标签：
排序学习总结
1.冒泡法
总结：第一种冒泡方法：第一个位置的数字和后面相连位置的数字比较。只要后面位置的数字更小，就进行数据交换，再第二个位置数字和其后面相连位置的数字比较，只要后面位置的数字更大，就进行数据交换。依次比较到最后一个数字。
原始待排序数组| 6 | 2 | 4 | 1 | 5 | 9 |
第一趟排序(外循环)
第一次两两比较6 > 2交换(内循环)
交换前状态| 6 | 2 | 4 | 1 | 5 | 9 |
交换后状态| 2 | 6 | 4 | 1 | 5 | 9 |
第二次两两比较,6 > 4交换
交换前状态| 2 | 6 | 4 | 1 | 5 | 9 |
交换后状态| 2 | 4 | 6 | 1 | 5 | 9 |
第三次两两比较,6 > 1交换
交换前状态| 2 | 4 | 6 | 1 | 5 | 9 |
交换后状态| 2 | 4 | 1 | 6 | 5 | 9 |
第四次两两比较,6 > 5交换
交换前状态| 2 | 4 | 1 | 6 | 5 | 9 |
交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |
第五次两两比较,6 < 9不交换
交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |
交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |
第二趟排序(外循环)
第一次两两比较2 < 4不交换
交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |
交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |
第二次两两比较,4 > 1交换
交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |
交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |
第三次两两比较,4 < 5不交换
交换前状态| 2 | 1 | 4 | 5 | 6 | 9 |
交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |
第四次两两比较,5 < 6不交换
交换前状态| 2 | 1 | 4 | 5 | 6 | 9 |
交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |
第三趟排序(外循环)
第一次两两比较2 > 1交换
交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |
交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |
第二次两两比较,2 < 4不交换
交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |
交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |
第三次两两比较,4 < 5不交换
交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |
交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |
第四趟排序(外循环)无交换
第五趟排序(外循环)无交换
排序完毕,输出最终结果1 2 4 5 6 9
function(array) { var i = 0, len = array.length, j, d; for (; i < len; i++) { for (j = 0; j < len-i; j++) { if (array[j] > array[j+1]) { d = array[j]; array[j] = array[i]; array[i] = d; } } } return array;}
2.选择排序
总结：首先假设第一个数字是最小值，记录下最小值和最小值的下标。第一个位置的数字和后面所有的数字依次比较。只要后面位置的数字更小，就进行数据交换。所以每一趟外循环后，第一个数字一定是余下数字的最小值。
原始待排序数组| 6 | 2 | 4 | 1 | 5 | 9 |
第一趟排序(外循环)
第一次两两比较6 > 2交换(内循环)
交换前状态| 6 | 2 | 4 | 1 | 5 | 9 |
交换后状态| 2 | 6 | 4 | 1 | 5 | 9 |
第二次两两比较,2< 4不交换
交换前状态| 2 | 6 | 4 | 1 | 5 | 9 |
交换后状态| 2 | 6 | 4 | 1 | 5 | 9 |
第三次两两比较,2> 1交换
交换前状态| 2 | 6 | 4 | 1 | 5 | 9 |
交换后状态| 1| 6 | 4 | 2 | 5 | 9 |
第四次两两比较,不交换
第五次两两比较,不交换
第二趟排序(外循环)
第一次两两比较6 > 4交换
交换前状态| 1 | 6 | 4 | 2 | 5 | 9 |
交换后状态| 1 | 4 | 6 | 2 | 5 | 9 |
第二次两两比较,4 > 2交换
交换前状态| 1 | 4 | 6 | 2 | 5 | 9 |
交换后状态| 1 | 2 | 6 | 4 | 5 | 9 |
第三次两两比较,不交换
第四次两两比较,不交换
第三趟排序(外循环)
第一次两两比较6 > 4交换
交换后状态| 1 | 2 | 6 | 4 | 5 | 9 |
交换后状态| 1 | 2 | 4 | 6 | 5 | 9 |
第二次两两比较,不交换
第三次两两比较,不交换
第四趟排序(外循环)
第一次两两比较6 > 4交换
交换后状态| 1 | 2 | 4 | 6 | 5 | 9 |
交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |
第二次两两比较,不交换
第五趟排序(外循环)无交换
排序完毕,输出最终结果1 2 4 5 6 9
function(array) { var i = 0, len = array.length, j, d; for (; i < len; i++) { for (j = i+1; j < len; j++) { if (array[i] >array[j]) { d = array[j]; array[j] = array[i]; array[i] = d; } } } return array;}
注：一开始我把冒泡排序与选择排序混淆了。
3.快速排序
总结：假设要排序的数组是A[0]……A[N]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它的数都放到它前面，所有比它大的数都放到它后面，这个过程称为快速排序。快速排序的算法是：
1）设置两个变量I、J，排序开始的时候I：=0，J：=N；
2）以第一个数组元素作为关键数据，赋值给X，即X：=A[0]；
3）从J开始向前搜索，即由后开始向前搜索（J：=J-1），找到第一个小于X的值，两者交换；
4）从I开始向后搜索，即由前开始向后搜索（I：=I+1），找到第一个大于X的值，两者交换；
5）重复第3、4步，直到I=J；
注：关键数据时不变的。
// 快速排序 function(array) { //var array = [8,4,6,2,7,9,3,5,74,5]; //var array = [0,1,2,44,4,324,5,65,6,6,34,4,5,6,2,43,5,6,62,43,5,1,4,51,56,76,7,7,2,1,45,4,6,7]; var i = 0; var j = array.length - 1; var Sort = function(i, j) { // 结束条件 if (i == j) { return }; var key = array[i]; var stepi = i; // 记录开始位置 var stepj = j; // 记录结束位置 while (j > i) { // j <<-------------- 向前查找 if (array[j] >= key) { j--; } else { array[i] = array[j]； //i++ ------------>>向后查找 while (j > ++i) { if (array[i] > key) { array[j] = array[i]; break; } } } } // 如果第一个取出的 key 是最小的数 if (stepi == i) { Sort(++i, stepj); return; } // 最后一个空位留给 key array[i] = key; // 递归
Sort(stepi, i); Sort(j, stepj); } Sort(i, j); return array;},
4.插入排序
总结：1.取关键数据：一开始取数组中第二个数作为关键数据，后面取第三个数据为关键数据，以此类推直到取到最后一个数据返回数组。2比较方法：把关键数据和前面第一个数据比较，如果这个数据大于关键数据数据，就把这个数据数据赋值给关键数据所在数组位置。再把关键数据和前面第二个数据比较，如果这个数据大于关键数据，就把这个数据赋值给其后一个数据所在数组位置。以此类推。最后把关键数据插入最后一个比它大的数据位置。
例子：
//插入排序
static void insertion_sort(int[] unsorted)
{
for (int i = 1; i < unsorted.Length; i++)
{
if (unsorted[i - 1] > unsorted[i])
{
int temp = unsorted[i];
int j = i;
//如果前面的数据大于后面的数据，就交换位置
while (j > 0 && unsorted[j - 1] > temp)
{
unsorted[j] = unsorted[j - 1];
j--;
}
unsorted[j] = temp;
}
}
}
static void Main(string[] args)
{
int[] x = { 6, 2, 4, 1, 5, 9 };
insertion_sort(x);
foreach (var item in x)
{
if (item > 0)
Console.WriteLine(item + ",");
}
Console.ReadLine();
}
5.希尔排序
总结：希尔排序的步骤：1.选取增量。2.根据增量虚拟分成若干数组，各数组间进行插入排序。3.增量选取会逐步减小，直到最后一个增量是1,在进行插入排序。排序完后希尔排序就完成。
注：1.最后一个增量必须是1。2.用该避免选取增量（尤其是相连的值）互为倍数的情况。
例子：
static void shell_sort(int[] unsorted, int len)
{
int group, i, j, temp;
//group是选取的增量，从中间开始选取。
for (group = len / 2; group > 0; group /= 2) {
//虚拟分组进行插入排序。
for (i = group; i < len; i++)
{
for (j = i - group; j >= 0; j -= group)
{
//一般插入排序方法。
if (unsorted[j] > unsorted[j + group])
{
//如果前面数据比后面大，就交换位置。
temp = unsorted[j];
unsorted[j] = unsorted[j + group];
unsorted[j + group] = temp;
}
}
}
}
}
static void Main(string[] args)
{
int[] x = { 6, 2, 4, 1, 5, 9 };
shell_sort(x, x.Length);
foreach (var item in x)
{
Console.WriteLine(item);
}
Console.ReadLine();
}
标签：
原文地址：http://www.cnblogs.com/lihui1256/p/4883152.html
