面试常见排序算法

本文先给一个表格总结各个排序算法的时间复杂度、空间复杂度、稳定性等。然后重点介绍快速排序和堆排序两个面试过程中必问的排序,最后再介绍其他排序算法。


一、常见排序算法总结

稳定性:假定在待排序的记录序列中,存在多个具有相同的关键字的记录,若经过排序,这些记录的相对次序保持不变,即在原序列中,ri=rj,且ri在rj之前,而在排序后的序列中,ri仍在rj之前,则称这种排序算法是稳定的;否则称为不稳定的。

排序算法总结

注意:堆排序和快速排序都是不稳定的,堆排序的平均情况和最好最坏情况时间复杂度都是O(nlogn)。
快速排序平均情况和最好情况时O(nlogn),最坏情况时O(n2),面试过程中常问。


二、快速排序算法总结

2.1、快排的基本思想

  1. 先从数列中取出一个数作为基准数
  2. 分区过程,将小于或等于基准数的放到左边,将大于基准数的放到右边。
  3. 再对第二步得到的左右两个区间重复1、2过程,直到各区间只有一个数。

实例介绍
有以下一组数:

7265788604283734885

1. 选取基准数:原则上基准数要随机选取,但是我们这边的数据可以认为是随机的,所以我们每次的基准数都选取第一个数。这里为72.
2. 分区。分为如下左右两区:

6576042487288837385

3. 对左右两区重复1、2步,截止到每个区只有一个数。
左区重复,选基准数、分区过程

657604248

右区

88837385

2.2、快排的时间复杂度和空间复杂度分析

时间复杂度

快速排序的时间复杂度依赖于划分是否平衡。

  • 最坏情况分析:O(n^2)
    每次划分的时候左右两区间分别包含了n-1个元素和0个元素

  • 最好情况分析:O(nlogn)
    每次划分的时候左右两区间的元素个数几乎相等。


2.3、快排的程序编写

int* quickSort(int* A, int n) {
        // write code here
        //入参校验
        if(A==NULL || n<=0){
            cout<<"入参不合法"<<endl;
            return NULL;
        }

        //快排
        coreQuickSort(A, 0, n-1);

        return A;
    }

    /*
    * 快排,里面递归调用,递归截止条件为left>=right
    */
    void coreQuickSort(int* A, int left, int right){
        if(left<right){
            int mid=parition(A, left, right);
            coreQuickSort(A, left, mid-1);
            coreQuickSort(A, mid+1, right);
        }
    }


    /**
    * 一次划分
    *@return 一次划分完后的中间索引
    */
    int parition(int* A, int left, int right){
        int key=A[right];
        int lessNumIndex=left-1;

        for(int search=left; search<=right; search++){
            if(A[search]<=key){
                lessNumIndex++;
                swap(A, lessNumIndex, search);
            }
        }

        return lessNumIndex;
    }

    /**
    * 交换函数
    */
    void swap(int* A, int index1, int index2){
        int tmp=A[index1];
        A[index1]=A[index2];
        A[index2]=tmp;
    }

三、堆排序算法总结

3.1、堆排序的思想

堆:以最小堆为例,根节点不大于左右子节点。
堆排序:先将数组初始化为最小堆,然后每次取出堆顶的元素,取完之后对堆进行维护,维护其为最小堆。这样取出来的元素就会是从小到大排列的。

3.2、堆排序的时间复杂度和空间复杂度分析

时间复杂度:

时间复杂度是O(n*logn),对数组初始化为堆的时候,时间复杂度为O(n),取完堆顶元素后,需要维护堆,每次维护堆的时间复杂度为O(logn),共需要N-1次维护堆的操作。
所以O(N)+(N-1)*O(logN)=O(N*logN)

3.3、堆排序程序编写

int* heapSort(int* A, int n) {
        int lastPosi=n-1;
        maxHeapBuild(A, lastPosi);     //建最大堆
        while(lastPosi>=1){            //维护最大堆
            swap(A, 0, lastPosi);
            lastPosi=lastPosi-1;
            heapifyMax(A, 0, lastPosi);
        }
        return A;
    }

    //建立最大堆
    void maxHeapBuild(int* A, int lastPosi){
        for(int i=(lastPosi-1)/2; i>=0; i--){
            heapifyMax(A, i, lastPosi);
        }
    }

    //堆下沉,建立最大堆和维护堆的时候都需要的过程
    void heapifyMax(int* A, int posi, int lastPosi){
        int maxLR=2*posi+1;
        while(maxLR<=lastPosi){
            if( maxLR < lastPosi && A[maxLR+1]>A[maxLR]){
                maxLR++;
            }
            if(A[maxLR] <= A[posi]){
                break;
            }
            else{
                swap(A, posi,maxLR);
                posi=maxLR;
                maxLR=2*posi+1;
            }
        }
    }

    //交换
    void swap(int* A, int index1, int index2){
        int tmp=A[index1];
        A[index1]=A[index2];
        A[index2]=tmp;
    }
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值