排序笔试面试题（一）

本博客内容
一、什么是排序
二、排序算法分类
三、排序算法分析
四、排序时间和空间复杂度总结

一、什么是排序

参考博客：https://blog.csdn.net/xiazdong/article/details/7304239
排序是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。
1.可以分为 稳定/不稳定。
　　稳定：如果a=b,排序前，a就在b前面，排序后仍然a在b前面，就是稳定的。
2.可以分为：内排序/外排序。
　　内排序：所有排序操作都在内存中完成。
　　外排序:由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行。
排序耗时的操作：比较、移动。

二、排序算法分类

主要分为4大类：
交换类：冒泡、快排。特点：通过不断的比较和交换进行排序
选择类：简单选择、堆排序。特点：看准了再移动
插入类：简单插入、希尔排序。特点：通过插入的手段进行排序
归并类：归并排序。特点：先分割后合并
上述排序算法都是基于排序的，还有一类排序算法不是基于比较的排序算法，即计算排序、基数排序。
最开始排序算法都是O(n^2),希尔排序的出现打破僵局。
最基础的排序算法如下：

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

缺点：每次找最小值都是单纯的找，没有为下一次做出铺垫。

三、排序算法分析

1.冒泡排序

思想：两两相邻元素之间的比较，如果前者大于后者，就交换

void bubbleSort(int *a ,int n)
{
    for(int i=0;i<n-1;i++)
        for(int j=0;j<n-1-i;j++)
            if(a[j]>a[j+1])   //如果前面的值大于后面的值，就交换，将最大值依次放到最后
                swap(j,j+1);
}

如原本序列基本是排好的，改进方法：定义一个变量，如果一次循环中没有交换过元素，则说明已经排好序。

void bubbleSort2(int * a,int n)
{
    bool isChanged=true;
    for(int i=0;i<n-1&&isChanged;i++)
    {
        isChanged=false;
        for(int j=0;j<n-1-i;j++)
            if(a[j]>a[j+1])
                {
                swap(j,j+1);
                isChanged=true;
                }
    }
}

复杂度分析：最好情况：n-1次比较后结束，时间O（n）,不占空间
最坏情况：n(n-1)/2;时间O(n^2),空间O(1).

2.简单选择排序

思想：每次循环找到最小值，并交换
相对于最简单的排序，对于很多不必要的交换做了改进，每个循环不断比较后记录最小值，只做了一次交换（当然也可能不交换，当最小值已经在正确位置）

for(int i=0;i<len-1;i++)
    {
        int min=i;
        for(int j=i+1;j<len;j++)
        {
            if(a[min]>a[j])
                min=j;
        }
        if(min!=i)
            swap(a[min],a[i];
    }

最好：n(n-1)/2次比较 不交换 时间复杂度：o(n^2).
最坏：n(n-1)/2次比较 n-1次交换 复杂度仍为o(n^2).

3.简单插入排序

思想：给定序列，存在一个分界线，分界线的左边被认为是有序的，分界线的右边还没被排序，每次取没被排序的最左边一个和已排序的做比较，并插入到正确位置；我们默认索引0的子数组有序；每次循环将分界线右边的一个元素插入有序数组中，并将分界线向右移一位；

for(int i=1;i<len;i++)
    {
        int key=a[i];  //记录未排序的第一个值
        int j=i-1;   //未排序第一个值的左边
        while(j>=0&&a[j]>key) //从右向左，找到合适地方插入
            {
                a[j+1]=a[j]; //将大值向后放置、腾出空间
                j--;
            }
            a[j+1]=key; //最后将待插入的值放到合适位置上
    }               

最好：本身有序，只考虑前一次，进行n-1次比较，0次移动 时间O(n).
最坏：数组逆序，每次都要和前面的全部比较移动 时间复杂度：O(n^2).

排序中级阶段：（4个改进版的排序算法）

4.希尔排序

思想：简单插入排序的改进版。简单插入排序对数据少/基本有序时很有效，因此通过将序列进行分组排序使得每组容量变小，再进行分组排序，然后进行一次简单插入排序即可。分组是跳跃分组，逐渐缩小增量。按组进行插入排序操作，增量为1时，只需微调即可结束。
举例：例如增量increment=3;i%3相等的索引为一组，1 ，1+3,1+3*2：公式：increment=increment/3+1;

void shellSort(int * a,int len)
{
    int h=1;
    while(h<len)
        h=3*h+1; //选取步长
    while(h>0)
        {
            for(int j=h;j<len;j++)
                {
                    int key=a[j];  //保存当前值
                    int i=j-h;
                    while(i>=0 && a[i]>key)
                        {
                            a[i+h]=a[i];
                            i=i-h;      //当前分组中减去一个分量，继续往前
                        }
                        a[i+h]=key;
                }
                h=h/3;  //步长依次减少
        }
}                                   

希尔排序的时间复杂度与选取的步长有关。

5.堆排序

思想：简单选择排序的改进版；构建一颗完全二叉树，首先构建大根堆，然后每次把根节点即最大值移除，并用编号最后的节点替代，这时数组长度减1，然后重新构建大根堆，以此类推
大根堆：任意父节点都比子节点大；
小根堆：任意父节点都比子节点小；
举例：构建一个小顶堆，得到的是一个降序序列

void adjustDown(int arr[],int i,int n)
//参数i:开始判断的非叶子节点            n：当前节点的最后一个数
{
    int j=i*2+1;  //子节点
    while(j<n)
    {
        if(j+1<n&&arr[j]>arr[j+1])//如果有右节点，而且右节点比左节点还小 (如果建立大根堆，改为<)
            j++;
        if(arr[i]<arr[j])                  //(如果建立大根堆，改为>)
            break;                          //如果最小的值就在顶上，直接退出，不进行交换操作
        swap(arr[i],arr[j]);        //交换i和j的值
        i=j;    //如果发生了换，要将底层节点作为新的头结点继续判断
        j=i*2+1;     //如果j直接超过了根节点的个数n，证明无下层节点，直接返回
    }
}
void makeHeap(int arr[] ,int n)
{
    int i=0;  //从非叶子节点开始找
    for(i=n/2-1;i>=0;i--)  
        adjustDown(arr,i,n);
}
void heapSort(int arr[],int len)
{
    int i=0;
    makeHeap(arr,len);//第一步，构建初始堆 建堆复杂度为O(n). 
    for(int i=len-1;i>=0;i--)
        {
            swap(arr[i],arr[0]); // 交换堆顶元素和尾元素
            adjustDown(arr,0,i);  //重新建堆
        }
}

6.归并排序

思想：利用递归进行分割和合并，分割直到长度为1为止，并在合并前保证两序列原本各自有序，合并后也有序；

void merge(int * a,int * b,int start,int mid,int end)
{
    int i=start; //左边第一个开始
    int j=mid+1; //右边第一个开始
    int index=start;    //结果的左边
    while(i<=mid && j<=end)
        {
            if(a[i]<=a[j]) //如果左边的值小
                 b[index++]=a[i++];  
            else              //右边的小，右边的往结果中放
                b[index++]=a[j++];  
        }
        //处理剩余元素
    while(i<=mid)   
         b[index++]=a[i++];       
    while(j<=end)  
        b[index++]=b[j++];     
 }          
void mergeSort(int * a,int *b,int start,int end)
{
    if(start<end)       //如果区间还有元素
        {
            int mid=(end-start)/2+start; //找到中间元素
            mergeSort(b,a,start,mid);  //左边部分排序
            mergeSort(b,a,mid+1,end);  //右边部分排序
            merge(a,b,start,mid,end);  //合并操作
        }
}
int main()
{
     int arr[9]={5,3,1,7,9,6,2,4,8};     
     int* temp_arr = new int [sizeof(arr)/sizeof(int)];  //创建临时数组b
      memcpy(temp_arr ,a,sizeof(arr));     //临时数组b 存放的值和a的一样
      merge_sort(arr,temp_arr,0,8);     //执行排序算法
      for(int i=0;i<sizeof(temp_arr)/sizeof(int);i++)  
        std::cout<<temp_arr[i]<<' ';  
    return 0;    
}

时间复杂度为O(log2^n) 空间复杂度为O(n)

7.快速排序

思想：冒泡升级版，现阶段用最多。分治的策略，选取一个基准（一般将第一个作为基准），分为2部分，前半部分比其小，后半部分比其大，从后向前查找，将key值赋给中间值，然后分开2次调用该函数；
注意：如果序列基本有序或者序列个数较少，则可以采用简单插入排序，因为快速排序对于这些情况效率不高。

void quickSort(int a [] ,int low,int high)
{
    if(low>=high)
        return ;
    int first=low;
    int last=high;
    int key=a[first];
    while(first<last)
        {
            while(first<last && a[last]>=key)
                --last;
            a[first]=a[last];
            while(first<last && a[first]<=key)
                ++first;
            a[last]=a[first];

        }
            a[first]=key;
            quickSort(a,low,first-1);
            quickSort(a,first+1,high);
}           

8.计数排序和基数排序

后续再学习这2个…

四、排序时间和空间复杂度总结

稳定性：冒泡/直接插入/归并是稳定的
空间复杂度：快排O(log^n) 归并O(n) ,其余都为O(1).

欢迎大家批评指正，谢谢，未完待续….