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

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

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

　　(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[n];
	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.序列初始基本有序（正序），宜用直接插入，冒泡