七种排序算法整理代码全部测试通过，一眼就懂，面试手撕系列）

最新推荐文章于 2022-08-03 20:29:58 发布

一禅的师兄

最新推荐文章于 2022-08-03 20:29:58 发布

阅读量344

点赞数

分类专栏：笔试刷题每日一题

本文链接：https://blog.csdn.net/weixin_42145502/article/details/107526421

版权

笔试刷题每日一题专栏收录该内容

102 篇文章 9 订阅

订阅专栏

如果连排序都不写不不出来，不要去面试了，自己找难看！！丢人！！

这里写图片描述

1.冒泡排序：

冒泡排序的原理：从第一个数开始，依次往后比较，如果前面的数比后面的数大就交换。

n个数据需要来回n-1趟，每将一个数归位我们将其称为“一趟”,时间复杂度： O(N^2),稳定排序。

在这里插入图片描述

如果有n个数进行排序，只需将n-1个数归位，也就是说要进行n-1趟操作。而“每一趟”都需要从第1位开始进行相邻两个数的比较，将较小的一个数放在后面，比较完毕后向后挪一位继续比较下面两个相邻数的大小，重复此步骤，直到最后一个尚未归位的数，已经归位的数则无需再进行比较（已经归位的数你还比较个啥，浪费表情）

2.选择排序

选择排序就是不断地从未排序的元素中选择最大（或者最下）的元素放入已经排好序的元素集合中，直到未排序中仅剩一个元素为止。

第一步：
这里写图片描述
第二步：

第三步：

第四步：

第五步：

3.插入排序

基本思想：每一步将一个待排序的数据插入到前面已经排好序的有序序列中，直到插完所有元素为止

4.归并排序

思路：

1.利用递归确保左边有序

2.利用递归确定右边有序

3.最后将两个有序的序列进行合并

5、堆排序

堆排序的基本思想是：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了

预备知识

堆排序

　　堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。首先简单了解下堆结构。

堆

　　堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。如下图：

同时，我们对堆中的结点按层进行编号，将这种逻辑结构映射到数组中就是下面这个样子

该数组从逻辑上讲就是一个堆结构，我们用简单的公式来描述一下堆的定义就是：

大顶堆：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]

小顶堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]

ok，了解了这些定义。接下来，我们来看看堆排序的基本思想及基本步骤：

步骤一构造初始堆。将给定无序序列构造成一个大顶堆（一般升序采用大顶堆，降序采用小顶堆)。

步骤二将堆顶元素与末尾元素进行交换，使末尾元素最大。然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换。

再简单总结下堆排序的基本思路：

　　a.将无需序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆;

　　b.将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端;

c.重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。

C#算法设计排序篇之06-堆排序（附带动画演示程序）

构造堆

将无序数组构造成一个大根堆（升序用大根堆，降序就用小根堆）

假设存在以下数组

主要思路：第一次保证0~0位置大根堆结构（废话），第二次保证0~1位置大根堆结构，第三次保证0~2位置大根堆结构...直到保证0~n-1位置大根堆结构（每次新插入的数据都与其父结点进行比较，如果插入的数比父结点大，则与父结点交换，否则一直向上交换，直到小于等于父结点，或者来到了顶端）

插入6的时候，6大于他的父结点3，即arr(1)>arr(0)，则交换；此时，保证了0~1位置是大根堆结构，如下图：

(友情提示：待交换的数为蓝色，交换后的数为绿色)

插入8的时候，8大于其父结点6，即arr(2)>arr(0),则交换；此时，保证了0~2位置是大根堆结构，如下图

插入5的时候，5大于其父结点3，则交换，交换之后，5又发现比8小，所以不交换；此时，保证了0~3位置大根堆结构，如下图

插入7的时候，7大于其父结点5，则交换，交换之后，7又发现比8小，所以不交换；此时整个数组已经是大根堆结构

2.2 固定最大值再构造堆

此时，我们已经得到一个大根堆，下面将顶端的数与最后一位数交换，然后将剩余的数再构造成一个大根堆

（友情提示：黑色的为固定好的数字，不再参与排序）

此时最大数8已经来到末尾，则固定不动，后面只需要对顶端的数据进行操作即可，拿顶端的数与其左右孩子较大的数进行比较，如果顶端的数大于其左右孩子较大的数，则停止，如果顶端的数小于其左右孩子较大的数，则交换，然后继续与下面的孩子进行比较

下图中，5的左右孩子中，左孩子7比右孩子6大，则5与7进行比较，发现5<7，则交换；交换后，发现5已经大于他的左孩子，说明剩余的数已经构成大根堆，后面就是重复固定最大值，然后构造大根堆

如下图：顶端数7与末尾数3进行交换，固定好7，

剩余的数开始构造大根堆，然后顶端数与末尾数交换，固定最大值再构造大根堆，重复执行上面的操作，最终会得到有序数组

最后说明：希尔排序参考插入排序，快速排序写臭，只给出代码。

#include <iostream>
#include <vector>
#include <algorithm>
using namespace  std;
//1.bubble
vector<int> bubblesort(vector<int>& arr)
{
  int len=arr.size();
  for(int i=0;i<len-1;i++){
      for(int j=0;j<len-i-1;j++){ //从第1位开始比较直到最后一个尚未归位的数
          if(arr[j]>arr[j+1]){
              swap(arr[j],arr[j+1]);
          }
      }
  }
  return arr;
}

//基本思想：每一步将一个待排序的数据插入到前面已经排好序的有序序列中，直到插完所有元素为止。
/**
 * @brief InsertSort()
 * @param arr
 * @return
 */
vector<int> InsertSort(vector<int>& arr)
{
  int len=arr.size();
  int i;
  int j;
  //defaule i=0 sorted
  for( i=1;i<len;i++){ //外层是无序，待插入的数据，和选择排序相反
      int temp=arr[i];
      for( j=i-1;j>=0&&arr[j]>temp;j--){//内层是有序的
          arr[j+1]=arr[j];
      }
      arr[j+1]=temp;//put the sorted arr  tail
  }
 return  arr;
}
/**
 * @brief shellsort
 * @param arr
 * @return
 *
 */
vector<int>  shellsort(vector<int>& arr)
{
   int i;
   int j;
   int len=arr.size();
   for(int gap=len/2;gap>0;gap/=2)
   {
     for(i=gap;i<len;i++){
        int temp=arr[i];
        for(j=i-1;j>0&&arr[j]>temp;j--){
            arr[j+1]=arr[j];
        }
        arr[j+1]=temp;
     }
   }
    return arr;
}

/**
 //===5---quicksort
 * @brief quicksort
 * @param arr
 * @param left
 * @param right
 * @return
 * 它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，
 * 然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
 */
vector<int> quicksort(vector<int>& arr,int left,int right)
{

    if(right<left) return arr;
   int low=left;
   int high=right;
   int base=arr[low];
   while(low<high){
      while(low<high && arr[high]>=base){
       high-- ;
      }
      arr[low]=arr[high];
      while(low<high && arr[low]<=base){
       low++;
      }
       arr[high]=arr[low];
   }
    arr[low]=base;
    quicksort(arr,left,low-1);
    quicksort(arr,low+1,right);
    return arr;
}
//4.seclectsort
/**
 * @brief selectsort
 * @param arr
 * @return
 * @brief: 选择排序法是在要排序的一组数中，选出最小（或最大）的一个数与第一个位置的数交换；
 *         在剩下的数当中找最小的与第二个位置的数交换，即顺序放在已排好序的数列的最后，如此循环，直到全部数据元素排完为止
 */
vector<int>  selectsort(vector<int>& arr)
{
   int i;
   int j;
   int len=arr.size();
   for(i=0;i<len;i++){ /外层控制有序
       int minIndex=i;
       for(j=i+1;j<len;j++){ //在无序区间找出最小元素
           if(arr[j]<arr[minIndex]){
               minIndex=j;
           }
       }
       swap(arr[i],arr[minIndex]);
   }
   return arr;
}
//=================6 mergesort====================================
static vector<int> merge(vector<int>& num,int l1,int r1,int l2,int r2)
{

    int i=l1;
    int j=l2;
    int n=r1-l1+r2-l2+2;
    int k=0;
    vector<int> temp(num.size());
    while(i<=r1&&j<=r2){
      if(num[i]<num[j]){
          temp[k++]=num[i++];
      }else{
          temp[k++]=num[j++];
      }
    }
    while(i<=r1){
        temp[k++]=num[i++];

    }
    while(j<=r2){
        temp[k++]=num[j++];
    }
    for(int i=0;i<n;i++){
        num[l1+i]=temp[i];
    }
   return num;

}
/**
 * @brief mergesort
 * @param arr
 * @param left
 * @param right
 * @return
 * 归并排序的算法我们通常用递归实现。
   先把待排序区间 [s,t] 以中点二分；
   接着把左边子区间排序；
   再把右边子区间排序；
   最后把左区间和右区间用一次归并操作合并成有序的区间 [s,t] 。
 */
vector<int>  mergesort(vector<int>& arr,int left,int right)
{
   if(left<right)
   {
   int mid=left+(right-left)/2;
   mergesort(arr,left,mid);  //左边有序
   mergesort(arr,mid+1,right);//右边有序
   merge(arr,left,mid,mid+1,right);//最后将两个有序的序列合并
   }
   return arr;
}
//==================7 heap=============================
/**
堆排序的基本思想是：1、将带排序的序列构造成一个大顶堆，根据大顶堆的性质，当前堆的根节点（堆顶）就是序列中最大的元素；
2、将堆顶元素和最后一个元素交换，然后将剩下的节点重新构造成一个大顶堆；
3、重复步骤2，如此反复，从第一次构建大顶堆开始，
每一次构建，我们都能获得一个序列的最大值，然后把它放到大顶堆的尾部。最后，就得到一个有序的序列了。
 * @brief adjustHeap
 * @param arr
 * @param i
 * @param length
 * 大顶堆：每个结点的值都大于或等于其左右孩子结点的值，根结点的值一定是所有结点中最大的
   小顶堆：每个结点的值都小于或等于其左右孩子结点的值，根结点的值一定是所有结点中最小的
 */
static void  adjustHeap(vector<int>&arr ,int i ,int length){


    int temp=arr[i];  //derive the current node
    //k(i)>=k(2i)
    //k(i)>=k(2i+1)
    // 按照层序遍历，将上图中的大顶堆存入数组中
    //循环遍历当前结点s的左右孩子j，因为是完全二叉树，所以所以左孩子的序号是2*k，右孩子的序号是2*k+1
    for(int k=2*i+1;k<length;k=2*k+1){
        //k<length-1说明当前的孩子结点不是完全二叉树的最后一个结点
        if(k<length-1 && arr[k]<arr[k+1]){
            k++;
        }
        if(arr[k]>temp){
            arr[i]=arr[k];
            i=k;
        }else{
            break;
        }
    }
    arr[i]=temp;

}
vector<int>  heapsort(vector<int>& arr)
{
    int j;
    int length=arr.size();
   //从第最后一个非叶子节点开始，调整对结构
    for(int i=length/2-1;i>=0;i--){
        adjustHeap(arr,i,length);
    }
    for(int j=length-1;j>=0;j--){
        swap(arr[j],arr[0]); //换堆顶元素与当前末尾元素
        adjustHeap(arr,0,j); //重新调整堆结构
    }
    return arr;


}
//print vector
void printvec(vector<int> arr){
  for(auto x:arr){
      cout<<x<<" ";
  }
}
int main()
{
    vector<int>  arr={3,6,8,5,7};
    vector<int>   temp=heapsort(arr);
    printvec(temp);
    return 0;
}
//print vector
void printvec(vector<int> arr){
  for(auto x:arr){
      cout<<x<<" ";
  }
}
int main()
{
    vector<int>  arr={1,3,2,5,6,4};
   vector<int>   temp=heapsort(arr);
    printvec(temp);

    return 0;
}

链表归并排序

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param head ListNode类 
     * @return ListNode类
     */
    ListNode* sortList(ListNode* head) {
        // write code here
     if(head==NULL||head->next==NULL){
      return head;  //必须加
     }
      ListNode* mid=middle(head); 将左右分割开
      ListNode* right=sortList(mid->next);
      mid->next=NULL;
      ListNode* left=sortList(head);
      return mergesort(left, right);
    }
    ListNode *mergesort(ListNode* left,ListNode* right){
        if(left==NULL)   return  right;
        if(right==NULL)   return left;
        ListNode* temp=new  ListNode(0);
        ListNode* head=temp;
        while(left!=NULL && right!=NULL){
            if(left->val<right->val){
                head->next=left;
                left=left->next;
             
            }else{
                head->next=right;
                right=right->next;
             
            }
               head=head->next;
        }
        if(left==NULL){
            head->next=right;
        }
        if(right==NULL){
            head->next=left;
        }
        return temp->next;
    }
    ListNode *middle(ListNode* head){
        ListNode *slow=head;
        ListNode *fast=head->next;
        while(fast!=NULL && fast->next!=NULL){
            slow=slow->next;
            fast=fast->next->next;
        }
        return slow;
    }
  
};

一禅的师兄

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
七种排序算法整理代码全部测试通过，一眼就懂，面试手撕系列）

#include <iostream>#include <vector>#include <queue>#include <math.h>#include <algorithm>#include <time.h>using namespace std;/*** @projectName sort* @author zjl* @date 2020-07-22*///=====.
复制链接

扫一扫