数据结构排序算法总结-CSDN博客

本文链接：https://blog.csdn.net/qq_34739984/article/details/51482333

常用的算法有插入排序、冒泡排序、选择排序、快速排序、归并排序、希尔排序、堆排序、计数排序和基数排序。下面对着九种常见排序方法进行总结：

排序方法	时间复杂度	空间复杂度	个人评价
插入排序	O(n^2)	O(1)
选择排序
冒泡排序
希尔排序	O(n log n)
快速排序		O( log n)
归并排序		O(n)
堆排序		O(1)
计数排序	O(n)	O(k)
堆排序	O(n)	O(n)

1.插入排序、选择排序和冒泡排序

插入排序：将排序的记录按照大小，插入到前面已经排好序部分的适当位置，直到整个数组有序为止。实现的核心代码为：

for (int i = 1; i < n; i++) {
	int tmp = arr[i];
	int j = 0;
	for (j = i; j > 0 && arr[j - 1] > tmp; j--) {
		arr[j] = arr[j - 1];
	}
	arr[j] = tmp;
     }

选择排序：每次遍历数组都会将最大（或者为最小）的元素，将其放置到数组尾部已排好序部分的前面，尾部排好序的部分不断增大，直到整个数组有序为止。另一种思路是从头部开始构建排好序的数组。实现的核心代码为：

for(int i=0; i<n-1; i++){
	int min = arr[i];  int position =i;
	for(int j=i+1;j<n; j++){
		if(arr[j] <min){
			min=arr[j];  position = j;
		}
	}
	int tmp = arr[i];
	arr[i]=min;
	arr[position]=tmp;
}

冒泡排序：每次遍历数组做的操作是比较i号位置元素与i+1号元素的大小，如果i号为止的元素大于i+1号元素，那么交换两个的位置。这样每次遍历都会将"最大"的元素交换到尾部。经过n次遍历，这个数组就变成有序数组了。关键代码如下：

for (int i = 0; i < n - 1; i++) {
	for (int j = 0; j < n - i - 1; j++) {
		if (arr[j] > arr[j + 1]) {
			int tmp = arr[j];
			arr[j]=arr[j+1];
			arr[j+1]=tmp;
		}
	}
}

2. 希尔排序、快速排序、归并排序和堆排序

希尔排序：排序思想来源于选择排序，选择步长为di的元素为一组，将数组分为di个组，每组进行插入排序。然后步长改为di/2，重复以上操作。当步长为0时结束，此时数组就是有序的了。关键代码如下：

while (feet > 0) {
	for (int i = feet; i < arr.length; i++) {
		index = i;
		while (index >= feet) {
			if (arr[index - feet] > arr[index]) {
				swap(arr, index - feet, index);
				index -= feet;
			} else {
				break;
			}
		}
	}
	feet /= 2;
     }

快速排序：这是一种分治策略，首先选择一个元素a作为左右两部分的分界，大于a的放在数组的右部，小于a的放在数组的左部分，最后将a放在“中间位置”。依照这一思想分别对左部分和右部分做同样的操作。如此分下去，最后会得到一个有序的数组。

   public static void process(int[] arr, int left, int right) {
		if (left < right) {
			int random = left + (int) (Math.random() * (right - left + 1));
			swap(arr, random, right);
			int mid = partition(arr, left, right);
			process(arr, left, mid - 1);
			process(arr, mid + 1, right);
		}
	}
	public static int partition(int[] arr, int left, int right) {
		int pivot = left - 1;
		int index = left;
		while (index <= right) {
			if (arr[index] <= arr[right]) {
				swap(arr, ++pivot, index);
			}
			index++;
		}
		return pivot;
	}

归并排序：将两个或两个以上的有序表合并成一个有序表。初始时，把长度为n的数组看成n个长度为1的有序表，然后将相邻的有序表两两合并，形成长度为2的有序表。重复以上操作，直到只剩下两个有序表，最后合并这两个有序表可得到最终的排序后的数组。关键代码如下：

public static void process(int[] arr, int left, int right) {
    if (left == right) {
        return;
    }
    int mid = (left + right) / 2;
    process(arr, left, mid);
    process(arr, mid + 1, right);
    merge(arr, left, mid, right);
}


public static void merge(int[] arr, int left, int mid, int right) {
    int[] help = new int[right - left + 1];
    int l = left;
    int r = mid + 1;
    int index = 0;
    while (l <= mid && r <= right) {
        if (arr[l] <= arr[r]) {
            help[index++] = arr[l++];
        } else {
            help[index++] = arr[r++];
        }
    }
    while (l <= mid) {
        help[index++] = arr[l++];
    }
    while (r <= right) {
        help[index++] = arr[r++];
    }
    for (int i = 0; i < help.length; i++) {
        arr[left + i] = help[i];
    }
}

堆排序：数组形式的完全二叉树。针对大根堆，每个节点的父节点的值大于任意一个子节点的值。这样我们就可以得到这个数组的最大值，然后将该最大值放在数组尾部排好序的部分，缩小大根堆的范围，根据这个原理，最后就可以得到一个有序的数组。

public int[] heapSort(int[] A, int n) {
		for (int i = n / 2; i >= 0; i--) {
			heapAdjust(A, i, n);
		}
		for (int i = n - 1; i > 0; i--) {
			swap(A, 0, i);  heapAdjust(A, 0, i);
		}
		return A;
	}
	void heapAdjust(int[] A, int index, int length) {
		int childLeft = 0;
		int temp = A[index];
		for (; index * 2 + 1 < length; index = childLeft) {
			childLeft = index * 2 + 1;
			if (childLeft != length - 1 && A[childLeft] < A[childLeft + 1]) {
				childLeft++;
			}
			if (temp > A[childLeft]) {
				break;
			} else {
				A[index] = A[childLeft];
				index = childLeft;
			}
		}
		A[index] = temp;
	}

3.计数排序和基数排序

计数排序：针对数组arr，得到这个数组的最大值max和最小值min，然后设置一个数组A（长度为max-min+1），A中i处元素代表min+i这个数出现的次数，遍历一遍数组arr后我们就可以填满A。最后只要遍历一遍数组A，就会得到一个排序后的数组了。

int min = arr[0];
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
	min = Math.min(arr[i], min);  max = Math.max(arr[i], max);
}
int[] countArr = new int[max - min + 1];
for (int i = 0; i < arr.length; i++) {
	countArr[arr[i] - min]++;
}
int index = 0;
for (int i = 0; i < countArr.length; i++) {
	while (countArr[i]-- > 0) {
		arr[index++] = i + min;
	}
}

基数排序：按照先按照每个数的个位进行排序合并成数组，然后再按照十位进行排序后合并数组，然后百位、千位.....直到得到有序数组。这里也用到了桶排序的概念。

public static void radixSort(int[] arr) {
		if (arr == null || arr.length < 2)  return;
		int negNum = 0;
		for (int i = 0; i < arr.length; i++)  negNum += arr[i] < 0 ? 1 : 0;
		int[] negArr = new int[negNum];
		int[] posArr = new int[arr.length - negNum];
		int negi = 0;  int posi = 0;
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] < 0)  negArr[negi++] = -arr[i];
			else  posArr[posi++] = arr[i];
		}
		radixSortForPositive(negArr);
		radixSortForPositive(posArr);
		int index = 0;
		for (int i = negArr.length - 1; i >= 0; i--) arr[index++] = -negArr[i];
		for (int i = 0; i < posArr.length; i++)  arr[index++] = posArr[i];
	}

public static void radixSortForPositive(int[] arr) {
		ArrayList<LinkedList<Integer>> qArr1 = new ArrayList<LinkedList<Integer>>();
		ArrayList<LinkedList<Integer>> qArr2 = new ArrayList<LinkedList<Integer>>();
		for (int i = 0; i < 10; i++) {
			qArr1.add(new LinkedList<Integer>());
			qArr2.add(new LinkedList<Integer>());
		}
		for (int i = 0; i < arr.length; i++) {
			qArr1.get(arr[i] % 10).offer(arr[i]);
		}
		long base = 10;
		while (base <= Integer.MAX_VALUE) {
			for (int i = 0; i < 10; i++) {
				LinkedList<Integer> queue = qArr1.get(i);
				while (!queue.isEmpty()) {
					int value = queue.poll();
					qArr2.get((int) (value / base) % 10).offer(value);
				}
			}
			ArrayList<LinkedList<Integer>> tmp = qArr1;
			qArr1 = qArr2;
			qArr2 = tmp;
			base *= 10;
		}
		int index = 0;
		for (int i = 0; i < 10; i++) {
			LinkedList<Integer> queue = qArr1.get(i);
			while (!queue.isEmpty()) {
				arr[index++] = queue.poll();
			}
		}
	}