数据结构之排序算法总结

八大排序，三大查找是 数据结构中非常基础的知识点，在这里为了复习顺带总结了一下常见的八种排序算法。
常见的八大排序算法，他们之间关系如下：

各排序算法的时间复杂度及空间复杂度如下：

直接插入排序：

直接插入排序的核心思想就是：将数组中的所有元素依次跟前面已经排好的元素相比较，如果选择的元素比已排序的元素小，则交换，直到全部元素都比较过。

因此，从上面的描述中我们可以发现，直接插入排序可以用两个循环完成：
第一层循环：遍历待比较的所有数组元素
第二层循环：将本轮选择的元素(a[j+1])与已经排好序的元素(a[j])相比较。
如果：a[j+1]> a[j]，那么将二者交换：

void insertSort(int a[], int n) {
    int i, j, temp;
    for (i = 1; i < n; i++) {
        // as a guard
        temp = a[i];
        // find location and move other elements back
        for (j = i - 1; j >= 0 && temp < a[j]; --j)
            a[j + 1] = a[j];
        // insert into correct place
        a[j + 1] = temp;
    }
}

冒泡排序：

将序列当中的左右元素，依次比较，保证右边的元素始终大于左边的元素；

（ 第一轮结束后，序列最后一个元素一定是当前序列的最大值；）
对序列当中剩下的n-1个元素再次执行步骤1。
对于长度为n的序列，一共需要执行n-1轮比较：

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

希尔（shell）排序

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

void shellSort(int *ary,int len)
{
    int i,j;
    int increment = len;//增量
    int key;
    while(increment > 1)//最后在增量为1并且是执行了情况下停止。
    {
        increment = increment/3 + 1;//根据公式
        //printf("increment:%d\n",increment);
        for (i=increment;i<len;i++)//从[0]开始，对相距增量步长的元素集合进行修改。
        {
            key = ary[i];
            //以下和直接插入排序类似。
            j=i-increment;
            while(j >= 0)
            {
                if (key < ary[j] )
                {
                    int temp = ary[j];
                    ary[j] = key;
                    ary[j+increment] = temp;
                }
                j=j-increment;
            }
        }
    }
}

快速排序

快速排序的基本思想是，通过一轮的排序将序列分割成独立的两部分，其中一部分序列的关键字（这里主要用值来表示）均比另一部分关键字小。继续对长度较短的序列进行同样的分割，最后到达整体有序。在排序过程中，由于已经分开的两部分的元素不需要进行比较，故减少了比较次数，降低了排序时间。

void quicksort(int* a, int l,int r)
｛
	int i = l;
	int j = r;
	int temp = a[l];
	while(i < j)
	{
		while(a[j] >= temp&&j>i)
		{
			j--;
		}
		if(j > i)
		{
			a[i] = a[j];
			i++;
			while(a[i] < temp&&i<j)
			{
				i++;
			}
			if(i < j)	
			{
				a[j] = a[i];
				j--;
			}
		}
	}
	a[i] = temp;
	if(l < (i-1))	
	{
		quicksort(a,l,i-1);
	}
	if((i+1) > r)
	{
		quicksort(a,j+1,r);
	}
｝

选择排序

选择排序：每趟从待排序的记录中选出关键字最小的记录，顺序放在已排序的记录序列末尾，直到全部排序结束为止。

void selectSort(int a[],int n)
{  
   // 需要遍历获得最小值的次数
    // 要注意一点，当要排序 N 个数，已经经过 N-1 次遍历后，已经是有序数列
    for (int i = 0; i < n- 1; i++)
    {
        int temp = 0;
        int index = i; // 用来保存最小值得索引
       // 寻找第i个小的数值
        for (int j = i + 1; j < n; j++)
        {
            if (a[index] > a[j])
            {
                index = j;
            }
        }
        // 将找到的第i个小的数值放在第i个位置上
        temp = a[index];
        a[index] = a[i];
        a[i] = temp;
     }
}