必刷算法题之排序篇（题目及代码）---C++

已于 2022-05-11 10:20:37 修改
阅读量9.6k 收藏 19
点赞数 3
分类专栏： 剑指offer 文章标签： 算法 面试 c++ 排序算法 leetcode
于 2022-03-15 16:44:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40077565/article/details/123427785
版权

前言，该篇博客记录了和排序有关的一些题目，差不多是逐级递增的难度，后续还会补充，有具体思路和代码。

文章目录

第一题：排序

在这里插入图片描述
解法一：（冒泡排序）

具体代码如下：

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 将给定数组排序
     * @param arr int整型vector 待排序的数组
     * @return int整型vector
     */
    vector<int> MySort(vector<int>& arr) {
        //vector<int> res;
        int temp;
        for(int i=0;i<arr.size()-1;i++){
           for(int j=i+1;j<arr.size();j++){
               if (arr[i]>arr[j]){
                   temp = arr[j];
                   arr[j] = arr[i];
                   arr[i] = temp;
                }
           }
        }
        return arr;
    }
};

解法二：（快速排序）不了解快速排序的可以点击此处了解1或 点击此处了解2

具体代码如下：

class Solution {
public:
    
    vector<int> MySort(vector<int>& arr) {
        Quick_Sort(arr,0,arr.size()-1);  %调用快速排序函数
        return arr;
    }
    
    void Quick_Sort(vector<int>& arr, int begin, int end){  %这是一个递归函数
    if(begin > end)   %说明到结束位置了
        return;
    int tmp = arr[begin];   %默认从第一个数开始比较
    int i = begin;          %首位置的哨兵
    int j = end;			%尾位置的哨兵
    while(i != j){
        while(arr[j] >= tmp && j > i){   %j的作用是找到比tmp小的数，如果没有，继续向前找
            j--;
            }    %不满足循环说明此时arr[j] < tmp或者j=i
        while(arr[i] <= tmp && j > i){   %i的作用是找到比tmp大的数，如果没有，继续向后找
            i++;
            }   %不满足循环说明此时arr[i] > tmp或者j=i
        if(j > i){    %说明此时j>i，且arr[i] > tmp或是arr[j] < tmp其中一个条件满足,那么交换两者位置的值，
            int t = arr[i];
            arr[i] = arr[j];
            arr[j] = t;
        }
    }
    %第一轮“探测"结束后，哨兵i、j重合了，这时候该重合点拆分成两个序列，继续递归
    arr[begin] = arr[i];
    arr[i] = tmp;
    Quick_Sort(arr, begin, i-1);
    Quick_Sort(arr, i+1, end);
    }
};

第二题：判断字符是否唯一

在这里插入图片描述

解法一：（排序法）
解题思路如下：
step1:先对字符串进行排序
step2:出现过两次就说明重复了（判断依据：相邻的字符相等）

具体代码如下：

class Solution {
public:
    bool isUnique(string str) {
    sort(str.begin(), str.end());  
    for(int i=0;i<str.size()-1;i++){
        if(str[i]==str[i+1]){
            return false;
        }
    }
    return true;
    }
};

解法二：（双层循环，和后续的数进行对比，查看是否相同）
具体代码如下：

class Solution {
public:
    bool isUnique(string str) {
    for(int i=0;i<str.size()-1;i++){
        for(int j=i+1;j<str.size();j++){
            if(str[i]==str[j]){
                return false;
            }
        }
    }
    return true;
    }
};

解法三：（哈希表）
具体代码如下：

class Solution {
public:
    bool isUnique(string astr) {
        if(astr.length() == 0)
            return true;
        //创建哈希表
        unordered_map<char, int>map;
        for(int i = 0; i< astr.length(); i++){
            if(map.find(astr[i])!= map.end())  //如果在map中找到了对应的数，返回false
                return false;
            map[astr[i]] = i;   //否则，将这个数加入到map中
        }
        return true;
    }
};

第三题: 最小的k个数

在这里插入图片描述
解题思路：
先对数组进行排序，然后输出最小的4个数。

解法一：（冒泡排序，时间复杂度效率不高）
具体代码如下：

class Solution {
public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        vector<int> res;
        int temp;
        if(0==k){
            return res;
        }else
            for(int i=0;i<input.size()-1;i++)  %先进行排序
            {
                for(int j=i;j<input.size();j++)
                {
                    if(input[i]>input[j])
                    {
                        temp=input[j];
                        input[j]=input[i];
                        input[i]=temp;
                    }
                }
            }
        for(int i=0;i<k;i++){   %输出排序后的前k个数
            res.push_back(input[i]);
        }
        return res;
    }
};

解法二：（快速排序）
这里和第一题当中出现的快速排序是一样的，只是多了一步而已。测试后发现时间和空间只是优化了一点点（但是运行了一下官方给出的代码，发现没相差多少）

具体代码如下：

class Solution {
public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        Quick_Sort(input,0,input.size()-1);  //调用快速排序函数
        vector<int> res;
        for(int i=0;i<k;i++){
            res.push_back(input[i]);
        }
        return res;
    }
    
    void Quick_Sort(vector<int>& arr, int begin, int end){
    if(begin > end)
        return;
    int tmp = arr[begin];                //默认从第一个数开始比较
    int i = begin;                       //首位置的哨兵
    int j = end;			             //尾位置的哨兵
    while(i != j){
        while(arr[j] >= tmp && j > i){   //满足这个条件，尾哨兵向前移动
            j--;
            }                            //不满足循环说明此时arr[j] < tmp或者j=i
        while(arr[i] <= tmp && j > i){  //满足这个条件，首哨兵向后移动
            i++;
            }                           //不满足循环说明此时arr[i] > tmp或者j=i
        if(j > i){                      //说明此时j!=i，而是arr[i] > tmp、arr[j] < tmp,那么交换两者位置的值，
            int t = arr[i];
            arr[i] = arr[j];
            arr[j] = t;
        }
    }
    //第一轮“探测"结束后，哨兵i、j重合了，这时候该重合点拆分成两个序列，继续递归
    arr[begin] = arr[i];
    arr[i] = tmp;
    Quick_Sort(arr, begin, i-1);
    Quick_Sort(arr, i+1, end);
    }
};

解法3：（大根堆—有兴趣的读者可自行搜索，笔者对这方面的知识点不怎么清楚）

第四题: 单链表的排序

在这里插入图片描述
解题思路：

先将无序链表中的数据依次存放在一个vector数组当中，然后对vector数组进行排序，排完序后依次将数据赋给链表头，最后返回链表头（借助临时链表）
具体代码如下：

class Solution {
public:
    ListNode* sortInList(ListNode* head) {
        vector<int> res;
        ListNode* pres=head;  //创建临时链表，用于保存排序之后的数组
        while(pres){
            res.push_back(pres->val);
            pres=pres->next;
        }
        pres=head;  //记得将链表的指针重新指向链表头
        sort(res.begin(),res.end());  //进行排序
        for(int i=0;i<res.size();i++){
            pres->val=res[i];
            pres=pres->next;
        }
        return head;   //返回真正的链表头
    }
};

时间复杂度： O(nlog2n)O(nlog_2n)O(nlog2​n)，sort函数的复杂度
空间复杂度： O(n)O(n)O(n)，存储链表元素值的辅助数组长度n

第五题：最大数

在这里插入图片描述
解题思路：

  • 定义一个字符数组，通过for循环将数字转换成字符
  • 对字符数组进行排序
  • 设置排序规则
  • 输出字符数组

具体代码如下：

class Solution {
public:
    static bool cmp(string a,string b){
    	return a+b>b+a;
    }
    string solve(vector<int>& nums) {
        vector<string> temp;
        for(int i = 0;i < nums.size();i++){
        	temp.push_back(to_string(nums[i]));
        }
        sort(temp.begin(),temp.end(),cmp);  //对字符数组进行排序，cmp为排序规则
        if(temp[0]=="0"){
        	return "0";
        }
        string res;
        for(int i=0;i<temp.size();i++){
        	res+=temp[i];
        }
        return res;
    }
};

第六题：调整数组顺序使奇数位于偶数前面(二)

在这里插入图片描述
解法一：（不满足空间复杂度）
将奇数和偶数分别提取出来，最后再拼到一起。
具体代码如下：

class Solution {
public:
    vector<int> reOrderArrayTwo(vector<int>& array) {
        vector<int> res1,res2,res;
        for(int i=0;i<array.size();i++){
            if(array[i]%2==1){    //说明是奇数
                res1.push_back(array[i]);
            }else{
                res2.push_back(array[i]);
            }    
        }
        for(int i=0;i<res1.size();i++){
            res.push_back(res1[i]);
        }
        for(int i=0;i<res2.size();i++){
            res.push_back(res2[i]);
        }
        return res;
    }
};

解法二：（双指针）思路很重要，没想到用什么知识点去解决就很伤

解题思路：

  • 双指针，从数组两头向中间靠近。左边的为奇数指针，右边的为偶数指针。
  • 左边指针在没有遇到偶数时，就向右移动，遇到偶数立即停止；右边指针再没有遇到奇数时，向左边移动，遇到奇数时，进行奇偶指针元素交换。交换之后切换到奇数指针工作。
  • 这个方法只遍历一遍数组，时间o(n),空间o(1)。

具体代码如下：

class Solution {
public:
    vector<int> reOrderArrayTwo(vector<int>& array) {
        if(array.size()<=1){
            return array;
        }
        int i=0,j=array.size()-1;  //指向vector中的元素的指针，其实就相当于下标
        while(i<j){
            if(array[i]%2==1){
                i++;
            }
            if(array[j]%2==0){
                j--;
            }
            if(array[i]%2==0&&array[j]%2==1){  //下面也可以直接用swap(array[i], array[j]);
                int temp;
                temp=array[j];
                array[j]=array[i];
                array[i]=temp;
                i++;
                j--;
            }
        }
        return array;
    }
};

第七题：两个数组的交集

在这里插入图片描述
解题思路：

  • 首先将其中一个数组进行排序
  • 然后将排序后的元素逐个插入到临时vector数组中，插入的时候还要查看与相邻元素的值是否相等，相等的话就不插入了。
  • 这样得到的临时vector数组就是排序好的无重复数字的数组，然后逐个与另一个数组进行比较，如果是相等的，那么将这个数取出来。

具体代码如下：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        vector<int> res,nums3;  //res为保存结果的数组,nums3为临时排序数组
        sort(nums1.begin(),nums1.end());
        for(int i=0;i<nums1.size();i++){
            nums3.push_back(nums1[i]);
            if(nums1[i]==nums1[i+1]){
                nums3.pop_back();
            }
        }
        for(int i=0;i<nums3.size();i++){
            for(int j=0;j<nums2.size();j++){
                if(nums3[i]==nums2[j]){
                    res.push_back(nums3[i]);
                    break;
                }
            }
        }
        return res;
        
    }
};

第八题：矩阵第k小

在这里插入图片描述
解题思路：

将矩阵中的全部数字都取出来再排序，然后输出第k大的数

具体代码如下：

class Solution {
public:
    int KthinMatrix(vector<vector<int> >& matrix, int k) {
    int n = matrix.size();   //获取方形矩阵行的大小
    vector<int> nums(n*n);   //定义一个一维数组用于保存矩阵中的所有数据
    int index = 0;
    for(int i = 0; i < n; i++){
        for(int j = 0; j < n; j++){
           nums[index++] = matrix[i][j];
        }
    }
    sort(nums.begin(), nums.end());  //对一维数组进行排序
    return nums[k - 1];    
    }
};

第九题：数据流中的中位数

在这里插入图片描述
这个题目要多读几遍，不然都不清楚要做什么（因为代码的主框架有点不一样）。
答题代码模板如下：

class Solution {
public:
    void Insert(int num) {
        
    }

    double GetMedian() { 
    
    }

};

题目大意：
设计一个类，它有两个方法，Insert(num)可以插入一个数num，GetMedian()返回所有插入的数中的中位数（若一共插入了偶数个，则取中间两个数的平均值；若一共插入了奇数个，则取中间一个即可）

具体代码如下：

class Solution {
public:
    vector<int> res;
    void Insert(int num) {
        res.push_back(num);
    }

    double GetMedian() { 
        sort(res.begin(),res.end());
        if(res.size()%2==0){
            return (res[res.size()/2-1]+res[res.size()/2])/2.00;
        }else{
            return res[res.size()/2];   // 为奇数则返回中间的数
        }
    }

};

第十题：栈和排序

在这里插入图片描述
题目要求：

  • 给你一个 1 到 n 的排列和一个栈，并按照排列顺序入栈
  • 在不打乱入栈顺序的情况下，仅利用入栈和出栈两种操作，输出字典序最大的出栈序列

补充：（字典序）
字典序是基于字母顺序排列的单词按字母顺序排列的方法。
英文中的 字母表（Alphabet） 按照如下的顺序排列：

ABCDEFG HIJKLMN OPQRST UVWXYZ
abcdefg hijklmn opqrst uvwxyz

本题要求的最大字典序，其实是倒过来的（从后往前找,后面的总是小于等于前面的元素才能保证子序列按字典序排列）

解题思路：
这道题文字描述有点复杂，感兴趣的小伙伴可以点击下面这个链接，有视频讲解。当然了，如果能看懂下面编写的代码，那是最好不过的了。

具体代码如下：

class Solution {
public:
    /**
     * 栈排序
     * @param a int整型一维数组 描述入栈顺序
     * @param aLen int a数组长度
     * @return int整型vector
     */
    vector<int> solve(int* a, int aLen) {
        stack<int>s;//定义一个栈用来存储数据
        int n = aLen;
        vector<int>res;//用来返回结果
        vector<bool> vis(aLen,0);//用来标记哪个数字出现过
        for(int i = 0;i<aLen;i ++){//遍历数组
            s.push(a[i]);//压入栈
            vis[a[i]] = 1;//压入一个数就把对应的数字标记为1
            while(n && vis[n]) n--;//检测现有栈中最大的几个数是否都出现了（出现了就将当前未出现的最大的数n减去1），
            while(!s.empty() && n <= s.top()){  //如果先前比n大的数没有弹出（因为n改变了），那么先将先前的数弹出
                //然后将栈中>=n的元素出栈
                res.push_back(s.top());
                s.pop();
            }
        }
        //如果栈没为空就按照栈中原样直接出栈
        while(!s.empty()){
            int temp = s.top();
            res.push_back(temp);
            s.pop();
        }
        return res;
    }
};

注： 以上题目都是在牛客网的剑指offer题库中刷的，有自己做的，也有不会做看别人精华解题思路，然后总结的。如果侵犯了您的权益，请私聊我。
最后，觉得本文内容对你有所帮助的话，感谢您能点赞收藏，在我的剑指offer专栏还有相关的算法刷题文章，等待您的阅读！

导航链接：必刷算法题—二分查找（C++）
导航链接：必刷算法题—哈希篇（C++）
导航链接：剑指—动态规划篇（C++）
导航链接：剑指—树篇(C++)
导航链接：剑指—链表篇（C++）
导航链接：剑指—队列&栈篇（C++）

枫恋蝶
关注
专栏目录
C++测试题：两种排序方法
qq_43509349的博客
05-31 354
标题：两种排序方法 | 时间限制：1秒 | 内存限制：32768K | 语言限制： 不限 【两种排序方法】考拉有n个字符串字符串，任意两个字符串长度都是不同的。考拉最近学习到有两种字符串的排序方法： 1.根据字符串的字典序排序。例如： “car” < “carriage” < “cats” < "doggies < “koala” 2.根据字符串的长度排序。例如： “car...
编程入门必作题
liang851128的专栏
05-16 6607
1.  给定等式  A B C D E     其中每个字母代表一个数字，且不同数字对应不                    D F G     同字母。编程求出这些数字并且打出这个数字的             +      D F G     算术计算竖式。             ───────                X Y Z D E   2. Ａ、Ｂ、Ｃ、Ｄ、
【排序算法】插入排序(C++实现)
热门推荐
JimYe的专栏
03-10 5万+
插入排序的基本思想是每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子文件中的适当位置，直到全部记录插入完成为止。常见的插入排序有插入排序（Insertion Sort），希尔排序（Shell Sort），二叉查找树排序（Tree Sort），图书馆排序（Library Sort），Patience排序（Patience Sort）。下面介绍前两种： （一）直接插入排序 最差时间复
【C++】数据结构＋冒泡排序综合练习
最新发布
weixin_60546365的博客
07-09 323
【代码】【C++】数据结构＋冒泡排序综合练习。
c++排序问题
hi_baymax的博客
08-25 3937
http://www.cnblogs.com/eniac12/p/5329396.html这个网址里的动画特别形象，记录一下 1、直接排序法--稳定排序 对于第K个元素，将该元素的值存储在零时变量中，比较第前一个元素与该元素的大小，如果大于该元素就将前一个元素往后移动一步； 比较前面第二个元素与该元素的大小，如果大于该元素就将前第二个元素往后移动一步； 重复上述过程直到找到小于等于原来第K...
牛客网排序题（C++）
weixin_46741734的博客
08-29 236
i++)这里的里面的if3次判断，刚开始一直不懂为什么是这样，后来理解了过后发现真的是巧用，会节省好多代码，此外关于归并排序的应用自己还要再理解理解，稍微懂其中的一点原理，但是还是不能自己手写出来一个归并排序，归并融合递归解这道题对于初次学这种题的自己还是有些难度的，但是也体会到了写代码有的时候不知道为啥，但是真的可以背下来经典的代码，相信随着时间的流逝自己会理解的~如果中间值小的话，那么就修改right为中间值，进行靠拢！...
蓝桥杯c++-蓝桥杯竞赛练习之算法提高题冒泡排序法.zip
04-13
冒泡排序法是一种基础但实用的排序算法，尤其在C++编程中，它常常作为学习算法的起点。本文将深入探讨冒泡排序的基本原理、C++实现方式以及在蓝桥杯竞赛中的应用。 **冒泡排序简介** 冒泡排序的核心思想是通过重复...
1.10编程基础之简单排序(10题)--题目 有链接.pdf
06-11
在编程竞赛中，如NOIP（全国青少年信息学奥林匹克竞赛）等，排序题目常常是考察选手算法能力和编程技巧的重要题目。 7. C++语言编程基础： C++是一种支持过程化编程、面向对象编程和泛型编程的高级编程语言。它是...
算法设计与分析-排序算法性能分析-要求pdf 报告文档 c++源代码 preppt
06-18
选择排序 冒泡排序 插入排序 合并排序 快速排序算法原理及代码实现 不同排序算法时间效率的经验分析方法 验证理论分析与经验分析的一致性 void Init_Random();//数组随机数初始化函数声明 void Show_Array();//展示...
蓝桥杯c++-蓝桥杯竞赛练习之算法提高题多项式输出.zip
04-12
【标题】"蓝桥杯c++-蓝桥杯竞赛练习之算法提高题多项式输出"主要涉及的是在C++编程语言环境下，针对蓝桥杯竞赛中的算法问题进行的专项训练，特别是关于多项式输出的技巧和方法。在编程竞赛中，理解和高效实现多项式...
蓝桥杯c++-蓝桥杯竞赛练习之算法提高题交换Easy.zip
04-12
【标题解析】：“蓝桥杯c++-蓝桥杯竞赛练习之算法提高题交换Easy.zip”这个标题表明了这是与“蓝桥杯”竞赛相关的C++编程资源，特别是针对算法提高部分的练习题目。"交换Easy"可能意味着这是一个相对简单的交换类...
C++编程题目------ 排序
would20110710的博客
08-03 694
输入n个数，将n个数从小到大输出。第1行为一个正整数n。输入n个数，将n个数从小到大输出。第1行为一个正整数n。共1行，表示排序后的n个数。共1行，表示排序后的n个数。
【C++】各种排序涉及到的选择小题合集（每日小细节009）
weixin_71138261的博客
12-25 600
【C++】各种排序涉及到的选择小题合集（每日小细节009）
C++算法：基础排序练习
weixin_44416114的博客
04-01 2441
选择排序 选择排序，对输入的n个数字进行升序排列。 输入 第一行一个数n, 第二行n个待排序的数字ai。 输出 一行升序排列，n个用空格隔开的数字。 输入样例 4 4 3 2 1 输出样例 1 2 3 4 说明/提示 对100%数据，n≤1000,ai≤1000000。 题解 完整代码及注释说明 #include <iostream> using namespace std; // 定义数组 int arr[] = {}; // 交换函数 void swap_(int &a, int
8 求第几天
HurryBen的博客
10-15 455
8求第几天 作者:Turbo时间限制:1S章节:循环 问题描述 : 按年、月、日的顺序读入一个日期，输出该日期是这一年中的第几天。 输入说明 : 输入数据为三个正整数y 、m、d，分别表示年、月、日，整数之间以空格分隔，在行首和行尾没有多余的空格。 输出说明 : 输出一个整数，表示输入的日期是这一年中的第几天，在行首和行尾没有多余的空格。 输入范例 : 2000 12 3...
C++算法入门练习——简单排序
u011708235的博客
10-12 121
简单排序中有三种：①冒泡排序 ②选择排序 ③插入排序。
c++排序题【1】
m0_68339197的博客
05-20 277
输出：-2 -1 1 1。
C/C++ 排序专题
Pinkray_07的博客
09-08 1132
排序专题 3238.字串非重复字符数排序 对 个由大写字母组成的长度为 的字符串，按字符串中不同字符个数从多到少的顺序进行排序。不同字符个数相同的字符串按字符串的字典序排序。 例如：ABCCBA 和 CDFE 按照 CDFE ，ABCCBA 顺序排序，因为 ABCCBA 的不同字符个数是 个，CDFE是 个。ABCCBAX 和 CDFE 按照 ABCCBAX, CDFE 顺序排序，因为这两个字符串的不同字符个数都是 个，而 ABCCBAX 的字典序小于 CDFE。 #include <ios
c++十大排序之快速排序（例题+代码+注释+讲解+动态图）
weixin_47067783的博客
02-23 1190
对于新手来说函数虽然简单但如果把所有代码结合到一起对于小白就很难理解了所以就有了今天的文章： 今天是先讲解在练习： 快速排序是冒泡排序的升级版（也可以叫改进版） 下面是简介： 快速排序由C. A. R. Hoare在1962年提出。它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 动态图与讲解：从数列中挑出一个元素，称为 "基准".
C语言实现：Prim-Kruskal-Dijkstra算法与拓扑排序详解
在福建农林大学计算机与信息学院的计算机类课程设计中，学生易向阳在指导教师黄思先的指导下，针对课程设计题目“图的算法实现”进行深入研究。该设计旨在通过C语言实践，提升对数据结构与算法的理解和应用能力，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

枫恋蝶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值