快速排序（Quicksort）是对冒泡排序的一种改进。设要排序的数组是 A[0]……A[N-1]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面， 这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。
更多信息请参考：http://baike.baidu.com/view/115472.htm
C语言代码：
1 #include <stdlib.h> 2 #include <stdio.h> 3 #include <memory.h> 4 #include <time.h> 5 6 void init(int *array, int count) 7 { 8 int n = 0; 9 srand((unsigned int)time(NULL)); 10 11 for (n=0; n<count; n++) 12 { 13 array[n] = rand()%100 + 1; 14 } 15 } 16 17 void output(int *array, int count) 18 { 19 int n = 0; 20 for (n=0; n<count; n++) 21 { 22 printf("%5d", array[n]); 23 } 24 25 printf("\n"); 26 } 27 28 /* 快速排序的具体实现，排正序 */ 29 void qsort_asc(int* array, int left, int right) 30 { 31 int i = 0; 32 int j = 0; 33 int pivot = 0; 34 35 if (left < right) 36 { 37 // 这个条件用来结束递归 38 i = left; 39 j = right; 40 pivot= array[i]; 41 42 while (i < j) 43 { 44 while (i < j && array[j]>pivot) 45 { 46 j--; // 从右向左找第一个小于pivot的数 47 } 48 49 if (i < j) 50 { 51 array[i] = array[j]; 52 i++; 53 } 54 55 while (i < j &&array[i]<pivot) 56 { 57 i++; // 从左向右找第一个大于pivot的数 58 } 59 60 if (i < j) 61 { 62 array[j] = array[i]; 63 j--; 64 } 65 } 66 67 array[i] =pivot; 68 qsort_asc(array, left, i-1); 69 qsort_asc(array, i+1, right); 70 } 71 } 72 73 /* 快速排序的具体实现，排倒序 */ 74 void qsort_desc(int* array, int left, int right) 75 { 76 int i = 0; 77 int j = 0; 78 int pivot = 0; 79 80 if (left < right) 81 { 82 // 这个条件用来结束递归 83 i = left; 84 j = right; 85 pivot= array[i]; 86 87 while (i < j) 88 { 89 while (i < j && array[j]<pivot) 90 { 91 j--; // 从右向左找第一个大于pivot的数 92 } 93 94 if (i < j) 95 { 96 array[i] = array[j]; 97 i++; 98 } 99 100 while (i < j &&array[i]>pivot) 101 { 102 i++; // 从左向右找第一个小于pivot的数 103 } 104 105 if (i < j) 106 { 107 array[j] = array[i]; 108 j--; 109 } 110 } 111 112 array[i] =pivot; 113 qsort_desc(array, left, i - 1); 114 qsort_desc(array, i + 1, right); 115 } 116 } 117 118 /* 快速排序 */ 119 void quicksort(int* array, int count, int type) 120 { 121 if (type == 0) 122 { 123 // 正排序，从小排到大 124 qsort_asc(array, 0, count-1); 125 } 126 else 127 { 128 // 倒排序，从大排到小 129 qsort_desc(array, 0, count-1); 130 } 131 } 132 133 int main() 134 { 135 const int count = 10; 136 int array[count]; 137 138 memset(array, 0, sizeof(int)*count); 139 140 init(array, count); 141 142 printf("data before sort: "); 143 output(array, count); 144 145 quicksort(array, count, 0); // 正排序，从小排到大 146 printf("data after sort(asc): "); 147 output(array, count); 148 149 quicksort(array, count, 1); // 倒排序，从大排到小 150 printf("data after sort(desc): "); 151 output(array, count); 152 153 return 0; 154 }
运行结果如下：
data before sort: 19 87 46 71 6 35 10 51 8 68
data after sort(asc): 6 8 10 19 35 46 51 68 71 87
data after sort(desc): 87 71 68 51 46 35 19 10 8 6
Java代码：
1 import java.util.Random; 2 3 /** 4 * 快速排序 快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。 步骤为： 5 * 1. 从数列中挑出一个元素，称为 "基准"（pivot）， 6 * 2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。 7 * 在这个分割之后，该基准是它的最后位置。这个称为分割（partition）操作。 8 * 3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。 9 * 递回的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递回下去，但是这个算法总会结束， 10 * 因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。 11 */ 12 13 public class Sort 14 { 15 /* 16 * 输出数组中的数据 17 */ 18 public static void OutputArray(int[] array) 19 { 20 for (int data : array) 21 { 22 System.out.print(data + "\t"); 23 } 24 25 System.out.println(); 26 } 27 28 /* 29 * 生成需要排序的数组 30 */ 31 public static int[] createArray(int count) 32 { 33 int array[] = new int[count]; 34 Random r = new Random(); 35 36 for (int i = 0; i < count; i++) 37 { 38 array[i] = r.nextInt(100); 39 } 40 41 System.out.println(""); 42 System.out.print("data before sort:\t"); 43 44 OutputArray(array); 45 46 return array; 47 } 48 49 /** 50 * 快速排序 51 */ 52 public static void quickSort(int[] array, String sortType) 53 { 54 if (sortType.equals("asc")) 55 { 56 // 正排序，从小排到大 57 qsort_asc(array, 0, array.length - 1); 58 } 59 else if (sortType.equals("desc")) 60 { 61 // 倒排序，从大排到小 62 qsort_desc(array,0,array.length-1); 63 } 64 else 65 { 66 System.out.println("parameter input error."); 67 } 68 } 69 70 /** 71 * 快速排序的具体实现，排正序 72 */ 73 public static void qsort_asc(int[] array, int left, int right) 74 { 75 int i, j,pivot; 76 if (left < right) 77 { 78 // 这个条件用来结束递归 79 i = left; 80 j = right; 81 pivot= array[i]; 82 while (i < j) 83 { 84 while (i < j && array[j]>pivot) 85 { 86 j--; // 从右向左找第一个小于pivot的数 87 } 88 89 if (i < j) 90 { 91 array[i] = array[j]; 92 i++; 93 } 94 95 while (i < j &&array[i]<pivot) 96 { 97 i++; // 从左向右找第一个大于pivot的数 98 } 99 100 if (i < j) 101 { 102 array[j] = array[i]; 103 j--; 104 } 105 } 106 107 array[i] =pivot; 108 qsort_asc(array, left, i - 1); 109 qsort_asc(array, i + 1, right); 110 } 111 } 112 113 /** 114 * 快速排序的具体实现，排倒序 115 */ 116 public static void qsort_desc(int[] array, int left, int right) 117 { 118 int i, j,pivot; 119 if (left < right) 120 { 121 // 这个条件用来结束递归 122 i = left; 123 j = right; 124 pivot= array[i]; 125 while (i < j) 126 { 127 while (i < j && array[j]<pivot) 128 { 129 j--; // 从右向左找第一个大于pivot的数 130 } 131 132 if (i < j) 133 { 134 array[i] = array[j]; 135 i++; 136 } 137 138 while (i < j &&array[i]>pivot) 139 { 140 i++; // 从左向右找第一个小于pivot的数 141 } 142 143 if (i < j) 144 { 145 array[j] = array[i]; 146 j--; 147 } 148 } 149 150 array[i] =pivot; 151 qsort_desc(array, left, i - 1); 152 qsort_desc(array, i + 1, right); 153 } 154 } 155 156 static int[] arr1=createArray(10); 157 158 public static void main(String[] args) 159 { 160 //int[] arr1=createArray(10); 161 162 System.out.print("data after sort(asc):\t"); 163 quickSort(arr1, "asc"); 164 OutputArray(arr1); 165 166 System.out.print("data after sort(desc):\t"); 167 quickSort(arr1, "desc"); 168 OutputArray(arr1); 169 } 170 }
排序结果如下：
data before sort: 46 41 69 13 3 24 62 37 67 94
data after sort(asc): 3 13 24 37 41 46 62 67 69 94
data after sort(desc): 94 69 67 62 46 41 37 24 13 3
转载于:https://www.cnblogs.com/yuanping/archive/2012/12/25/2833185.html