关于常用排序算法的一个总结

Posted 2020-10-23 beststrive

　　前段时间被人问到排序算法，今天特此总结一下，冒泡，选择，快排，归并，插入这五种排序算法。

　　1.选择排序

　　选择排序是整体对比，每次选出你最需要的那个值，比如以下代码，首先选出最小的值，从小实现从小到大排序，外循环一次，内部循环记录下最小的坐标，只发生一次交换，它是一种稳定的排序算法，时间复杂度为o(n²),核心代码如下：

int[] numberArray = { 22, 32, 12, 1, 5, 66 };
		int arraylength = numberArray.length;
		int temp = 0;
		for (int i = 0; i < arraylength - 1; i++) {
			int k = i;
			for (int j = i + 1; j < arraylength; j++) {
				if (numberArray[k] > numberArray[j]) {
					k = j;
				}
			}

			if (i != k) {
				temp = numberArray[i];
				numberArray[i] = numberArray[k];
				numberArray[k] = temp;
			}
		}
		System.out.println(Arrays.toString(numberArray));

　　2.冒泡排序

　　冒泡排序的核心思路是相邻元素进行对比，把大的数往后移,外循环一次，内部循环可能会发生很多次交换，它是一种稳定的算法，时间复杂度为o(n²)，核心代码如下：

int[] numberArray = { 22, 32, 12, 1, 5, 66 };
        int arraylength = numberArray.length;
        int temp = 0;
        for (int i = 0; i < arraylength - 1; i++) {
            for (int j = i + 1; j < arraylength; j++) {
                if (numberArray[i] > numberArray[j]) {
                    temp = numberArray[i];
                    numberArray[i] = numberArray[j];
                    numberArray[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(numberArray));

 

　　3.插入排序

　　插入排序通过默认一个正确的位置，然后寻找插入位置，有点像我们完斗地主时，会把连牌挨着大小放着，它也是一种稳定的排序算法，时间复杂度为o(n²),核心代码如下：

int[] numberArray = { 22, 32, 12, 1, 5, 66 };
		for (int i = 1; i < numberArray.length; i++) {
			////把j看作一个游标
			int j = i;
			int target = numberArray[i];
			while (j > 0 && target < numberArray[j - 1]) {
				//// 说明有更大的，往后移
				numberArray[j] = numberArray[j - 1];
				j--;
			}

			numberArray[j] = target;
		}
		System.out.println(Arrays.toString(numberArray));

　　4.快速排序

　　快速排序的核心是冒泡+二分+递归分治，实际应用中算是最好的排序算法了，但它是一种不稳定的排序算法，平均时间复杂度为o(nlgn),最坏的情况是o(n²),它和冒泡算法的区别是同时查找大的数和小的数，核心代码如下：

　　

public static void main(String[] args) {
		try {
			int[] numberArray = new int[] { 4, 3, 6, 1, 2, 5 };
			recursionSort(numberArray, 0, numberArray.length - 1);
			System.out.println(Arrays.toString(numberArray));
		} catch (Exception ex) {
			System.out.println(ex.getMessage());
		}
	}

	private static void recursionSort(int[] numberArray, int low, int high) {
		if (low < high) {
			int basevalueIndex = partitionGroup(numberArray, low, high);
			////左区间递归
			recursionSort(numberArray, low, basevalueIndex - 1);
			////右区间递归
			recursionSort(numberArray, basevalueIndex + 1, high);
		}
	}

	private static int partitionGroup(int[] numberArray, int low, int high) {
		int basevalue = numberArray[low];
		while (low < high) {
			//// 先从右向左
			while (low < high && numberArray[high] >= basevalue) {
				--high;
			}
			//// 交换比基准值小的到左边
			numberArray[low] = numberArray[high];
			while (low < high && numberArray[low] <= basevalue) {
				++low;
			}

			//// 交互比基准值大的到右边
			numberArray[high] = numberArray[low];
		}

		//// 扫描完成，左右下标，即low=high
		numberArray[low] = basevalue;

		//// 返回基准值的下标
		return low;
	}

 

　　5.归并排序

 

 　　理论上归并排序的效率应该高于快速排序，但是由于赋值次数较多以及分配临时数组等，所以和快排的效率应该不相上下。它的思路就是把原始数组序列不断两两分块，直到每一个块只剩下一个元素，然后利用递归的原理合并即可，它是一种稳定的排序算法，时间复杂度为o(n²)，核心代码如下：

　　

public static void main(String[] args) {
		try {
			int[] numberArray = new int[] { 4, 3, 6, 1, 2, 5 };
			partition(numberArray, 0, numberArray.length - 1);
		} catch (Exception ex) {
			System.out.println(ex.getMessage());
		}
	}

	public static void partition(int[] a, int low, int high) {
		int mid = (low + high) / 2;
		if (low < high) {
			// 左边
			partition(a, low, mid);
			// 右边
			partition(a, mid + 1, high);
			// 左右归并
			merge(a, low, mid, high);
			System.out.println(Arrays.toString(a));
		}

	}

	public static void merge(int[] numberArray, int low, int mid, int high) {
		int[] temp = new int[high - low + 1];
		//// 左指针
		int i = low;
		// 右指针
		int j = mid + 1;
		int k = 0;
		// 把较小的数先移到新数组中
		while (i <= mid && j <= high) {
			if (numberArray[i] < numberArray[j]) {
				temp[k++] = numberArray[i++];
			} else {
				temp[k++] = numberArray[j++];
			}
		}
		// 把左边剩余的数移入数组
		while (i <= mid) {
			temp[k++] = numberArray[i++];
		}
		// 把右边边剩余的数移入数组
		while (j <= high) {
			temp[k++] = numberArray[j++];
		}
		// 把新数组中的数覆盖nums数组
		for (int k2 = 0; k2 < temp.length; k2++) {
			numberArray[k2 + low] = temp[k2];
		}
	}