排序

常用排序实现

（1）插入排序

         A：直接插入排序 ——将一个记录插入到已经排好序的有序表中。其时间复杂度为O（n^2）

void insertSort(int a[],int n)
{
	for(int i=0;i<n-1;i++)
	{
		int temp;
		int x=i;
		if(a[i+1]<a[i])
		{
			temp=a[i+1];
			while(temp<a[i])
			{
				a[i+1]=a[i];
				i--;
			}
			a[i+1]=temp;
		}
		i=x;
	}
	return;
}

B：希尔排序——又称“缩小增量排序”，将待排记录序列分割成若干子序列分别进行直接插入排序，待整个序列“基本有序”后，再整体进行一次排序。希尔排序的时间复杂度根据选择的增量的而不同，目前还没有较好的增量序列。

void shellInsert(int a[],int n,int dk)
{       //n是数组的长度，dk是增量
	for(int i=dk;i<10;i++)
	{
		int temp;
		int x=i;
		if(a[i]<a[i-dk])
		{
			temp=a[i];
			while(i-dk>=0&&temp<a[i-dk])
			{
				a[i]=a[i-dk];
				i-=dk;
			}
			a[i]=temp;
		}
		i=x;
	}
}

void shellSort(int a[],int n,int dk)
{
	while(dk>=1)
	{
		shellInsert(a,n,dk);
		dk=dk/2;
	}

}

（2）选择排序——在该元素后面的所有元素中选择最小（或最大）的元素与该元素进行交换。无论初始排列如何，比较次数均为n（n-1）/2，所以其时间复杂度为O(n^2)。

void selectSort(int a[],int n)
{
	for(int i=0;i<n-1;i++)
	{
		int index=i;
		for(int j=i+1;j<n;j++)
		{
			if(a[j]<a[index])
			{
				index=j;
			}
		}
		if(index!=i)
		{
			int temp=a[i];
			a[i]=a[index];
			a[index]=temp;
		}
	}
}

（3）冒泡排序——从最后一个元素不断和前一个元素比较，小于（或大于）则交换。其时间复杂度为O(n^2)。

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

（4）快速排序——对冒泡的改进，通过一趟排序将带排序的记录分割成独立的两部分，左边的小于（或大于）关键字，右边的大于（或小于）关键字。

void quickSort(int a[],int m,int n)
{
    int p;
    if(m<n)
    {
        p=quickp(a,m,n);
        quickSort(a,m,p-1);
        quickSort(a,p+1,n);
    }
    return ;
}

int quickp(int a[],int left,int right)
{
    int low=left;
    int height=right;
    int temp=a[low];

    while(low<height)
    {
        while(low<height&&a[height]>=temp)
            height--;
        if(low<height)
        {
            a[low]=a[height];
            low++;
        }

        while(low<height&&a[low]<temp)
            low++;
        if(low<height)
        {
            a[height]=a[low];
            height--;
        }
    }
    a[low]=temp;
    return low;

}