排序算法基础总结

Posted 2022-10-17 少年风华正茂

算法基础总结

• 经典算法java代码实现
• • 1.冒泡排序
  • 2.选择排序
  • 3.插入排序
  • 4.归并排序
  • 5.快速排序
  • 6.堆排序
  • 7.交换两个数的值

经典算法java代码实现

1.冒泡排序

	/***
	 * @冒泡排序
	 * @BubbleSort
	 * @param arr
	 */
	public static void BubbleSort(int[] arr)
		if(arr == null || arr.length<2)
			return;
		
		for(int i = arr.length-1;i>0;i--)
			for(int j=0;j<i;j++)
				if(arr[j]>arr[j+1])
					swap(arr,i,j);
			
		
	

2.选择排序

	/***
	 * @选择排序
	 * @SelectionSort 两个指针，一个遍历指针，一个指向当前的最值
	 * @param arr
	 */
	public static void SelectionSort(int[] arr)
		if(arr == null || arr.length<2)
			return;
		
		for (int i = 0; i < arr.length - 1; i++) 
			int minIndex = i;
			for (int j = i + 1; j < arr.length; j++) 
				minIndex = arr[j] < arr[minIndex] ? j : minIndex;
			
			swap(arr, i, minIndex);
		
	

3.插入排序

	/***
	 * @插入排序
	 * @InsertionSort
	 * @param arr
	 */
	public static void InsertionSort(int[] arr)
		if(arr == null || arr.length<2)
			return;
		
		for(int i = 1 ; i < arr.length;i++)
			for(int j = i-1 ; j >=0;j--)
				if(arr[j]<arr[j+1])
					swap(arr,j,j+1);
				else
					break;
			
		
	

4.归并排序

	/***
	 * @归并排序
	 * @mergeSort
	 * @param arr
	 */
	public static void mergeSort(int[] arr) 
		if (arr == null || arr.length < 2) 
			return;
		
		mergeSort(arr, 0, arr.length - 1);
	
	
	public static void mergeSort(int[] arr, int l, int r) 
		if (l == r) 
			return;
		
		int mid = l + ((r - l) >> 1);
		mergeSort(arr, l, mid);
		mergeSort(arr, mid + 1, r);
		merge(arr, l, mid, r);
	
	//两个有序数组 (l-m) (m+1 - r)的合并
	public static void merge(int[] arr, int l, int m, int r) 
		int[] help = new int[r - l + 1];//R-L+1
		int i = 0;
		int p1 = l;
		int p2 = m + 1;
		while (p1 <= m && p2 <= r) 
			help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
		
		while (p1 <= m) 
			help[i++] = arr[p1++];
		
		while (p2 <= r) 
			help[i++] = arr[p2++];
		
		for (i = 0; i < help.length; i++) 
			arr[l + i] = help[i];
		
	

5.快速排序

	/***
	 * @快速排序  应用：荷兰国旗问题
	 * @quickSort
	 * @param arr
	 */
	public static void quickSort(int[] arr) 
		if (arr == null || arr.length < 2) 
			return;
		
		quickSort(arr, 0, arr.length - 1);
	

	public static void quickSort(int[] arr, int l, int r) 
		if (l < r) 
			swap(arr, l + (int) (Math.random() * (r - l + 1)), r);//随机快排，L-R上随机选个位置和R上的交换
			int[] p = partition(arr, l, r);
			quickSort(arr, l, p[0] - 1);
			quickSort(arr, p[1] + 1, r);
		
	

	public static int[] partition(int[] arr, int l, int r) //以R位置上的数为参考值，小的左边，大的右边，等于的放中间
		int less = l - 1;
		int more = r;
		while (l < more) 
			if (arr[l] < arr[r]) 
				swap(arr, ++less, l++);
			 else if (arr[l] > arr[r]) 
				swap(arr, --more, l);
			 else 
				l++;
			
		
		swap(arr, more, r);
		return new int[]  less + 1, more ;
	

6.堆排序

	/***
	 * @堆排序
	 * 1.求大根堆
	 * 2.交换首尾
	 * 3.通过heapify下沉首节点
	 * @heapSort
	 * @param arr
	 */
	public static void heapSort(int[] arr) 
		if (arr == null || arr.length < 2) 
			return;
		
		for (int i = 0; i < arr.length; i++) //构建初始大根堆
			heapInsert(arr, i);
		
		int size = arr.length;
		swap(arr, 0, --size);
		while (size > 0) 
			heapify(arr, 0, size);//构建出大根堆
			swap(arr, 0, --size);
		
	
	public static void heapInsert(int[] arr, int index) //构造大根堆，index与其父节点比较
		while (arr[index] > arr[(index - 1) / 2]) //arr[(0-1)/2] = arr[0]
			swap(arr, index, (index - 1) / 2);
			index = (index - 1) / 2;
		
	
	public static void heapify(int[] arr, int index, int size) //由于将最大值和arr[0]互换，不规范的节点往下沉的过程
		int left = index * 2 + 1;//index的左孩子
		while (left < size) 
			int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left;//记录当前孩子节点的最大值下标
			largest = arr[largest] > arr[index] ? largest : index;//记录当前子树（三个结点）的最大值下表
			if (largest == index) 
				break;
			
			swap(arr, largest, index);//交换最大值
			index = largest;
			left = index * 2 + 1;
		
	

7.交换两个数的值

	/***
	 * @公共调用方法
	 * @采用两次异或交换两个数 
	 * @swap a,b
	 * @param arr
	 * @param i
	 * @param j
	 */
	public static void swap(int[] arr,int i,int j)
		arr[i] = arr[i]^arr[j];
		arr[j] = arr[i]^arr[j];
		arr[i] = arr[i]^arr[j];