C++数据结构与算法——数组

C++第二阶段——数据结构和算法,之前学过一点点数据结构,当时是基于Python来学习的,现在基于C++查漏补缺,尤其是树的部分。这一部分计划一个月,主要利用代码随想录来学习,刷题使用力扣网站,不定时更新,欢迎关注!

一、数组数理基础

数组是最基础的数据结构,数组是存放在连续内存空间上的相同类型数据的结合,有点像Python中的列表list。数组可以通过索引来获取到对应的数据,值得注意的是,数组的索引是从0开始。正因为数组的内存是连续的,所以在删除元素的时候,只能采用后面的元素覆盖前面元素的方式.

二、二分查找

2.1 二分查找(力扣 704)

二分查找最重要的是判断边界,一个是确定数组的区间,一个是确定right和left更新的规则。同时需要注意的是,二分查找需要在有序的数组中进行,并且数组中无重复元素。
下面通过两种不同方式讲解二分法,其中第一种最为常用。
左闭右闭
首先right设置成nums.size()-1,那么就是左闭右闭区间,为保证区间的合法性,可以设置成left<right,在搜索时,right=middle-1,因为middle值已经判断过了,不是target,同理left=middle+1.

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left =0;
        int right = nums.size()-1; // [left,right]左闭右闭
        while(left<=right){ // 保证区间合法
            int middle = (right+left)/2;
            if(nums[middle]>target){
                // 在左区间搜索
                right = middle-1; //middle值已经判断过了,因此需要减一
            }
            else if(nums[middle]<target){
                // 右区间搜索
                left = middle+1;
            }
            else{
                return middle;
            }
        }
        return -1; // 没找到
    }
};

在这里插入图片描述
左闭右开
right为nums.size(),那么区间为左闭右开,取不到right,为保证区间的合法性,left要<right,更新时,由于right取不到,因此right=middle,实际值是从right-1开始,left的更新原则不变。

class Solution {
public:
        int search(vector<int>& nums, int target) {
        int left =0;
        int right = nums.size(); // [left,right)左闭右开
        while(left<right){ // 保证区间合法
            int middle = (right+left)/2;
            if(nums[middle]>target){
                // 在左区间搜索
                right = middle; //right开区间不包含在内,因此直接赋值为right,真实有效的数是right-1
            }
            else if(nums[middle]<target){
                // 右区间搜索
                left = middle+1;
            }
            else{
                return middle;
            }
        }
        return -1; // 没找到
    }
};

在这里插入图片描述

2.2 搜索插入位置(力扣35)

给定一个排序数组和一个目标值,在数组中找到目标值,并返回其索引。如果目标值不存在于数组中,返回它将会被按顺序插入的位置。
请必须使用时间复杂度为 O(log n) 的算法。
示例 1:
输入: nums = [1,3,5,6], target = 5
输出: 2
示例 2:
输入: nums = [1,3,5,6], target = 2
输出: 1
示例 3:
输入: nums = [1,3,5,6], target = 7
输出: 4
提示:
1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 为 无重复元素 的 升序 排列数组
-104 <= target <= 104

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int left =0;
        int right = nums.size()-1;
        while (left<=right){
            int middle = (left+right)/2;
            if(nums[middle]>target){
                right = middle -1;
            }
            else if(nums[middle]<target){
                left = middle+1;
            }
            else{
                return middle;
            }
        }
    return left; // right+1
    }
};

在这里插入图片描述
没找到返回的为left或者是right+1

2.3 在排序数组中查找元素的第一个和最后一个位置(力扣34)

给定一个按照升序排列的整数数组 nums,和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 target,返回 [-1, -1]。
进阶:你可以设计并实现时间复杂度为 O ( log ⁡ n ) O(\log n) O(logn) 的算法解决此问题吗?
示例 1:
输入:nums = [5,7,7,8,8,10], target = 8
输出:[3,4]
示例 2:
输入:nums = [5,7,7,8,8,10], target = 6
输出:[-1,-1]
示例 3:
输入:nums = [], target = 0
输出:[-1,-1]
#思路

首先是暴力法,两个for循环一个找左边界,一个找右边界,时间复杂度为O(n)

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int flag;
        int begin;
        int end=-1;
        for(int i=0;i<nums.size();i++){
            if (nums[i]==target){
                // 找到第一个
                begin = i;
                break;
            }
            begin =-1;
        }
        for(int i=0;i<nums.size();i++){
            if (nums[i]==target){
                // 找到最后
                end = i;
            }
        }
        return {begin, end};
    }
};

在这里插入图片描述
使用二分查找法找左右边界,时间复杂度可以降到O(log n),注意需要考虑边界信息。

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        // 找左边界
        int first = getFirst(nums,target);
        // 找右边界
        int end = getEnd(nums,target);
        return {first,end};
    }
    int getFirst(vector<int>&nums,int target){
        int left=0;
        int right =nums.size()-1;
        while(left<=right){
            int mid = left+(right-left)/2;
            if(nums[mid]>target){
                right = mid-1;
            }
            else if(nums[mid]<target){
                left = mid+1;
            }
            else{
                // 等于的情况
                // 不应该用线性搜索,应该还是用二分搜索
                if(mid==0||nums[mid-1]!=target){
                    return mid;
                }
                else{
                    right = mid-1;
                }

            }
        }
        return -1;
    }
    int getEnd(vector<int>&nums,int target){
        int left=0;
        int right =nums.size()-1;
        while(left<=right){
            int mid = left+(right-left)/2;
            if(nums[mid]>target){
                right = mid-1;
            }
            else if(nums[mid]<target){
                left = mid+1;
            }
            else{
                // 等于的情况
                // 不应该用线性搜索,应该还是用二分搜索
                if(mid==nums.size()-1||nums[mid+1]!=target){
                    return mid;

                }
                else{
                    left = mid+1;
                }

            }
        }
        return -1;
    }
};

在这里插入图片描述

2.4 x的平方根(力扣69)

第一想法是暴力遍历,如果(ii<=x&&(i+1)(i+1)>x。说明i就是平方根,但是超时了,复杂度O(n),不符合题意

class Solution {
public:
    int mySqrt(int x) {
        if(x==0){
            return 0;
        }
        if(x==1){
            return 1;
        }
        for(int i=0;i<x;i++){
            if(i*i<=x&&(i+1)*(i+1)>x){
                return i;
            }
        }
        return -1;
    }
};

在这里插入图片描述
使用二分查找法,找到就返回midle,没找到就返回right。

class Solution {
public:
    int mySqrt(int x) {
        long left=0;
        long right = x;
        while(left<=right){
            long middle = left+(right-left)/2; // 防止int溢出
            if(middle*middle>x){
                right = middle-1;
            }
            else if(middle*middle<x){
                left = middle+1;
            }
            else{
                return middle;
            }

        }
        return right;
    }
};

在这里插入图片描述

2.5 有效的完全平方数(力扣367)

和2.4大致相同,没什么难度。

class Solution {
public:
    bool isPerfectSquare(int num) {
        long left = 0;
        long right = num;
        while(left<=right){
            long mid = left+(right-left)/2;
            if(mid*mid>num){
                right = mid-1;
            } 
            else if(mid*mid<num){
                left = mid+1;
            }
            else{
                return true;
            }
        }
        return false;
    }
};

三、移除元素

给你一个数组 nums 和一个值 val,你需要 原地 移除所有数值等于 val 的元素,并返回移除后数组的新长度。
不要使用额外的数组空间,你必须仅使用 O(1) 额外空间并原地修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。 你不需要考虑数组中超出新长度后面的元素。
示例 2: 给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。
你不需要考虑数组中超出新长度后面的元素。

利用快慢双指针,慢指针占位置,快指针找符合条件的元素。

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        // 利用快慢指针进行删除
        // 1. 判断是否只有零个或一个元素,防止索引超出数组长度
        if(nums.size()==1){
            if(nums[0]==val){
                return 0;
            }
            else{
                return 1;
            }
        }
        if (nums.size()==0){
            return 0;
        }

        int slow =0;
        for(int fast=0;fast<nums.size();fast++){
            if(nums[fast]!=val){
                nums[slow] = nums[fast];
                slow++;
            }
        }
        return slow;
    }
};

在这里插入图片描述

3.1 删除有序数组中的重复项(力扣26)

给你一个 非严格递增排列 的数组 nums ,请你 原地 删除重复出现的元素,使每个元素 只出现一次 ,返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。
考虑 nums 的唯一元素的数量为 k ,你需要做以下事情确保你的题解可以被通过:
更改数组 nums ,使 nums 的前 k 个元素包含唯一元素,并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。
返回 k 。
示例 1:
输入:nums = [1,1,2]
输出:2, nums = [1,2,_]
解释:函数应该返回新的长度 2 ,并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。
示例 2:
输入:nums = [0,0,1,1,1,2,2,3,3,4]
输出:5, nums = [0,1,2,3,4]
解释:函数应该返回新的长度 5 , 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。
提示:
1 <= nums.length <= 3 * 104
-104 <= nums[i] <= 104
nums 已按 非严格递增 排列

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        if(nums.size()==1){
            return 1;
        }
        int slow = 1;
        for (int fast =0;fast<nums.size();fast++){
            if(nums[fast]!=nums[slow-1]){  // 不等于上一个
                nums[slow]=nums[fast];
                slow++;
            }
        }
        return slow;
    }
};

在这里插入图片描述

3.2 移动零(力扣283)

给定一个数组 nums,编写一个函数将所有 0 移动到数组的末尾,同时保持非零元素的相对顺序。
请注意 ,必须在不复制数组的情况下原地对数组进行操作。
示例 1:
输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]
示例 2:
输入: nums = [0]
输出: [0]
提示:
1 <= nums.length <= 104
-231 <= nums[i] <= 231 - 1

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int slow =0;
        if(nums.size()==1){
            return;
        }
        for (int fast=0;fast<nums.size();fast++){
            if(nums[fast]!=0){
                swap(nums[slow],nums[fast]);
                slow++;
            }
        }
    }
};

在这里插入图片描述

3.3 比较含退格的字符串(力扣844)

给定 s 和 t 两个字符串,当它们分别被输入到空白的文本编辑器后,如果两者相等,返回 true 。# 代表退格字符。
注意:如果对空文本输入退格字符,文本继续为空。
示例 1:
输入:s = “ab#c”, t = “ad#c”
输出:true
解释:s 和 t 都会变成 “ac”。
示例 2:
输入:s = “ab##”, t = “c#d#”
输出:true
解释:s 和 t 都会变成 “”。
示例 3:
输入:s = “a#c”, t = “b”
输出:false
解释:s 会变成 “c”,但 t 仍然是 “b”。
提示:
1 <= s.length, t.length <= 200
s 和 t 只含有小写字母以及字符 ‘#’

运用栈的思想,遇到#就弹出栈顶的元素

class Solution {
public:
    bool backspaceCompare(string s, string t) {
        string s_str = getStr(s);
        string t_str = getStr(t);
        if(s_str==t_str){
            return true;
        }
        return false;
    }
    string getStr(string str){
        // 用栈的思想
        string result;
        for(int i=0;i<str.length();i++){
            if(str[i]=='#'){
                if (result.length()==0){
                }
                else{
                    result.pop_back();
                }
            }
            else{
                result.push_back(str[i]);
            }
        }
        return result;
    }
};

在这里插入图片描述
使用双指针

class Solution {
public:
    bool backspaceCompare(string s, string t) {
        int s_j = s.length()-1;
        int t_j = t.length()-1;
        int skip_s = 0;
        int skip_t =0;
        while(s_j>=0||t_j>=0){
            // 找到一个确定的字母
            while(s_j>=0){
                if(s[s_j]=='#'){
                    skip_s ++;
                    s_j--;
                }
                else if(skip_s>0){
                    skip_s --;
                    s_j --;
                }
                else{
                    break; // 找到确认的字母
                }
            }
            while(t_j>=0){
                if(t[t_j]=='#'){
                    skip_t ++;
                    t_j--;
                }
                else if(skip_t>0){
                    skip_t --;
                    t_j --;
                }
                else{
                    break; // 找到确认的字母
                }
            }
            if(t_j>=0&&s_j>=0){
                if(s[s_j]!=t[t_j]){
                    return false;
                }
            }
            else{
                if(s_j>=0||t_j>=0){
                    return false;
                }

            }
            s_j --;
            t_j --;
        }
        return true;
    }
};

在这里插入图片描述

3.4 有序数组的平方(力扣977)

给你一个按 非递减顺序 排序的整数数组 nums,返回 每个数字的平方 组成的新数组,要求也按 非递减顺序 排序。
示例 1:
输入:nums = [-4,-1,0,3,10]
输出:[0,1,9,16,100]
解释:平方后,数组变为 [16,1,0,9,100],排序后,数组变为 [0,1,9,16,100]
示例 2:
输入:nums = [-7,-3,2,3,11]
输出:[4,9,9,49,121]

最大值只可能在最左侧或者最右侧取到,因此使用双指针,比较大小即可。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        // 双指针left right
        vector<int> v;
        // 最大的只可能是最左端或者是最右端
        int left = 0;
        int right = nums.size()-1;
        while(left<=right){
            if(nums[left]*nums[left]>nums[right]*nums[right]){
                v.push_back(nums[left]*nums[left]);
                left++;
            }
            else{
                v.push_back(nums[right]*nums[right]);
                right--;
            }
        }
        reverse(v.begin(),v.end());
        return v;
    }
};

在这里插入图片描述

四、长度最小的子数组(力扣209)

给定一个含有 n 个正整数的数组和一个正整数 s ,找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组,并返回其长度。如果不存在符合条件的子数组,返回 0。
示例:
输入:s = 7, nums = [2,3,1,2,4,3]
输出:2
解释:子数组 [4,3] 是该条件下的长度最小的子数组。
提示:
1 <= target <= 10^9
1 <= nums.length <= 10^5
1 <= nums[i] <= 10^5

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        // 双指针 移动窗口
        int begin=0; // 起始指针
        int sum =0; // 累加值
        int result =INT32_MAX; // 最终返回的最小窗口大小
        for(int end=0;end<nums.size();end++){
            sum+=nums[end];
            while(sum>=target){
                // 记录当前的窗口大小
                int Length = (end-begin+1);
                result = min(result,Length); // 记录最小值
                sum -= nums[begin]; // 减值,移动窗口起始值
                begin++;
            }
        }
        if(result==INT32_MAX){
            return 0; // 说明所有值加一起都没有达到target
        }
        return result;
    }
};

在这里插入图片描述

4.1 水果成篮(力扣904)

你正在探访一家农场,农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示,其中 fruits[i] 是第 i 棵树上的水果 种类 。你想要尽可能多地收集水果。然而,农场的主人设定了一些严格的规矩,你必须按照要求采摘水果:
你只有 两个 篮子,并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
你可以选择任意一棵树开始采摘,你必须从 每棵 树(包括开始采摘的树)上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次,你将会向右移动到下一棵树,并继续采摘。
一旦你走到某棵树前,但水果不符合篮子的水果类型,那么就必须停止采摘。
给你一个整数数组 fruits ,返回你可以收集的水果的 最大 数目。

这题看要哈希表,先放在这里,等学到哈希表再写。。。

4.2 最小覆盖子串(力扣76)

给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串,则返回空字符串 “” 。
注意:
对于 t 中重复字符,我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
如果 s 中存在这样的子串,我们保证它是唯一的答案。
示例 1:
输入:s = “ADOBECODEBANC”, t = “ABC”
输出:“BANC”
解释:最小覆盖子串 “BANC” 包含来自字符串 t 的 ‘A’、‘B’ 和 ‘C’。
示例 2:
输入:s = “a”, t = “a”
输出:“a”
解释:整个字符串 s 是最小覆盖子串。
示例 3:
输入: s = “a”, t = “aa”
输出: “”
解释: t 中两个字符 ‘a’ 均应包含在 s 的子串中,
因此没有符合条件的子字符串,返回空字符串。

这题有点难了。也先放着,后面学一遍之后再写。。。

五、螺旋矩阵 II(力扣59)

给你一个正整数 n ,生成一个包含 1 到 n2 所有元素,且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。
在这里插入图片描述

主要是边界的判断,四条边用四个for循环来写。

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        // i,j 表示坐标
        int loop = n/2;
        int count = 1;
        int startx =0;
        int starty = 0;
        int step =1;
        int i=startx;
        int j=starty;
        vector<vector<int>> nums(n, vector<int>(n, 0));
        // 到零的时候退出
        while(loop--){
            // 上面这个边
            i=startx;
            j=starty;
            for(;j<n-step;j++){
                nums[i][j] = count++;
            }
            // 右边
            for(;i<n-step;i++){
                nums[i][j] = count++;
            }
            // 下面
            for(;j>starty;j--){
                nums[i][j] = count++;
            }
            for(;i>startx;i--){
                nums[i][j] = count++;
            }
            step++;
            startx++;
            starty++;
        }
        if(n%2==1){
            nums[n/2][n/2] = count;
        }
        return nums;
    }
};

在这里插入图片描述

5.1 螺旋矩阵(力扣54)

已解答
中等
相关标签
相关企业
提示
给你一个 m 行 n 列的矩阵 matrix ,请按照 顺时针螺旋顺序 ,返回矩阵中的所有元素。
在这里插入图片描述

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        // 获取矩阵的行列
        int m = matrix.size(); // 行数
        int n = matrix[0].size(); // 列数
        // 结果列表
        vector<int> nums;
        // 定义上下左右边界
        int up=0;int down =m-1;int left =0;int right=n-1;
        while(true){
            // 上面一层存到数组中
            for(int i=left;i<=right;i++){
                nums.push_back(matrix[up][i]);
            }
            // 上边界下移
            if(++up>down){break;}
            //右边
            for(int i=up;i<=down;i++){
                nums.push_back(matrix[i][right]);
            }
            if(--right<left){break;}

            // 下面
            for(int i=right;left<=i;i--){
                nums.push_back(matrix[down][i]);
            }
            if(--down<up){break;}

            //左边
            for(int i=down;up<=i;i--){
                nums.push_back(matrix[i][left]);
            }
            if(++left>right){break;}
        }
        return nums;
    }
};

在这里插入图片描述

5.2 螺旋遍历二维数组(力扣LCR 146)

给定一个二维数组 array,请返回「螺旋遍历」该数组的结果。
螺旋遍历:从左上角开始,按照 向右、向下、向左、向上 的顺序 依次 提取元素,然后再进入内部一层重复相同的步骤,直到提取完所有元素。
示例 1:
输入:array = [[1,2,3],[8,9,4],[7,6,5]]
输出:[1,2,3,4,5,6,7,8,9]
示例 2:
输入:array = [[1,2,3,4],[12,13,14,5],[11,16,15,6],[10,9,8,7]]
输出:[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]
限制:
0 <= array.length <= 100
0 <= array[i].length <= 100

class Solution {
public:
    vector<int> spiralArray(vector<vector<int>>& array) {
        if(array.size()==0){return {};}
        // 首先获取array的行列
        int m = array.size(); // 行数
        int n = array[0].size(); // 列数
        vector<int> nums;
        // 定义上下左右边界
        int up=0;int down=m-1;int left=0;int right =n-1;
        while(true){
            // 上面
            for(int i=left;i<=right;i++){
                nums.push_back(array[up][i]);
            }
            // 上边界下移
            if(++up>down){break;}
            // 右边
            for(int i=up;i<=down;i++){
                nums.push_back(array[i][right]);
            }
            if(--right<left){break;}
            // 下面
            for(int i=right;i>=left;i--){
                nums.push_back(array[down][i]);
            }
            if(--down<up){break;}
            // 左边
            for(int i=down;i>=up;i--){
                nums.push_back(array[i][left]);
            }
            if(++left>right){break;}
        }
        return nums;
    }
};

在这里插入图片描述

  • 15
    点赞
  • 25
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

打赏作者

爱睡觉的咋

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

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

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

打赏作者

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

抵扣说明:

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

余额充值