排序总结

1. 直接插入排序

思想：将数组分为无序区和有序区两个部分，然后不断将无序区的第一个元素按大小顺序插入到有序区中去，最终将所有无序区元素都移动到有序区完成排序。

时间复杂度O(n^2)级别

代码实现：

const int INF=1000;
int num[INF];   //存储待排序的数据
void InsertSort(int n)     //直接插入排序，n表示元素个数
{
    int i,j;  //i表示已排序数的终止位置，j表示未排序数的起始位置
    for(i=0;i<n-1;)
    {
        j=i+1;
        if(num[j]<num[i])
        {
            int temp=num[j];     //记录待排序数
            while(temp<num[i] && i>=0)   //查找插入位置，并移动元素
            {
                num[i+1]=num[i];
                i--;
            }
            num[i+1]=temp;  //插入元素
        }
        i=j;
    }
}

2. Shell排序

思想：又称增量缩小排序。是对直接排序的该进，首先选取一个小于n的数字将待排序元素划分成若干组，在各组内进行直接插入排序；

然后选取第二个增量，重复上面的分组和排序，知道增量为1时停止。是一种不稳定的排序。

时间复杂度要小于O(n^2)。

增量的选择一般每次选择数组元素个数的一半。

实现如下：

const int INF=1000;
int num[INF];   //存储待排序的数据
int n;  //元素个数
void Shell1(int d)  //直接插入排序
{
    for(int i=d;i<n;i++)
    {
        if(num[i]<num[i-d])
        {
            int temp=num[i];
            int j=i-d;
            while(j>=0 && temp<num[j])
            {
                num[j+d]=num[j];
                j-=d;
            }
            num[j+d]=temp;
        }
    }
}
void ShellSort1(int d)  //Shell排序
{
    while(d>=1)
    {
        Shell1(d);
        d/=2;
    }
}

3. 冒泡排序

思想：进行n次比较，每次将较大的数沉底。

时间复杂度O(n^2)

代码如下：

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

4. 选择排序

思想：进行n-1趟排序，每一趟选择最小的元素（或者最大的元素）与前面待排序的数进行交换。

时间复杂度O(n^2)。

代码如下：

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

5.归并排序

思想：采用分治的思想，将数组划分成若干部分，先对每一部分进行排序，然后将排好序的部分合并进行排序。是一种稳定的排序。

时间复杂度为O(nlgn)。

代码如下：

const int INF=1e5;
int num[INF];

void Mergesort(int first,int mid,int last)   //将分治得到的两个序列排序  合并
{
	int *temp=new int[last-first+2];
	int i=first;
	int m=mid;
	int j=mid+1;
	int n=last;
	int k(0);
	while(i<=m && j<=n)
	{
		if(num[i]<num[j])
			temp[k++]=num[i++];
		else temp[k++]=num[j++];
	}
	while(i<=m) 
		temp[k++]=num[i++];
	while(j<=n)
		temp[k++]=num[j++];
	for(int i=0;i<k;i++)
		num[first+i]=temp[i];
	delete []temp;
}

void Merge(int first,int last)   //利用分治的思想将原序列分开
{
	if(first<last)
	{
		int mid=(first+last)/2;
		Merge(first,mid);
		Merge(mid+1,last);
		Mergesort(first,mid,last);  
	}
}

6.堆排序

思想：将数组A创建为一个最大堆，然后交换堆的根(最大元素)和最后一个叶节点x，将x从堆中去掉形成新的堆A1，

然后重复以上动作，直到堆中只有一个节点。

时间复杂度为O(nlgn)。

堆排序的时间复杂度是O(nlgN)，与快速排序达到相同的时间复杂度。但是在实际应用中，我们往往采用快速排序而不是堆排序。

这是因为快速排序的一个好的实现，往往比堆排序具有更好的表现。堆排序的主要用途，是在形成和处理优先级队列方面。

代码：点击打开代码链接

7.快速排序

思想：

1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；
2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]赋给A[i]；
4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]赋给A[j]；
5）重复第3、4步，直到i==j。

时间复杂度平均为O(nlogn)，最坏为O(n^2)(数组基本有序的情况)

但实际应用中经常使用的还是快排

代码如下：

#include <iostream>
#include <cstdio>
using namespace std;
const int INF=1e4;

int q_sort(int num[],int l,int r)  //一趟快速排序  时间复杂度为O(r-l)
{
    int base(num[l]);  //基准
    while(l<r)
    {
        while(l<r && num[r]>=base)  //注意“=”号一定要加上
            r--;
        num[l]=num[r];  //将不满足条件的数放到基准的左边
        while(l<r && num[l]<=base)  //注意“=”号一定要加上
            l++;
        num[r]=num[l];  //将不满足条件的数放到基准的右边
    }
    num[l]=base;  //基准的位置
    return l;
}
void quicksort(int num[],int l,int r)  //快排  时间复杂度为O(log(r-l))
{
    if(l<r)
    {
        int mid=q_sort(num,l,r);
        quicksort(num,l,mid-1);
        quicksort(num,mid+1,r);
    }
}

（未完待续。。。）