【程序28】
题目：对10个数进行排序
1.程序分析：八大排序算法
如果觉得篇幅太长，看这里 http://write.blog.csdn.net/postlist/6402914/null
扩展：八大排序算法
排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。
当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。
快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；
1.插入排序—直接插入排序(Straight Insertion Sort)
基本思想:
将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。
要点：设立哨兵，作为临时存储和判断数组边界之用。
直接插入排序示例：
如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。
算法的实现：
public class StraihtInertionSort {
//快速排序算法
public static int[] sort(int[] arr){
int n = arr.length;
for(int i=0; i<n-1 ; i++){
if(arr[i] > arr[i+1]){
//交换
int tmp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = tmp;
int index = i; //由于上面的交换，arr[i] < arr[i+1]的 ， 所以index存储的是即将要与前面所有数比较的索引即监视哨
int j=i-1;
while( j>=0 && arr[j] > arr[index] ){
//交换
int tmp1 = arr[j];
arr[j] = arr[index];
arr[index] = tmp1;
index = j;
j--;
}
}
}
return arr;
}
//打印数组
public static void print(int[] arr){
for(int i=0; i<arr.length ; i++){
System.out.print(arr[i] + " ");
}
System.out.println();
}
public static void main(String[] args) {
int[] arr = {49,38,65,97,76,13,27,49};
print(arr);
print(sort(arr));
}
}
49 38 65 97 76 13 27 49
13 27 38 49 49 65 76 97 效率：
时间复杂度：O（n^2）.
2. 插入排序—希尔排序（Shell`s Sort）
希尔排序是1959 年由D.L.Shell 提出来的，相对直接排序有较大的改进。希尔排序又叫缩小增量排序
基本思想：
先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。
操作方法：
- 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
- 按增量序列个数k，对序列进行k 趟排序；
- 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
希尔排序的示例：
算法实现：
我们简单处理增量序列：增量序列d = {n/2 ,n/4, n/8 .....1} n为要排序数的个数
即：先将要排序的一组记录按某个增量d（n/2,n为要排序数的个数）分成若干组子序列，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。继续不断缩小增量直至为1，最后使用直接插入排序完成排序。
import java.util.Random;
public class ShellSort {
//希尔排序
public static int[] shellSort(int[] arr){
/*//确定增量序列
double n = arr.length;
int[] d = new int[(int)n]; //增量序列
for(int i=0; i<n; i++){
if(n > 0){
d[i] = (int) Math.ceil(n/2);
n = (int) Math.ceil(n/2);
if( n <= 3 ){
d[i+1] = 1;
break;
}
}
}
System.out.println("增量序列：");
print(d);*/
double n = arr.length; //n 定义为double很重要。如果是int ，这(int)Math.ceil(5/2)==2。如果是double，(int)Math.ceil(5/2)==3
for(int i=(int)Math.ceil(n/2) ; i>0 ; i=(int)Math.ceil(n/2) ){ //增量序列：
if( i==2 && n%2 != 0){ //如果是n=5时，下一个增量应该是3，在下一个增量应该是1，去除2，
n=i; //但是， 如果是n=4时，下一个增量应该是2， 此时增量为2 ，应该被保留
continue;
}
for(int j=0; j<n ;j++ ){ //趟数,趟数与增量相同
int k = j;
while(k+i<arr.length){ //分组，将arr 分组为相隔i的几组，然后一个一个比较
if ( arr[k] > arr[k + i]) {
int tmp = arr[k];
arr[k] = arr[k + i];
arr[k + i] = tmp;
}
k = k+i;
}
}
n = i;
System.out.print("增量为" + i + "时，排序为 : ");
print(arr);
if(n==1){ // 因为double n=1,时 (int)Math.ceil(n/2)==1，如果不写break，这里会一直循环
break;
}
}
return arr;
}
// 打印数组
public static void print(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
public static void main(String[] args) {
int[] arr2 = {49,38,65,97,76,13,27,49,55,04};
System.out.println("排序前 ： ");
print(arr2);
System.out.println("排序后 ： ");
print(shellSort(arr2));
//测试：
System.out.println();
System.out.println("任意数组测试：");
Random r = new Random();
int[] testArr = new int[20];
for (int i = 0; i < 20; i++) {
testArr[i] = r.nextInt(100);
}
System.out.println("排序前 ： ");
print(testArr);
System.out.println("排序后 ： ");
print(shellSort(testArr));
}
}
输出结果：
排序前 ：
49 38 65 97 76 13 27 49 55 4
排序后 ：
增量为5时，排序为 : 13 27 49 55 4 49 38 65 97 76
增量为3时，排序为 : 13 4 49 38 27 49 55 65 97 76
增量为1时，排序为 : 4 13 27 38 49 49 55 65 76 97
4 13 27 38 49 49 55 65 76 97
任意数组测试：
排序前 ：
38 57 9 30 49 27 45 83 88 76 14 53 16 58 77 21 20 40 55 94
排序后 ：
增量为10时，排序为 : 14 53 9 30 49 21 20 40 55 76 38 57 16 58 77 27 45 83 88 94
增量为5时，排序为 : 14 20 9 30 49 21 45 16 55 76 27 53 40 58 77 38 57 83 88 94
增量为3时，排序为 : 14 20 9 30 16 21 40 27 53 38 49 55 45 57 77 76 58 83 88 94
增量为1时，排序为 : 14 9 16 20 21 27 30 38 40 49 45 53 55 57 58 76 77 83 88 94
14 9 16 20 21 27 30 38 40 49 45 53 55 57 58 76 77 83 88 94
3. 选择排序—简单选择排序（Simple Selection Sort）
基本思想：
在要排序的一组数中，选出最小（或者最大）的一个数，用第1个位置的数与剩下的n-1个数进行比较，然后，用第2个位置的数与剩下的n-2个数进行比较，以此类推。
简单选择排序的示例：
算法实现：
import java.util.Random;
public class SimpleSelectionSort {
//简单选择排序
public static int[] ssSort(int[] arr){
for(int i=0; i<arr.length-1; i++){
for(int j=i+1; j<arr.length; j++){
if(arr[i] > arr[j]){
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}
}
return arr;
}
// 打印数组
public static void print(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
public static void main(String[] args) {
System.out.println("任意数组测试：");
Random r = new Random();
int[] testArr = new int[20];
for (int i = 0; i < 20; i++) {
testArr[i] = r.nextInt(100);
}
System.out.println("排序前 ： ");
print(testArr);
System.out.println("排序后 ： ");
print(ssSort(testArr));
}
}
任意数组测试：
排序前 ：
27 21 8 56 28 19 40 72 80 84 85 31 99 25 11 62 8 67 60 94
排序后 ：
8 8 11 19 21 25 27 28 31 40 56 60 62 67 72 80 84 85 94 99
4.选择序—堆排序（Heap Sort）
堆排序是一种树形选择排序，是对直接选择排序的有效改进。基本思想：
堆的定义如下：具有n个元素的序列（k1,k2,...,kn),当且仅当满足
时称之为堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最小项（小顶堆）。
若以一维数组存储一个堆(Java数组从0开始,i为0到n-1)，则堆对应一棵完全二叉树，且所有非叶结点的值均不大于(或不小于)其子女的值，根结点（堆顶元素）的值是最小(或最大)的。如：
（a）大顶堆序列：（96, 83,27,38,11,09)
(b) 小顶堆序列：（12，36，24，85，47，30，53，91）
1.堆
堆实际上是一棵完全二叉树，其任何一非叶节点满足性质：
Key[i] <= key[2i+1] && Key[i] <= key[2i+2]
或者
Key[i] >= Key[2i+1] && key >= key[2i+2]即任何一非叶节点的关键字不大于或者不小于其左右孩子节点的关键字。
堆分为大顶堆和小顶堆，
满足 Key[i] >= Key[2i+1] && key >= key[2i+2] 称为大顶堆，满足 Key[i] <= key[2i+1] && Key[i] <= key[2i+2] 称为小顶堆。由上述性质可知大顶堆的堆顶的关键字肯定是所有关键字中最大的，小顶堆的堆顶的关键字是所有关键字中最小的。
2.堆排序的思想
利用大顶堆(小顶堆)堆顶记录的是最大关键字(最小关键字)这一特性，使得每次从无序中选择最大记录(最小记录)变得简单。
其基本思想为(大顶堆)：
1)将初始待排序关键字序列(R1,R2....Rn)构建成大顶堆，此堆为初始的无序区；
2)将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,......Rn-1)和新的有序区(Rn),且满足R[1,2...n-1]<=R[n];
3)由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,......Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2....Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。
操作过程如下：
1)初始化堆：将R[1..n]构造为堆；
2)将当前无序区的堆顶元素R[1]同该区间的最后一个记录交换，然后将新的无序区调整为新的堆。
因此对于堆排序，最重要的两个操作就是构造初始堆和调整堆，其实构造初始堆事实上也是调整堆的过程，只不过构造初始堆是对所有的非叶节点都进行调整。
下面举例说明：
给定一个整形数组a[]={16,7,3,20,17,8}(小顶堆)，对其进行堆排序。
首先根据该数组元素构建一个完全二叉树，得到
然后需要构造初始堆，则从最后一个非叶节点开始调整，调整过程如下：
20和16交换后导致16不满足堆的性质，因此需重新调整
这样就得到了初始堆。
即每次调整都是从父节点、左孩子节点、右孩子节点三者中选择最大者跟父节点进行交换(交换之后可能造成被交换的孩子节点不满足堆的性质，因此每次交换之后要重新对被交换的孩子节点进行调整)。有了初始堆之后就可以进行排序了。
此时3位于堆顶不满堆的性质，则需调整继续调整
这样整个区间便已经有序了。
从上述过程可知，堆排序其实也是一种选择排序，是一种树形选择排序。只不过直接选择排序中，为了从R[1...n]中选择最大记录，需比较n-1次，然后从R[1...n-2]中选择最大记录需比较n-2次。事实上这n-2次比较中有很多已经在前面的n-1次比较中已经做过，而树形选择排序恰好利用树形的特点保存了部分前面的比较结果，因此可以减少比较次数。对于n个关键字序列，最坏情况下每个节点需比较log2(n)次，因此其最坏情况下时间复杂度为nlogn。堆排序为不稳定排序，不适合记录较少的排序。
import java.util.Random;
public class HeapSort {
public static int[] heapSort(int[] arr) {
System.out.println("----------------建堆----------------");
int lastIndex = 0;
for (int i = 0; i < arr.length; i++) {
lastIndex = arr.length - 1 - i;
createHeap(arr, lastIndex); // 建初始堆（大顶堆）
isHeap(arr, lastIndex);// 检查堆还有没有不满足性质的
swap(arr, 0, arr.length - 1 - i); // 堆顶元素与叶子元素交换
System.out.println("堆顶与第"+(lastIndex+1)+"个数交换后 :");
print(arr);
System.out.println("----------------建堆----------------");
}
return arr;
}
//大顶堆
private static void createHeap(int[] arr, int lastIndex) {
int j = lastIndex;
int i = 0;
for (i = (lastIndex - 1) / 2; i >= 0; i--) {// 初始i等于lastIndex 的父节点
// 保存当前正在判断的节点
int k = i;
// 若当前节点的子节点存在
if ((2 * k) + 1 <= j) {
// biggerIndex总是记录较大节点的值,先赋值为当前i节点的左子节点
int biggerIndex = 2 * k + 1;
if (biggerIndex < j) {//如果有右节点
// 若右子节点存在，则判断左子节点与右子节点谁大，将大的放入biggerIndex
if (arr[biggerIndex] < arr[j]) {
biggerIndex++;
}
}
if (arr[k] < arr[biggerIndex]) {
// 若当前节点值比子节点最大值小，则交换2者得值，交换后将biggerIndex值赋值给k
swap(arr, k, biggerIndex);
j = (--k) * 2 + 2; //j 一直为k的右子节点
// k = biggerIndex;
}else{
j = (--k) * 2 + 2;//j 一直为k的右子节点
}
}
print(arr);
}
}
// 检查堆是否都满足大顶堆得性质
private static void isHeap(int[] arr, int lastIndex) {
int leftIndex = 0;
int rightIndex = 0;
int parent = 0;
for (int i = 0; i < (arr.length - 2) / 2; i++) {
leftIndex = 2 * i + 1;
rightIndex = 2 * i + 2;
parent = i;
if (arr[leftIndex] > arr[parent] || arr[rightIndex] > arr[parent]) {
createHeap(arr, lastIndex);
}
}
}
// 交换数组元素
private static void swap(int[] arr, int i, int j) {
if (i == j) {
return;
}
arr[i] = arr[i] + arr[j];
arr[j] = arr[i] - arr[j];
arr[i] = arr[i] - arr[j];
}
// 打印数组
public static void print(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
public static void main(String[] args) {
System.out.println("任意数组测试：");
Random r = new Random();
int[] testArr = new int[20];
for (int i = 0; i < 20; i++) {
testArr[i] = r.nextInt(100);
}
int a[] = { 16, 7, 3, 20, 17, 8 };
System.out.println("排序前 ： ");
print(a);
System.out.println("排序 ： ");
print(heapSort(a)); //得到小顶堆
/*
* System.out.println("排序前 ： "); print(testArr);
*
* System.out.println("排序 ： "); print(heapSort(testArr));
*/
}
}
</pre><pre>任意数组测试：
排序前 ：
16 7 3 20 17 8
排序 ：
----------------建堆----------------
16 7 8 20 17 3
16 20 8 7 17 3
20 16 8 7 17 3
20 16 8 7 17 3
20 17 8 7 16 3
20 17 8 7 16 3
堆顶与第6个数交换后 :
3 17 8 7 16 20
----------------建堆----------------
3 17 8 7 16 20
17 3 8 7 16 20
17 16 8 7 3 20
17 16 8 7 3 20
堆顶与第5个数交换后 :
3 16 8 7 17 20
----------------建堆----------------
3 16 8 7 17 20
16 3 8 7 17 20
16 7 8 3 17 20
16 7 8 3 17 20
堆顶与第4个数交换后 :
3 7 8 16 17 20
----------------建堆----------------
8 7 3 16 17 20
8 7 3 16 17 20
堆顶与第3个数交换后 :
3 7 8 16 17 20
----------------建堆----------------
7 3 8 16 17 20
7 3 8 16 17 20
7 3 8 16 17 20
堆顶与第2个数交换后 :
3 7 8 16 17 20
----------------建堆----------------
3 7 8 16 17 20
3 7 8 16 17 20
3 7 8 16 17 20
堆顶与第1个数交换后 :
3 7 8 16 17 20
----------------建堆----------------
3 7 8 16 17 20
（本人写的代码输出结果意在看排列的过程，请去除重复后，再与下面结论进行比较验证）
分析:
设树深度为k，
。从根到叶的筛选，元素比较次数至多2(k-1)次，交换记录至多k 次。所以，在建好堆后，排序过程中的筛选次数不超过下式：
而建堆时的比较次数不超过4n 次，因此堆排序最坏情况下，时间复杂度也为：O(nlogn )。
5. 交换排序—冒泡排序（Bubble Sort）
基本思想：
在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。
冒泡排序的示例：
算法的实现：
import java.util.Random;
public class BubbleSort {
public static void main(String[] args) {
int[] arr = new int[10];
Random r = new Random();
for(int i=0; i<10 ; i++){
arr[i] = r.nextInt(100);
}
for(int i=0; i<10 ; i++){
System.out.print(arr[i] + " ");
}
System.out.println();
int minIndex = 0;
for(int i=0; i< arr.length; i++){ //趟数
for(int j=0; j<arr.length-i-1; j++){//比较
if(arr[j] > arr[j+1]){
int tmp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tmp;
}
}
}
for(int i=0; i<10 ; i++){
System.out.print(arr[i] + " ");
}
System.out.println();
}
}
输出结果：
2 24 41 14 63 2 38 11 12 78
2 2 11 12 14 24 38 41 63 78
6. 交换排序—快速排序（Quick Sort）
快速排序和归并排序都使用分治法来设计算法，区别在于归并排序把数组分为两个基本等长的子数组，分别排好序之后还要进行归并(Merge)操作，而快速排序拆分子数组的时候显得更有艺术，取一个基准元素，拆分之后基准元素左边的元素都比基准元素小，右边的元素都不小于基准元素，这样只需要分别对两个子数组排序即可，不再像归并排序一样需要归并操作。
基本思想：
1）选择一个基准元素,通常选择第一个元素或者最后一个元素,
2）通过一趟排序讲待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的 元素值比基准值大。
3）此时基准元素在其排好序后的正确位置
4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。
快速排序的示例：
（a）一趟排序的过程：
（b）排序的全过程
算法的实现：
import java.util.Random;
public class QuickSort {
// 快速排序
private static void quickSort(int[] a) {
System.out.println("在数组中从0到"+(a.length-1)+"基准元素索引：" + 0);
subQuickSort(a, 0, a.length-1);
}
private static void subQuickSort(int[] a,int start, int end) {
if(a == null || end-start<2){
return ;
}
int keyIndex = quickSortPortion(a, start, end);
System.out.println("在数组中从"+start+"到"+end+"基准元素索引变换：" + keyIndex);
if(keyIndex == start){
subQuickSort(a, start+1, end);
}else if(keyIndex == end){
subQuickSort(a, start, end-1);
}else{
subQuickSort(a, start, keyIndex-1);
subQuickSort(a, keyIndex+1, end);
}
}
private static int quickSortPortion(int[] a, int start, int end) {
int minIndex = (end-start) / 2 + start; // minIndex定义为数组的中间索引
int key = start; // 将数组的第一个元素的索引定义为基准元素
int h = end;
System.out.println("快速排序------------>");
for (int i = start; i < end; i++) { // 比较 length-1次
if (key <= minIndex) { // 如果基准元素在前半部分
if (a[key] > a[h]) { // 元素值比基准元素值小
swap(a, key, h); // 交换位置
int tmp = h;
h = key + 1;
key = tmp;
} else {
h--;
}
} else { // 如果基准元素在后半部分
if (a[key] < a[h]) { // 元素值比基准元素值大
swap(a, key, h); // 交换位置
int tmp = key;
key = h;
h = tmp - 1;
} else {
h++;
}
}
print(a);
}
// print(a);
return key;
}
// 交换数组元素
private static void swap(int[] arr, int i, int j) {
if (i == j) {
return;
}
arr[i] = arr[i] + arr[j];
arr[j] = arr[i] - arr[j];
arr[i] = arr[i] - arr[j];
}
// 打印数组
public static void print(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
public static void main(String[] args) {
int a[] = { 49, 38, 65, 97, 76, 13, 27, 49 };
System.out.println("排序前 ： ");
print(a);
System.out.println("排序 ： ");
quickSort(a);
print(a);
// System.out.println("任意数组测试：");
// Random r = new Random();
// int[] testArr = new int[20];
// for (int i = 0; i < 20; i++) {
// testArr[i] = r.nextInt(100);
// }
//
// System.out.println("排序前 ： ");
// print(testArr);
//
// System.out.println("排序后： ");
// print(quickSort(testArr));
}
}
输出结果：
排序前 ：
49 38 65 97 76 13 27 49
排序后 ：
在数组中从0到7基准元素索引：0
快速排序------------>
49 38 65 97 76 13 27 49
27 38 65 97 76 13 49 49
27 38 65 97 76 13 49 49
27 38 49 97 76 13 65 49
27 38 13 97 76 49 65 49
27 38 13 49 76 97 65 49
27 38 13 49 76 97 65 49
在数组中从0到7基准元素索引变换：3
快速排序------------>
13 38 27 49 76 97 65 49
13 27 38 49 76 97 65 49
在数组中从0到2基准元素索引变换：1
快速排序------------>
13 27 38 49 49 97 65 76
13 27 38 49 49 76 65 97
13 27 38 49 49 65 76 97
在数组中从4到7基准元素索引变换：6
13 27 38 49 49 65 76 97
分析：
快速排序是一个不稳定的排序方法。
7. 归并排序（Merge Sort）
基本思想：
归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。
归并排序示例：
合并方法：
设r[i…n]由两个有序子表r[i…m]和r[m+1…n]组成，两个子表长度分别为m+1-i 、n+1-m。
- j=m+1；k=i；i=i; //置两个子表的起始下标及辅助数组的起始下标
- 若i>m 或j>n，转⑷ //其中一个子表已合并完，比较选取结束
- //选取r[i]和r[j]较小的存入辅助数组rf
如果r[i]<r[j]，rf[k]=r[i]； i++； k++； 转⑵
否则，rf[k]=r[j]； j++； k++； 转⑵ - //将尚未处理完的子表中元素存入rf
如果i<=m，将r[i…m]存入rf[k…n] //前一子表非空
如果j<=n , 将r[j…n] 存入rf[k…n] //后一子表非空 - 合并结束。
public class MergeSort2 {
private static void mergeSort(int[] a) {
double len = a.length;
int time = (int)len >> 1; //相当于len/2 ，即归并的趟数
for(int i=0; i<time; i++){
int subLength = 1 << i; //相当于2的i次方 ，子序列的长度
int subNum = (int) Math.ceil(len/((subLength+1)*(i+1))); //子序列数
for(int j=0; j<subNum; j++){
int a1_start = (int) (j*2*subLength< len ? j*2*subLength : len-1); //即下一组归并开始索引与上一组相差值
int a2_start = (int) (a1_start+subLength < len ? a1_start+subLength : len-1);
int a2_end = (int) ((a1_start+2*subLength-1) < len ? (a1_start+2*subLength-1): len-1); //防止最后一个越界
merge(a, a1_start, a2_start, a2_end);
}
System.out.println("-------------归并排序后:-------------");
print(a);
System.out.println("************************************");
}
}
//归并函数，传入的参数分别为：原数组，第一个字序列的开始索引，第二个字序列的开始索引，第二个字序列的结束索引
private static void merge(int[] a, int a1_start, int a2_start, int a2_end){
int len = a.length;
int[] rf = new int[a2_end-a1_start+1];
int i = a1_start, j = a2_start, k = 0;
while( i<a2_start && j <= a2_end){
if(a[i]<a[j]){
rf[k] = a[i];
i++;
k++;
}else{
rf[k] = a[j];
j++;
k++;
}
}
while(i<a2_start){
rf[k] = a[i];
k++;
i++;
}
while(j <= a2_end){
rf[k] = a[j];
k++;
j++;
}
//拷贝rf数组，到原数组 arraycopy(源数组，源数组开始索引，目标数组，目标数组开始索引，需要拷贝的长度);
System.arraycopy(rf,0,a,a1_start,rf.length);
print(a);
}
// 打印数组
public static void print(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
public static void main(String[] args) {
int a[] = { 49, 38, 65, 97, 76, 13, 27};
System.out.println("排序前 ： ");
print(a);
System.out.println("排序 ： ");
mergeSort(a);
print(a);
}
}
排序前 ：
49 38 65 97 76 13 27
排序 ：
38 49 65 97 76 13 27
38 49 65 97 76 13 27
38 49 65 97 13 76 27
38 49 65 97 13 76 27
-------------归并排序后:-------------
38 49 65 97 13 76 27
************************************
38 49 65 97 13 76 27
38 49 65 97 13 27 76
-------------归并排序后:-------------
38 49 65 97 13 27 76
************************************
13 27 38 49 65 76 97
-------------归并排序后:-------------
13 27 38 49 65 76 97
************************************
13 27 38 49 65 76 97
归并的迭代算法(方法二)
1 个元素的表总是有序的。所以对n 个元素的待排序列，每个元素可看成1 个有序子表。对子表两两合并生成n/2个子表，所得子表除最后一个子表长度可能为1 外，其余子表长度均为2。再进行两两合并，直到生成n 个元素按关键码有序的表。
public class MergeSort {
// private static long sum = 0;
/**
* <pre>
* 二路归并
* 原理：将两个有序表合并和一个有序表
* </pre>
*
* @param a
* @param s
* 第一个有序表的起始下标
* @param m
* 第二个有序表的起始下标
* @param t
* 第二个有序表的结束小标
*
*/
private static void merge(int[] a, int s, int m, int t) {
int[] tmp = new int[t - s + 1];
int i = s, j = m, k = 0;
while (i < m && j <= t) {
if (a[i] <= a[j]) {
tmp[k] = a[i];
k++;
i++;
} else {
tmp[k] = a[j];
j++;
k++;
}
}
while (i < m) {
tmp[k] = a[i];
i++;
k++;
}
while (j <= t) {
tmp[k] = a[j];
j++;
k++;
}
System.arraycopy(tmp, 0, a, s, tmp.length);
print(a);
}
/**
*
* @param a
* @param s
* @param len
* 每次归并的有序集合的长度
*/
public static void mergeSort(int[] a, int s, int len) {
int size = a.length;
int mid = size / (len << 1); // size/(len*2)
int c = size & ((len << 1) - 1); // 判断数组长度奇偶数
// -------归并到只剩一个有序集合的时候结束算法-------//
if (mid == 0)
return;
// ------进行一趟归并排序-------//
for (int i = 0; i < mid; ++i) {
s = i * 2 * len;
merge(a, s, s + len, (len << 1) + s - 1);
}
// -------将剩下的数和倒数一个有序集合归并-------//
if (c != 0)
merge(a, size - c - 2 * len, size - c, size - 1);
// -------递归执行下一趟归并排序------//
mergeSort(a, 0, 2 * len);
}
public static void main(String[] args) {
int[] a = new int[] {49, 38, 65, 97, 76, 13, 27 };
mergeSort(a, 0, 1);
for (int i = 0; i < a.length; ++i) {
System.out.print(a[i] + " ");
}
}
// 打印数组
public static void print(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}
输出结果：
38 49 65 97 76 13 27
38 49 65 97 76 13 27
38 49 65 97 13 76 27
38 49 65 97 13 27 76
38 49 65 97 13 27 76
13 27 38 49 65 76 97
13 27 38 49 65 76 97
8. 桶排序/基数排序(Radix Sort)
说基数排序之前，我们先说桶排序：
基本思想：是将阵列分到有限数量的桶子里。每个桶子再个别排序（有可能再使用别的排序算法或是以递回方式继续使用桶排序进行排序）。桶排序是鸽巢排序的一种归纳结果。当要被排序的阵列内的数值是均匀分配的时候，桶排序使用线性时间（Θ（n））。但桶排序并不是 比较排序，他不受到 O(n log n) 下限的影响。
简单来说，就是把数据分组，放在一个个的桶中，然后对每个桶里面的在进行排序。
例如要对大小为[1..1000]范围内的n个整数A[1..n]排序
首先，可以把桶设为大小为10的范围，具体而言，设集合B[1]存储[1..10]的整数，集合B[2]存储 (10..20]的整数，……集合B[i]存储( (i-1)*10, i*10]的整数，i = 1,2,..100。总共有 100个桶。
然后，对A[1..n]从头到尾扫描一遍，把每个A[i]放入对应的桶B[j]中。 再对这100个桶中每个桶里的数字排序，这时可用冒泡，选择，乃至快排，一般来说任 何排序法都可以。
最后，依次输出每个桶里面的数字，且每个桶中的数字从小到大输出，这 样就得到所有数字排好序的一个序列了。
假设有n个数字，有m个桶，如果数字是平均分布的，则每个桶里面平均有n/m个数字。如果
对每个桶中的数字采用快速排序，那么整个算法的复杂度是
O(n + m * n/m*log(n/m)) = O(n + nlogn - nlogm)
从上式看出，当m接近n的时候，桶排序复杂度接近O(n)
当然，以上复杂度的计算是基于输入的n个数字是平均分布这个假设的。这个假设是很强的 ，实际应用中效果并没有这么好。如果所有的数字都落在同一个桶中，那就退化成一般的排序了。
前面说的几大排序算法 ，大部分时间复杂度都是O（n2），也有部分排序算法时间复杂度是O(nlogn)。而桶式排序却能实现O（n）的时间复杂度。但桶排序的缺点是：
1）首先是空间复杂度比较高，需要的额外开销大。排序有两个数组的空间开销，一个存放待排序数组，一个就是所谓的桶，比如待排序值是从0到m-1，那就需要m个桶，这个桶数组就要至少m个空间。
2）其次待排序的元素都要在一定的范围内等等。
桶式排序是一种分配排序。分配排序的特定是不需要进行关键码的比较，但前提是要知道待排序列的一些具体情况。
分配排序的基本思想：说白了就是进行多次的桶式排序。
基数排序过程无须比较关键字，而是通过“分配”和“收集”过程来实现排序。它们的时间复杂度可达到线性阶：O(n)。
实例:
扑克牌中52 张牌，可按花色和面值分成两个字段，其大小关系为：
花色： 梅花< 方块< 红心< 黑心 
面值： 2 < 3 < 4 < 5 < 6 < 7 < 8 < 9 < 10 < J < Q < K < A
若对扑克牌按花色、面值进行升序排序，得到如下序列：
即两张牌，若花色不同，不论面值怎样，花色低的那张牌小于花色高的，只有在同花色情况下，大小关系才由面值的大小确定。这就是多关键码排序。
为得到排序结果，我们讨论两种排序方法。
方法1：先对花色排序，将其分为4 个组，即梅花组、方块组、红心组、黑心组。再对每个组分别按面值进行排序，最后，将4 个组连接起来即可。
方法2：先按13 个面值给出13 个编号组(2 号，3 号，...，A 号)，将牌按面值依次放入对应的编号组，分成13 堆。再按花色给出4 个编号组(梅花、方块、红心、黑心)，将2号组中牌取出分别放入对应花色组，再将3 号组中牌取出分别放入对应花色组，……，这样，4 个花色组中均按面值有序，然后，将4 个花色组依次连接起来即可。
设n 个元素的待排序列包含d 个关键码{k1，k2，…，kd}，则称序列对关键码{k1，k2，…，kd}有序是指：对于序列中任两个记录r[i]和r[j](1≤i≤j≤n)都满足下列有序关系：
其中k1 称为最主位关键码，kd 称为最次位关键码 。
两种多关键码排序方法：
多关键码排序按照从最主位关键码到最次位关键码或从最次位到最主位关键码的顺序逐次排序，分两种方法：
最高位优先(Most Significant Digit first)法，简称MSD 法：
1）先按k1 排序分组，将序列分成若干子序列，同一组序列的记录中，关键码k1 相等。
2）再对各组按k2 排序分成子组，之后，对后面的关键码继续这样的排序分组，直到按最次位关键码kd 对各子组排序后。
3）再将各组连接起来，便得到一个有序序列。扑克牌按花色、面值排序中介绍的方法一即是MSD 法。
最低位优先(Least Significant Digit first)法，简称LSD 法：
1) 先从kd 开始排序，再对kd-1进行排序，依次重复，直到按k1排序分组分成最小的子序列后。
2) 最后将各个子序列连接起来，便可得到一个有序的序列, 扑克牌按花色、面值排序中介绍的方法二即是LSD 法。
基于LSD方法的链式基数排序的基本思想
“多关键字排序”的思想实现“单关键字排序”。对数字型或字符型的单关键字，可以看作由多个数位或多个字符构成的多关键字，此时可以采用“分配-收集”的方法进行排序，这一过程称作基数排序法，其中每个数字或字符可能的取值个数称为基数。比如，扑克牌的花色基数为4，面值基数为13。在整理扑克牌时，既可以先按花色整理，也可以先按面值整理。按花色整理时，先按红、黑、方、花的顺序分成4摞（分配），再按此顺序再叠放在一起（收集），然后按面值的顺序分成13摞（分配），再按此顺序叠放在一起（收集），如此进行二次分配和收集即可将扑克牌排列有序。
基数排序:
是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以是稳定的。
9 总结
各种排序的稳定性，时间复杂度和空间复杂度总结：
我们比较时间复杂度函数的情况：
时间复杂度函数O(n)的增长情况
所以对n较大的排序记录。一般的选择都是时间复杂度为O(nlog2n)的排序方法。
时间复杂度来说：
(1)平方阶(O(n2))排序
各类简单排序:直接插入、直接选择和冒泡排序；
(2)线性对数阶(O(nlog2n))排序
快速排序、堆排序和归并排序；
(3)O(n1+§))排序,§是介于0和1之间的常数。
希尔排序
(4)线性阶(O(n))排序
基数排序，此外还有桶、箱排序。
说明：
当原表有序或基本有序时，直接插入排序和冒泡排序将大大减少比较次数和移动记录的次数，时间复杂度可降至O（n）；
而快速排序则相反，当原表基本有序时，将蜕化为冒泡排序，时间复杂度提高为O（n2）；
原表是否有序，对简单选择排序、堆排序、归并排序和基数排序的时间复杂度影响不大。
稳定性：
排序算法的稳定性:若待排序的序列中，存在多个具有相同关键字的记录，经过排序， 这些记录的相对次序保持不变，则称该算法是稳定的；若经排序后，记录的相对 次序发生了改变，则称该算法是不稳定的。
稳定性的好处：排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。另外，如果排序算法稳定，可以避免多余的比较；
稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序
不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序
选择排序算法准则：
每种排序算法都各有优缺点。因此，在实用时需根据不同情况适当选用，甚至可以将多种方法结合起来使用。
选择排序算法的依据
影响排序的因素有很多，平均时间复杂度低的算法并不一定就是最优的。相反，有时平均时间复杂度高的算法可能更适合某些特殊情况。同时，选择算法时还得考虑它的可读性，以利于软件的维护。一般而言，需要考虑的因素有以下四点：
1．待排序的记录数目n的大小；
2．记录本身数据量的大小，也就是记录中除关键字外的其他信息量的大小；
3．关键字的结构及其分布情况；
4．对排序稳定性的要求。
设待排序元素的个数为n.
1）当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。
快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；
堆排序 ： 如果内存空间允许且要求稳定性的，
归并排序：它有一定数量的数据移动，所以我们可能过与插入排序组合，先获得一定长度的序列，然后再合并，在效率上将有所提高。
2） 当n较大，内存空间允许，且要求稳定性 =》归并排序
3）当n较小，可采用直接插入或直接选择排序。
直接插入排序：当元素分布有序，直接插入排序将大大减少比较次数和移动记录的次数。
直接选择排序 ：元素分布有序，如果不要求稳定性，选择直接选择排序
5）一般不使用或不直接使用传统的冒泡排序。
6）基数排序
它是一种稳定的排序算法，但有一定的局限性：
1、关键字可分解。
2、记录的关键字位数较少，如果密集更好
3、如果是数字时，最好是无符号的，否则将增加相应的映射复杂度，可先将其正负分开排序。
注明：c语言实现：出处：http://blog.csdn.net/hguisu/article/details/7776068
728
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
