排序小节

直接插入排序：

public static void InsertSort(int []R)//排序数存在R数组中，R[1],R[2].....
{
	for(int i=2; i<R.length(); i++)
	{
		if(R[i]<R[i-1])
		{
			R[0] = R[i];
				for(int j=i-1; R[j]>R[0]; j--)
					R[j+1]=R[j];//后移一位
			R[j+1] = R[0];//插入到合适的位置
		}
	}
}

直接插入排序时间复杂度o平方，空间复杂度1，比较适合有序性较好的排列。




对直接插入排序进行优化，希尔排序
public static void ShellSort(int []R,int []d)//R是待排序列，d是递减的步长序列，

{
	for(int k=0;k<d.length;k++)
	{
		int h = d[k];//本趟的增量
		for(int i=h+1;i<R.length();i++)
		{
			if(R[i]<R[i-h])
			{
				R[0] = R[i];
				for(int j=i-h;R[j]<R[0]&&j>0;j=j-h)
					R[j+h]=R[j];//后移
				R[j+h] = R[0];//插入到正确位置
			}
		}
	}
}

对于希尔排序，注意步长序列除1外，不应有共因子，且最后一个步长因子一定为1，这是一个不稳定的排序算法。




冒泡排序：

public static void Bubble_Sort(int []R,int n)
{
    int i, j, temp;
    for (j = 0; j < n - 1; j++)
        for (i = 0; i < n - 1 - j; i++)
        {
            if(a[i] > a[i + 1])
            {
                temp = a[i];
                a[i] = a[i + 1];
                a[i + 1] = temp;
            }
        }
}

冒泡排序就是相邻两个数进行比较，时间复杂度是o的平方，空间复杂度是1，稳定的排序算法。


快速排序:采用分治策略，排序a[p:r]
1，首先将a[p:r]分解为a[p:q-1],a[q],a[q+1:r]三部分a[p:q-1]任何元素都小于a[q]，a[q+1,r]任何元素都大于a[q]；
2, 分别对a[p,q-1]和a[q+1,r]进行快速排序；
3，三部分进行合并；

public static void  QuickSort(int []data,int low,int high)
{
	if(low<high)
		return;
	int i=low;
	int j=high;
	int p=data[low];
	while(i<j)
	{
		while(i<j && data[j]>=p) j--;
		if(i<j) data[i++]=data[j];
		while(i<j && data[i]<=p) i++;
		if(i<j) data[j--]=data[i];
	}
	data[i]=p;
	QuickSort(data,low,i-1);
	QuickSort(data,i+1,high);
}

快速排序的时间复杂度nlogn,是不稳定的排序。


堆排序；判断一个序列是不是堆，可以和一颗完全二叉树对应起来。
堆排序是不稳定的排序算法，时间复杂度为ologn；


归并排序：
两个有序表的合并：

public static void Merge(int []R,int []R1,int s,int m,int t)
{
	//两个有序子表R[s]...R[m]和R[m+1]...R[t]，将这两个有序子表合并为R1
	i=s;
	j=m+1;
	k=s;
	while(i<=m && j<=t)
	{
		if(R[i]<R[j])
			R1[k++]=R[i++];
		else
			R1[k++]=R[j++];
	}
	while(i<=m)
		R1[k++]=R[i++];
	while(j<=t)
		R1[k++]=R[j++];
}

二路归并算法的基本思想：只有1个元素的表是有序的，所以排序表可以看作是n个长度为1的有序子表，将相邻
的两个有序子表合并，最后生成长度为n的有序表，整个过程需要logn趟。
二路归并算法的递归实现:

public static void MSort(int []R,int []R1,int s,int t)
{
	//将R[s]...R[t]归并排序为R1[s]...R1[t]
	if(s==t) R1[s] = R[s];
	else{
		int m =(s+t)/2;
		MSort(R,R1,s,m);//递归R[s...m]归并为有序的R1[s...m]
		MSort(R,R1,m+1,t);//递归R[m+1...t]归并为有序的R1[m+1...t]
		Merge(R1,R,s,m,t);//将R1[s...m]和R1[m+1...t]归并到R[s...t]
	}
}

归并算法的时间复杂度为ologn，是一种稳定的排序算法，但是他需要一个与表等长的辅助元素数组空间。