排序算法

1.十大排序算法复杂度

中文名称	英文名称	平均时间复杂度	稳定性
选择排序	Selection	$n^2$	不稳定
冒泡排序	Bubble	$n^2$	稳
插入排序	Insertion	$n^2$	稳
堆排序	heap	$nlo{g}_{2}n$	不稳
希尔排序	Shell	$n^{1.3}$	不稳
归并排序	Merge	$nlo{g}_{2}n$	稳
快速排序	Quick	$nlo{g}_{2}n$	不稳
桶排序	Bucket	n+k	稳
计数排序	Counting	n+k	稳
基数排序	Radix	n*k	稳

记忆法：转自马士兵

选泡插，
快归堆希桶计基
恩方恩老恩一三
对恩加K恩乘K，(对：指桶排序和计数排序一对)
不稳稳稳不稳稳，
不稳不稳稳稳稳，

2、选择排序

最没用的算法，时间复杂度高，还不稳定。
基本思想：从给定的数中选择出最大(或最小)的数，将其放在第一个位置；再从剩下的数中选择出最大(或最小)的数，将其放在第二个位置。以此类推！

void selectSort(int arry[],int len)
{
    for (int i = 0; i < len-1; i++)
    {
        int minpos = i;     //记录最小数的位置
        for (int j = i+1; j < len; j++)
        {
            minpos = arry[j]<arry[minpos]?j:minpos;
        }
        swap(arry[i],arry[minpos]);    
    }
    
}

简单优化版：每次外层的循环后找出最大值和最小值，将小值放在第一位，将最大值放在最后一位；对剩下的元素同样找出最大值和最小值，将最小值放在第二位，最大值放在倒数第二位；依次类推，直至排序结束。可以将外层的for循环次数减半。

//优化版：每次同时找出最大值和最小值，减少遍历的次数
//写的时候注意循环的边界条件
void selectSort(int arry[],int len)
{
    for (int i = 0; i != len/2; i++)
    {
        int minpos = arry[i]>arry[i+1]?i+1:i;     //记录最小数的位置
        int maxpos = arry[i]<arry[i+1]?i+1:i;	  //记录最大数的位置        
		for (int j = i+2; j < len-i; j++)
        {
            minpos = arry[j]<arry[minpos]?j:minpos;
            maxpos = arry[j]>arry[maxpos]?j:maxpos;
            // cout<<"j = "<<j<<endl;
        }
        // cout<<"max:"<<arry[maxpos]<<" "<<"min:"<<arry[minpos]<<endl;
        swap(arry[i],arry[minpos]);
        swap(arry[len-i-1],arry[maxpos]);
        // PrintfArry(arry,len);       
    }        
}

3、冒泡排序

基本思想 ：从给定的数中选出最大的数，放在数组末尾；在剩下的数中在选出最大的数，放在数组倒数第二位。以此类推。

void BubbleSort(int arry[],int len)
{
    int i,j;
    /* 外循环为排序趟数，len个数进行len-1趟 */
    for (i = 0; i < len-1; i++)
    {
        /* 内循环为每趟比较的次数，第i趟比较len-i次 */
        for (j = 0; j < len-1-i; j++)
        {
            if(arry[j]>arry[j+1])
            {
                int temp = arry[j];
                arry[j] = arry[j+1];
                arry[j+1] = temp;
            }
        }  
    }
    
}

简单优化改良版：如果给定的数是有序的，或者经过几次排序后剩下的数是有序的，使用上面的算法就会造成时间的浪费。可以加个标志，如果经过某几次排序后剩下的为有序的话，就不会进入里面的swap所在的if块，那么剩下的也没必要在继续排了。

void Bubblesort(vector<int> &arr)
{
	int len = arr.size();
	for (int i = 0; i < len-1; i++)
	{
		bool state = true;	//假设剩下的序列有序
		for (int j = 0; j < len-i-1; j++)
		{	
			if(arr[j]>arr[j+1])
			{
				//进入里面说明无序，还需要交换位置
				state = false;
				swap(arr[j],arr[j+1]);
			}
		}
		if(state)	//如果剩下的有序，那么state就不会被置位false。剩下的也没必要继续进行排序了
			break;
	}
}

4、插入排序

基本思想：类似于打扑克牌时，将待排序的数在已经排序好的数中选择合适的位置插入

void insertSort(int arr[],int len)
{
    for (int i = 0; i < len; i++)
    {
        for (int j = i; j > 0; j--)
        {
            if(arr[j-1]>arr[j])
            	swap(arr[j-1],arr[j]);
        }  
    } 
}

简易优化版：上述方法会额外的调用swap方法，造成时间的浪费。下面是简单优化。将待排序的数用一个临时变量保存，为待排序的数选择合适位置插入，在插入之前每次将前一个数后一个位置移动。

void insertSort(int arr[],int len)
{
    int i =0, j=0;
    for (i = 0; i < len; i++)
    {
        int temp = arr[i];
        for (j = i-1; j >= 0; j--)
        {
            if(arr[j]>temp)
            {
                arr[j+1] = arr[j];
            }
            else
                break;   
        }
        arr[j+1] = temp;       
    } 
}

5、希尔排序

希尔排序是一种递减增量排序方法，是插入排序的改进版。
基本思想 ：先选择一个步长增量，对原始数据按照步长gap分组。对每组内的数据进行插入排序；在减小步长，再次按照步长进行分组，对每组内的数据进行插入排序。直至步长变为1进行，进行最后的插入排序。
步长的选择：采用Kunth序列来确定步长是比较高效的选择。
Kunth序列：h=3*h+1(h=1)

void shellsort(vector<int> &v)
{
    //选择步长
    int h = 1;
    while (h <= v.size()-1)
    {
        h = h*3+1;
    }    
    for(int step = h ; step > 0; step = (step-1)/3)
    {
        //下面还是插入排序
        for(int i = step; i<v.size(); i++)
        {
            for (int j = i; j>step-1; j-= step)
            {
                if(v[j] < v[j-step])
                    swap(v[j], v[j-step]);
            }
        }
    }   
}