小结排序--插入排序/冒泡排序/选择排序/堆排序/归并排序

一、排序的基本概念：

（1）性能评价：取决于时间复杂度和空间复杂度。排序中的时间复杂度由元素的比较次数和移动次数决定

（2）稳定性：指关键字重复情况下的排序性能。例如：1   2  9  2 ，排序后1  2   2  9；第一个2仍在第二个2之前这样的排序是稳定的。

（3）内排序和外排序：内排序指待排序的数据元素全部存储在内存；外排序是指待排序的数据元素非常多，不嫩全部存储在内存中，需要存储在外部的存储介质上的数据分批导入内存，分批存储，以下只有内排序。

二、排序的种类

1.插入排序：直接插入排序和折半插入排序、希尔排序

2.交换排序：冒泡排序、快速排序

3.选择排序：直接选择排序、堆排序

4.归并排序

5.单链表排序：单链表直接插入排序、单链表直接选择排序、单链表的归并排序

三、图解排序：

1.直接插入排序：



2.希尔排序：



3.冒泡排序：



4.快速排序
第一趟排序的过程：



排序的过程



5.选择排序



6.堆排序
最小堆和最大堆



创建最小堆：



排序的过程：



7.归并排序
一次归并：



归并排序过程：

四、排序源码：

（1）直接插入排序：（以下是一个完整的程序直接粘贴复制到eclipse就可以运行的）

package renee;

import java.util.Scanner;
public class  sort{
//插入排序
public static void insertSort(int[] table){
for (int i=1;i<table.length;i++){

int temp = table[i],j;
for(j=i-1;j>=0&&temp<table[j];j--)
table[j+1] = table[j];
table[j+1] = temp;
}
}

public static void main(String[] args){
int number1;
Scanner num = new Scanner(System.in);
System.out.print("input how many number do you want to sort:");
number1 = num.nextInt();
int a[] = new int[number1];
System.out.print("Now put them in:");
for(int i=0;i<a.length;i++)
a[i] = num.nextInt();
insertSort(a);                                                                          //执行排序
for(int i=0;i<a.length;i++){
System.out.print(a[i]+" ");
}

}
}

（2）冒泡排序（在执行排序那行添加 bubbleSort(a);即可运行，下同）

public static void bubbleSort(int[] table){
boolean exchange = true;
for(int i = 1;i<table.length&&exchange;i++){
exchange = false;
for(int j=0;j<table.length-i;j++)
if(table[j]>table[j+1]){
int temp = table[j];
table[j] = table[j+1];
table[j+1] = temp;
exchange = true;
}
}
}

（3）选择排序

public static void selectSort(int[] table){
for(int i=0;i<table.length-1;i++){
int min=i;
for(int j=i+1;j<table.length;j++)
if(table[j]<table[min])
min=j;
if(min!=i){
int temp = table[i];
table[i] = table[min];
table[min] = temp;
}
}
}

（4）堆排序

public static void heapSort(int[] table){
int n = table.length;
for(int j=n/2;j>=0;j--)
sift(table,j,n-1);
for(int j=n-1;j>0;j--){
int temp = table[0];
table[0] = table[j];
table[j] = temp;
sift(table,0,j-1);
}
}
private static void sift(int[] table,int begin,int end){
int i=begin,j=2*i+1;
int temp = table[i];
while(j<=end){
if(j<end&&table[j]>table[j+1])
j++;
if(temp>table[i]){
table[i] = table[i];
i=j;
j=2*i+1;
}
else break;
}
table[i] = temp;
}

（5）归并排序

public static void merge(int[] X,int[] Y,int m,int r,int n){  //一次归并
int i=m,j=r,k=m;
while(i<r&&j<r+n&&j<X.length)                                //将X中两个相邻子序列归并到Y中
if(X[i]<X[j])                                                              //将较小值复制到Y中
Y[k++]=X[i++];
else
Y[k++]=X[j++];
while(i<r){
Y[k++]=X[i++];                                                      //将前一个子序列剩余元素复制到Y中
while(j<r+n&&j<X.length)
Y[k++]=X[j++];                                                  //将后一个子序列剩余元素复制到Y中
}
}
//归并排序-一趟归并
private static void mergepass(int[] X,int[] Y,int n){         //一趟归并
int i=0;
while(i<X.length-2*n+1){
merge(X,Y,i,i+n,n);
i += 2*n;
}
if(i+n<X.length)
merge(X,Y,i,i+n,n);                                                    //再一次归并
else
for (int j=i;j<X.length;j++)
Y[j]=X[j];                                                               //将X剩余元素复制到Y中
}
//归并排序
public static void mergeSort(int[] X){                              //归并排序
int[] Y = new int[X.length];                                          //将Y数组长度同X数组
int n = 1;                                                                    //已排序的子序列长度，初值为1
while(n<X.length){
mergepass(X,Y,n);                                                   //一趟归并，将X数组中各子序列归并到Y中
n*=2;                                                                    //子序列长度加倍
if(n<X.length){
mergepass(Y,X,n);                                              //将数组中各子序列再归并到X中
n*=2;
}
}
}