总结一些常用的排序算法，备忘

　排序大的分类可以分为两种：内排序和外排序。在排序过程中，全部记录存放在内存，则称为内排序，如果排序过程中需要使用外存，则称为外排序。下面讲的排序都是属于内排序。

　　内排序有可以分为以下几类：

　　(1)、插入排序：直接插入排序、二分法插入排序、希尔排序。

　　(2)、选择排序：简单选择排序、堆排序。

　　(3)、交换排序：冒泡排序、快速排序。

　　(4)、归并排序

　　(5)、基数排序
一、直接插入排序：

每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的字序列的合适位置（从后向前找到合适位置后），直到全部插入排序完为止。



程序如下：

public class DirectSort {
public static void main(String[] args){
int a[]={49,38,65,97,76};
for(int i=1; i<a.length; i++){
int temp =a[i];
int j;
for(j=i-1;j>=0;j--){
if(a[j]>temp){
a[j+1]=a[j];
}else{
break;
}
}
a[j+1]=temp;
}
System.out.println("排序之后：");
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}
}
}

直接插入排序是稳定的排序。文件初态不同时，直接插入排序所耗费的时间有很大差异。若文件初态为正序，则每个待插入的记录只需要比较一次就能够找到合适的位置插入，故算法的时间复杂度为O(n)，这时最好的情况。
若初态为反序，则第i个待插入记录需要比较i+1次才能找到合适位置插入，故时间复杂度为O(n²)，这时最坏的情况。

直接插入排序的平均时间复杂度为O(n²)。

一、冒泡排序

首先看一下冒泡排序的实例图：



冒泡排序的过程很简单，就是将第一个记录的关键字和第二个记录的关键字进行比较，如果后面的比前面的小则交换，然后比较第二个和第三个，依次类推。比完一趟，最大的那个已经放到了最后的位置，这样就可以对前面N-1个数再循环比较。
程序如下：

public class BubbleSort  {
public static void main(String[] args) {
int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
getBubbleSort(a);
}
public static void getBubbleSort (int[] a){
int temp;
for(int i=0; i<a.length;++i){
for(int j=a.length-1;j>i;--j){
if(a[j] <a[j-1]){
temp = a[j];
a[j] = a[j-1];
a[j-1] = temp;
}
}
}
for(int i=0;i<a.length;i++)
System.out.println(a[i]);
}
}

冒泡排序是一种稳定的排序方法。　

•若文件初状为正序，则一趟起泡就可完成排序，排序码的比较次数为n-1，且没有记录移动，时间复杂度是O(n)

•若文件初态为逆序，则需要n-1趟起泡，每趟进行n-i次排序码的比较，且每次比较都移动三次，比较和移动次数均达到最大值∶O(n2)

•起泡排序平均时间复杂度为O(n²)

二、快速排序

快速排序

　　1、基本思想：选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描，将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。

　　

　　2、实例



程序如下：

public class QuickSort {
public static void main(String[] args) {
int a[]={49,38,65,97};
quick(a);
}
private static void quick(int[] a) {
if(a.length>0)
quickSort(a,0,a.length-1);
System.out.println("排序之后：");
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]+" ");
}
}
private static void quickSort(int[] a, int low, int high) {
if(low<high){
int middle=getMiddle(a,low,high);
quickSort(a,0,middle-1);
quickSort(a,middle+1,high);
}
}
private static int getMiddle(int[] a, int low, int high) {
int temp=a[low];
while(low<high){
while(low<high && a[high]>=temp){
high--;
}
a[low]=a[high];
while(low<high && a[low]<=temp){
low++;
}
a[high]=a[low];
}
a[low] =temp;
return low;
}

}

快速排序是不稳定的排序。

快速排序的时间复杂度为O(nlogn)。

当n较大时使用快排比较好，当序列基本有序时用快排反而不好。

四、归并排序算法

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。
首先考虑下如何将将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可。

public void MemeryArrays(int[] num1, int[] num2, int newNum[]) {
int i = 0, j = 0, k = 0;
int num1Size = num1.length;
int num2Size = num2.length;
while (i < num1Size && j < num2Size) {
if (num1[i] > num2[j]) {
newNum[k++] = num2[j++];
}
if (num1[i] < num2[j]) {
newNum[k++] = num1[i++];
}
}
while (i < num1Size) {
newNum[k++] = num1[i++];
}
while (j < num2Size) {
newNum[k++] = num2[j++];
}
}

//将有二个有序数列a[first...mid]和a[mid...last]合并。
void mergearray(int a[], int first, int mid, int last, int temp[])
{
int i = first, j = mid + 1;
int m = mid,   n = last;
int k = 0;

while (i <= m && j <= n)
{
if (a[i] <= a[j])
temp[k++] = a[i++];
else
temp[k++] = a[j++];
}

while (i <= m)
temp[k++] = a[i++];

while (j <= n)
temp[k++] = a[j++];

for (i = 0; i < k; i++)
a[first + i] = temp[i];
}
void mergesort(int a[], int first, int last, int temp[])
{
if (first < last)
{
int mid = (first + last) / 2;
mergesort(a, first, mid, temp);    //左边有序
mergesort(a, mid + 1, last, temp); //右边有序
mergearray(a, first, mid, last, temp); //再将二个有序数列合并
}
}

bool MergeSort(int a[], int n)
{
int *p = new int
;
if (p == NULL)
return false;
mergesort(a, 0, n - 1, p);
delete[] p;
return true;
}

三、排序算法的选择

　　1.数据规模较小

　　（1）待排序列基本序的情况下，可以选择直接插入排序；

　　（2）对稳定性不作要求宜用简单选择排序，对稳定性有要求宜用插入或冒泡

　　2.数据规模不是很大

　　（1）完全可以用内存空间，序列杂乱无序，对稳定性没有要求，快速排序，此时要付出log（N）的额外空间。

　　（2）序列本身可能有序，对稳定性有要求，空间允许下，宜用归并排序

　　3.数据规模很大

　　（1）对稳定性有求，则可考虑归并排序。

　　（2）对稳定性没要求，宜用堆排序

　　4.序列初始基本有序（正序），宜用直接插入，冒泡