常见的排序算法
一、冒泡排序
冒泡排序(BubbleSort)的基本概念是:依次比较相邻的两个数,将小数放在前面,大数放在后面。即在第一趟:首先比较第1个和第2个数,将小数放前,大数放后。然后比较第2个数和第3个数,将小数放前,大数放后,如此继续,直至比较最后两个数,将小数放前,大数放后。至此第一趟结束,将最大的数放到了最后。在第二趟:仍从第一对数开始比较(因为可能由于第2个数和第3个数的交换,使得第1个数不再小于第2个数),将小数放前,大数放后,一直比较到倒数第二个数(倒数第一的位置上已经是最大的),第二趟结束,在倒数第二的位置上得到一个新的最大数(其实在整个数列中是第二大的数)。如此下去,重复以上过程,直至某一趟的交换顺序为0,最终完成排序。
例如对10,-3,5,34,-34,5,0,9进行排序
第一趟:-3,5,10,-34,5,0,9,34
第二趟:-3,5,-34,5,0,9,10,34
第三趟:-3,-34,5,5,0,9,10,34
第四趟:-34,-3,5,0,5,9,10,34
第五趟:-34,-3,0,5,5,9,10,34
import junit.framework.TestCase; public class BubbleSort extends TestCase { public void sort(Integer a[]) { boolean exchange = false; // 某一趟的交换次数为0 for (int i = a.length - 1; i > 0; i--) { for (int j = 0; j < i; j++) { if (a[j + 1] < a[j]) { exchange = true; Integer temp = a[j + 1]; a[j + 1] = a[j]; a[j] = temp; } } if (!exchange) { //如果本趟排序次数为0,表示排序次数为0 break; } } } public void test() { Integer a[] = {10,-3,5,34,-34,5,0,9 }; sort(a); for (int i = 0; i < a.length; i++) { System.out.print(a[i] + "、"); } } }
二、选择排序
每一趟从待排序的数据元素中选出最小(或最大)的一个元素,顺序放在已排好序的数列的最后,直到全部待排序的数据元素排完。选择排序是不稳定的排序方法。
初始 [49 38 65 97 76 13 27 49]
第一趟排序后 13 [38 65 97 76 49 27 49]
第二趟排序后 13 27 [65 97 76 49 38 49]
第三趟排序后 13 27 38 [97 76 49 65 49]
第四趟排序后 13 27 38 49 [76 97 65 49]
第五趟排序后 13 27 38 49 49 [97 65 76]
第六趟排序后 13 27 38 49 49 65 [97 76]
第七趟排序后 13 27 38 49 49 65 76 [97]
最后排序结果 13 27 38 49 49 65 76 97
import junit.framework.TestCase; public class CollectSort extends TestCase { // 选择排序 public void sort(Integer a[]) { int min; int temp; for (int i = 0; i < a.length - 1; i++) { min = i; // 本次排序最小的 for (int j = i + 1; j < a.length; j++) { if (a[j] < a[min]) { min = j; } } if (min != i) { temp = a[min]; a[min] = a[i]; a[i] = temp; } } } public void test() { Integer array[] = { 49, 38, 65, 97, 76, 13, 27, 49 }; sort(array); for (int i = 0; i < array.length; i++) { System.out.print(array[i] + " "); } } }
三、快速排序
快速排序它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
public class QuickSort { public static void sort(Comparable[] data, int low, int high) { // 枢纽元,一般以第一个元素为基准进行划分 int i = low; int j = high; if (low < high) { // 从数组两端交替地向中间扫描 Comparable pivotKey = data[low]; // 进行扫描的指针i,j;i从左边开始,j从右边开始 while (i < j) { while (i < j && data[j].compareTo(pivotKey) > 0) { j--; }// end while if (i < j) { // 比枢纽元素小的移动到左边 data[i] = data[j]; i++; }// end if while (i < j && data[i].compareTo(pivotKey) < 0) { i++; }// end while if (i < j) { // 比枢纽元素大的移动到右边 data[j] = data[i]; j--; }// end if }// end while // 枢纽元素移动到正确位置 data[i] = pivotKey; // 前半个子表递归排序 sort(data, low, i - 1); // 后半个子表递归排序 sort(data, i + 1, high); }// end if }// end sort public static void main(String[] args) { // 在JDK1.5版本以上,基本数据类型可以自动装箱 // int,double等基本类型的包装类已实现了Comparable接口 Comparable[] c = { 49 ,38, 65, 97, 76, 13, 27 }; sort(c, 0, c.length - 1); for (Comparable data : c) { System.out.println(data); } } }
四、直接插入排序
插入排序(insert sorting)思想:当插入第i个元素时,前面的v[0],v[1],v[2]......v[i-1],已经排好序了.这时用v[i]的插入码与v[i-1],v[i-2],......排序码进行比较,找到插入的位置即插入v[i],原来位置上的元素从后向前依次后移。
第一趟比较前两个数,然后把第二个数按大小插入到有序表中; 第二趟把第三个数据与前两个数从前向后扫描,把第三个数按大小插入到有序表中;依次进行下去,进行了(n-1)趟扫描以后就完成了整个排序过程。
直接插入排序属于稳定的排序,最坏时间复杂性为O(n2),空间复杂度为O(1)。
例子
[46] 58 15 45 90 18 10 62
[15 46] 58 45 90 18 10 62
[15 45 46] 58 90 18 10 62
[15 45 46 58] 90 18 10 62
[15 18 45 46 58] 90 10 62
[10 15 18 45 46 58] 90 62
[10 15 18 45 46 58 62] 90
public class Straight_Insert_Sort { public static void sort(Comparable array[]) { int i, j; Comparable temp; for (i = 1; i < array.length; i++) { temp = array[i]; for (j = 0; j < i; j++) { if (array[j].compareTo(array[i]) > 0) { for (int k = i; k > j; k--) { array[k] = array[k - 1]; } array[j] = temp; break; } } //以下的代码只是为了打印输出 System.out.print("["); j = 0; for (j = 0; j <= i - 1; j++) { System.out.print(array[j] + " "); } System.out.print(array[i]); System.out.print("] "); for (j = i+1; j < array.length; j++) { System.out.print(array[j] + " "); } System.out.println(); } } public static void main(String[] args) { Integer array[] = { 46, 58, 15, 45, 90, 18, 10, 62 }; sort(array); } } /* [46 58] 15 45 90 18 10 62 [15 46 58] 45 90 18 10 62 [15 45 46 58] 90 18 10 62 [15 45 46 58 90] 18 10 62 [15 18 45 46 58 90] 10 62 [10 15 18 45 46 58 90] 62 [10 15 18 45 46 58 62 90] */