分类:
1)插入排序(直接插入排序、希尔排序)
2)交换排序(冒泡排序、快速排序)
3)选择排序(直接选择排序、堆排序)
4)归并排序
5)分配排序(基数排序)
所需辅助空间最多:归并排序
所需辅助空间最少:堆排序
平均速度最快:快速排序
不稳定:快速排序,希尔排序,堆排序。
-
- private static final int[] NUMBERS =
- {49, 38, 65, 97, 76, 13, 27, 78, 34, 12, 64, 5, 4, 62, 99, 98, 54, 56, 17, 18, 23, 34, 15, 35, 25, 53, 51};
1. 直接插入排序
基本思想:在要排序的一组数中,假设前面(n-1)[n>=2] 个数已经是排
好顺序的,现在要把第n个数插到前面的有序数中,使得这n个数
也是排好顺序的。如此反复循环,直到全部排好顺序。
- public static void insertSort(int[] array) {
- for (int i =0; i < array.length; i++) {//从下标0开始,循坏
- int temp = array[i];//把每次循坏的数值赋值给temp
- int j = i - 1; //防止下标越界
- for (; j >= 0 && array[j] > temp; j--) { //进行比较大小,
-
- array[j + 1] = array[j];
- }
- array[j + 1] = temp;
- }
- System.out.println(Arrays.toString(array) + " insertSort");
- }
2. 希尔排序
希尔排序,也称递减增量排序算法,是插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法。
希尔排序是基于插入排序的以下两点性质而提出改进方法的:
插入排序在对几乎已经排好序的数据操作时,效率高,即可以达到线性排序的效率;
但插入排序一般来说是低效的,因为插入排序每次只能将数据移动一位。
先取一个正整数d1 < n, 把所有相隔d1的记录放一组,每个组内进行直接插入排序;然后d2 < d1,重复上述分组和排序操作;直至di = 1,即所有记录放进一个组中排序为止。
- public static void shellSort(int[] array) {
- int i;
- int j;
- int temp;
- int gap = 1;
- int len = array.length;
- while (gap < len / 3) { gap = gap * 3 + 1; }
- for (; gap > 0; gap /= 3) {
- for (i = gap; i < len; i++) {
- temp = array[i];
- for (j = i - gap; j >= 0 && array[j] > temp; j -= gap) {
- array[j + gap] = array[j];
- }
- array[j + gap] = temp;
- }
- }
- System.out.println(Arrays.toString(array) + " shellSort");
- }
3. 简单选择排序
基本思想:在要排序的一组数中,每一趟从待排序的数据元素中选择最小(或最大)的一个元素作为首元素,直到所有元素排完为止,简单选择排序是不稳定排序。
然后在剩下的数当中再找最小的与第二个位置的数交换,如此循环到倒数第二个数和最后一个数比较为止。
- public static void selectSort(int[] array) {
- for (int i = 0; i < array.length-1; i++) {//外层循环控制排序趟数
- for ( int j = i + 1; j < array.length; j++) { //每次循环,下标加1。每次循坏去掉上次得数
- if (array[i] > array[j]) { //进行比较大小
- int temp = array[i]; //赋值
- array[i]=array[j] ;//要是是比赋值的temp数小,就赋值给循坏的下标
- array[j]=temp;//再把原元素赋值给它
- }
- }
-
- }
- System.out.println(Arrays.toString(array) + " selectSort");
- }
4. 堆排序
基本思想:堆排序是一种树形选择排序,是对直接选择排序的有效改进。
堆的定义如下:具有n个元素的序列(h1,h2,...,hn),当且仅当满足(hi>=h2i,hi>=2i+1)或(hi<=h2i,hi<=2i+1)(i=1,2,...,n/2)时称之为堆。在这里只讨论满足前者条件的堆。由堆的定义可以看出,堆顶元素(即第一个元素)必为最大项(大顶堆)。完全二叉树可以很直观地表示堆的结构。堆顶为根,其它为左子树、右子树。初始时把要排序的数的序列看作是一棵顺序存储的二叉树,调整它们的存储序,使之成为一个堆,这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。依此类推,直到只有两个节点的堆,并对它们作交换,最后得到有n个节点的有序序列。从算法描述来看,堆排序需要两个过程,一是建立堆,二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数,二是反复调用渗透函数实现排序的函数。
建堆:
交换,从堆中踢出最大数
剩余结点再建堆,再交换踢出最大数
依次类推:最后堆中剩余的最后两个结点交换,踢出一个,排序完成。
- public static void heapSort(int[] array) {
-
-
-
-
-
-
- int len = array.length - 1;
- int beginIndex = (len - 1) >> 1;
- for (int i = beginIndex; i >= 0; i--) {
- maxHeapify(i, len, array);
- }
-
-
-
-
-
-
- for (int i = len; i > 0; i--) {
- swap(0, i, array);
- maxHeapify(0, i - 1, array);
- }
- System.out.println(Arrays.toString(array) + " heapSort");
- }
- private static void swap(int i, int j, int[] arr) {
- int temp = arr[i];
- arr[i] = arr[j];
- arr[j] = temp;
- }
-
-
-
-
-
-
- private static void maxHeapify(int index, int len, int[] arr) {
- int li = (index << 1) + 1;
- int ri = li + 1;
- int cMax = li;
- if (li > len) {
- return;
- }
- if (ri <= len && arr[ri] > arr[li])
- { cMax = ri; }
- if (arr[cMax] > arr[index]) {
- swap(cMax, index, arr);
- maxHeapify(cMax, len, arr);
- }
- }
5. 冒泡排序
基本思想:在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒。即:每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换。
- public static void bubbleSort(int[] array) {
- for (int i = 0; i < array.length - 1; i++) { //外层循环控制排序趟数
- for (int j = 0; j < array.length - 1 - i; j++) { //对当前无序区间score[0......length-i-1]进行排序(j的范围很关键,这个范围是在逐步缩小的)内层循环控制每一趟排序多少次
- if (array[j] > array[j + 1]) {
- int temp = array[j];
- array[j] = array[j + 1];
- array[j + 1] = temp;
- }
- }
- }
- System.out.println(Arrays.toString(array) + " bubbleSort");
- }
6. 快速排序
基本思想:选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描,将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。
- public static void quickSort(int[] array) {
- _quickSort(array, 0, array.length - 1);
- System.out.println(Arrays.toString(array) + " quickSort");
- }
-
-
- private static int getMiddle(int[] list, int low, int high) {
- int tmp = list[low];
- while (low < high) {
- while (low < high && list[high] >= tmp) {
- high--;
- }
-
-
- list[low] = list[high];
- while (low < high && list[low] <= tmp) {
- low++;
- }
-
-
- list[high] = list[low];
- }
- list[low] = tmp;
- return low;
- }
-
-
- private static void _quickSort(int[] list, int low, int high) {
- if (low < high) {
- int middle = getMiddle(list, low, high);
- _quickSort(list, low, middle - 1);
- _quickSort(list, middle + 1, high);
- }
- }
7、归并排序
基本排序:归并(Merge)排序法是将两个(或两个以上)有序表合并成一个新的有序表,即把待排序序列分为若干个子序列,每个子序列是有序的。然后再把有序子序列合并为整体有序序列。
- public static void mergingSort(int[] array) {
- sort(array, 0, array.length - 1);
- System.out.println(Arrays.toString(array) + " mergingSort");
- }
-
- private static void sort(int[] data, int left, int right) {
- if (left < right) {
-
- int center = (left + right) / 2;
-
- sort(data, left, center);
-
- sort(data, center + 1, right);
-
- merge(data, left, center, right);
- }
- }
-
- private static void merge(int[] data, int left, int center, int right) {
- int[] tmpArr = new int[data.length];
- int mid = center + 1;
-
- int third = left;
- int tmp = left;
- while (left <= center && mid <= right) {
-
- if (data[left] <= data[mid]) {
- tmpArr[third++] = data[left++];
- } else {
- tmpArr[third++] = data[mid++];
- }
- }
-
-
- while (mid <= right) {
- tmpArr[third++] = data[mid++];
- }
-
- while (left <= center) {
- tmpArr[third++] = data[left++];
- }
-
-
- while (tmp <= right) {
- data[tmp] = tmpArr[tmp++];
- }
- }
8、基数排序
基本思想:将所有待比较数值(正整数)统一为同样的数位长度,数位较短的数前面补零。然后,从最低位开始,依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。
- public static void radixSort(int[] array) {
-
- int max = array[0];
- for (int i = 1; i < array.length; i++) {
- if (array[i] > max) {
- max = array[i];
- }
- }
- int time = 0;
-
- while (max > 0) {
- max /= 10;
- time++;
- }
-
-
-
- ArrayList<ArrayList<Integer>> queue = new ArrayList<>();
- for (int i = 0; i < 10; i++) {
- ArrayList<Integer> queue1 = new ArrayList<>();
- queue.add(queue1);
- }
-
-
-
- for (int i = 0; i < time; i++) {
-
- for (int anArray : array) {
-
- int x = anArray % (int)Math.pow(10, i + 1) / (int)Math.pow(10, i);
- ArrayList<Integer> queue2 = queue.get(x);
- queue2.add(anArray);
- queue.set(x, queue2);
- }
- int count = 0;
-
- for (int k = 0; k < 10; k++) {
- while (queue.get(k).size() > 0) {
- ArrayList<Integer> queue3 = queue.get(k);
- array[count] = queue3.get(0);
- queue3.remove(0);
- count++;
- }
- }
- }
- System.out.println(Arrays.toString(array) + " radixSort");
- }
结果
先定义个交换数组元素的函数,供排序时调用
/**
* 交换数组元素
* @param arr
* @param a
* @param b
*/
public static void swap(int []arr,int a,int b){
arr[a] = arr[a]+arr[b];
arr[b] = arr[a]-arr[b];
arr[a] = arr[a]-arr[b];
}
简单选择排序
简单选择排序是最简单直观的一种算法,基本思想为每一趟从待排序的数据元素中选择最小(或最大)的一个元素作为首元素,直到所有元素排完为止,简单选择排序是不稳定排序。
在算法实现时,每一趟确定最小元素的时候会通过不断地比较交换来使得首位置为当前最小,交换是个比较耗时的操作。其实我们很容易发现,在还未完全确定当前最小元素之前,这些交换都是无意义的。我们可以通过设置一个变量min,每一次比较仅存储较小元素的数组下标,当轮循环结束之后,那这个变量存储的就是当前最小元素的下标,此时再执行交换操作即可。代码实现很简单,一起来看下。
代码实现
/**
* 简单选择排序
*
* @param arr
*/
public static void selectSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
int min = i;//每一趟循环比较时,min用于存放较小元素的数组下标,这样当前批次比较完毕最终存放的就是此趟内最小的元素的下标,避免每次遇到较小元素都要进行交换。
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[min]) {
min = j;
}
}
//进行交换,如果min发生变化,则进行交换
if (min != i) {
swap(arr,min,i);
}
}
}
简单选择排序通过上面优化之后,无论数组原始排列如何,比较次数是不变的;对于交换操作,在最好情况下也就是数组完全有序的时候,无需任何交换移动,在最差情况下,也就是数组倒序的时候,交换次数为n-1次。综合下来,时间复杂度为O(n2)
冒泡排序
冒泡排序的基本思想是,对相邻的元素进行两两比较,顺序相反则进行交换,这样,每一趟会将最小或最大的元素“浮”到顶端,最终达到完全有序
代码实现
在冒泡排序的过程中,如果某一趟执行完毕,没有做任何一次交换操作,比如数组[5,4,1,2,3],执行了两次冒泡,也就是两次外循环之后,分别将5和4调整到最终位置[1,2,3,4,5]。此时,再执行第三次循环后,一次交换都没有做,这就说明剩下的序列已经是有序的,排序操作也就可以完成了,来看下代码
/**
* 冒泡排序
*
* @param arr
*/
public static void bubbleSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
boolean flag = true;//设定一个标记,若为true,则表示此次循环没有进行交换,也就是待排序列已经有序,排序已然完成。
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
swap(arr,j,j+1);
flag = false;
}
}
if (flag) {
break;
}
}
}
根据上面这种冒泡实现,若原数组本身就是有序的(这是最好情况),仅需n-1次比较就可完成;若是倒序,比较次数为 n-1+n-2+...+1=n(n-1)/2,交换次数和比较次数等值。所以,其时间复杂度依然为O(n2)。综合来看,冒泡排序性能还还是稍差于上面那种选择排序的。
直接插入排序
直接插入排序基本思想是每一步将一个待排序的记录,插入到前面已经排好序的有序序列中去,直到插完所有元素为止。
代码实现
/**
* 插入排序
*
* @param arr
*/
public static void insertionSort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
int j = i;
while (j > 0 && arr[j] < arr[j - 1]) {
swap(arr,j,j-1);
j--;
}
}
}
简单插入排序在最好情况下,需要比较n-1次,无需交换元素,时间复杂度为O(n);在最坏情况下,时间复杂度依然为O(n2)。但是在数组元素随机排列的情况下,插入排序还是要优于上面两种排序的。