考研算法题对应代码

剑指 Offer 40. 最小的k个数

桶排序代码

class Solution {
public:
    int cnt[int(1e4 + 10)];
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        vector<int> ans;
        for(int i = 0;i<arr.size();i++){
            cnt[arr[i]]++;
        }
        for(int i = 0;i<=10000;i++){
            while(k && cnt[i]--){
                ans.push_back(i);
                k--;
            }
            if(k == 0) break;
        }
        return ans;
    }
};

归并排序

#include <iostream>
using namespace std;

const int maxn = 1e5 + 10;
int N;
int arr[maxn],tmp[maxn];
void solve(int l,int r,int arr[]){
    if(l == r) return ;
    int mid = (l + r)/2;
    solve(l,mid,arr);
    solve(mid+1,r,arr);
    int idx1 = l,idx2 = mid+1;
    for(int i = l;i<=r;i++){
        if(idx1 <= mid && idx2 <= r){
            if(arr[idx1] < arr[idx2]) tmp[i] = arr[idx1++];
            else tmp[i] = arr[idx2++];
        }else if(idx1 <= mid){
            tmp[i] = arr[idx1++];
        }else{
            tmp[i] = arr[idx2++];
        }
    }
    for(int i = l;i<=r;i++) arr[i] = tmp[i];
}
int main(){
    cin>>N;
    for(int i = 1;i<=N;i++) cin>>arr[i];
    solve(1,N,arr);
    for(int i = 1;i<=N;i++) cout<<arr[i]<<" ";cout<<'\n';

    return 0;
}

快速排序

#include <iostream>
#include <stdio.h>
using namespace std;

const int maxn = 1e6 + 10;
int N;
int arr[maxn];
void swap(int &a,int &b){
    int tmp = a;
    a = b;
    b = tmp;
}
void quick_sort(int left,int right,int arr[]){
    if(left >= right) return ;
    int l = left,r = right,val = arr[left];
    while(l < r){
        while(l<r && val <= arr[r]) --r;
        arr[l] = arr[r];
        while(l<r && arr[l] <= val) ++l;
        arr[r] = arr[l];
    }
    arr[l] = val;
    quick_sort(left,l-1,arr);
    quick_sort(l+1,right,arr);
}
int main(){
    cin>>N;
    for(int i = 1;i<=N;i++) cin>>arr[i];
    quick_sort(1,N,arr);
    for(int i = 1;i<=N;i++) cout<<arr[i]<<" ";cout<<'\n';
    
    return 0;
}

144. 二叉树的前序遍历

class Solution {
public:
    vector<int> ans;
    void dfs(TreeNode *cur){
        if(cur == NULL) return ;
        ans.push_back(cur->val);
        dfs(cur->left);
        dfs(cur->right);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        dfs(root);
        return ans;
    }
};

145. 二叉树的后序遍历

class Solution {
public:
    vector<int> ans;
    void dfs(TreeNode *cur){
        if(cur == NULL) return ;
        dfs(cur->left);
        dfs(cur->right);
        ans.push_back(cur->val);
    }
    vector<int> postorderTraversal(TreeNode* root) {
        dfs(root);
        return ans;
    }
};

226. 翻转二叉树

class Solution {
public:
    void dfs(TreeNode *cur){
        if(cur == NULL) return ;
        swap(cur->left,cur->right);
        dfs(cur->left);
        dfs(cur->right);
    }
    TreeNode* invertTree(TreeNode* root) {
        dfs(root);
        return root;
    }
};

404. 左叶子之和

class Solution {
public:
    int dfs(TreeNode *cur,int tag){
        if(cur == NULL) return 0;
        if(!cur->left && !cur->right) {
            if(tag == 0) return cur->val;
            else return 0;
        }else{
            return dfs(cur->left,0) + dfs(cur->right,1);
        }

    } 
    int sumOfLeftLeaves(TreeNode* root) {
        return dfs(root,1);
    }
};

105. 从前序与中序遍历序列构造二叉树

class Solution {
public:
    vector<int> pre,in;
    int idxin[int(6e3 + 10)];
    TreeNode * dfs(int l1,int r1,int l2,int r2){
        if(l1 > r1 || l2 > r2) return NULL;
        TreeNode *cur = new TreeNode(pre[l1]);
        if(l1 == r1) return cur;
        else{
            int rt = pre[l1] + 3000;
            int posmid = idxin[rt],len = posmid - l2;
            cur->left = dfs(l1 + 1,l1 + len,l2,posmid-1);
            cur->right = dfs(l1 + len + 1,r1,posmid+1,r2);
            return cur;
        }
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        pre = preorder,in = inorder;
        for(int i = 0;i<in.size();i++){
            idxin[in[i] + 3000] = i;
        }
        return dfs(0,pre.size()-1,0,in.size()-1);
    }
};

106. 从中序与后序遍历序列构造二叉树

const int maxn = 6e3 + 10;
class Solution {
public:
    int ind[maxn];
    vector<int> in,post;
    TreeNode *dfs(int l1,int r1,int l2,int r2){
        if(l1 > r1 || l2 > r2) return NULL;
        int val = post[r2];
        TreeNode *rt = new TreeNode(val);
        if(l1 == r1) return rt;
        else{
            int mid = ind[val + 3000];
            int len = mid - l1;
            rt->left = dfs(l1,mid-1,l2,l2 + len - 1);
            rt->right = dfs(mid+1,r1,l2 + len,r2-1);
            return rt;
        }
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        in = inorder,post = postorder;
        for(int i = 0;i<in.size();i++){
            ind[in[i] + 3000] = i;
        }
        return dfs(0,in.size()-1,0,post.size()-1);
    }
};

108. 将有序数组转换为二叉搜索树

class Solution {
public:
    vector<int> arr;
    TreeNode *dfs(int l,int r){
        if(l > r) return NULL;
        int mid = (l + r)>>1;
        TreeNode *rt = new TreeNode(arr[mid]);
        rt->left = dfs(l,mid-1);
        rt->right = dfs(mid+1,r);
        return rt;
    }
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        arr = nums;
        return dfs(0,arr.size()-1);
    }
};

637. 二叉树的层平均值

class Solution {
public:
    vector<double> ans;
    queue<TreeNode *> q1,q2;
    vector<double> averageOfLevels(TreeNode* root) {
        if(root == NULL) return ans;
        q1.push(root);
        while(q1.size()){
            double sum = 0,cnt = q1.size();
            while(q1.size()){
                TreeNode *cur = q1.front();q1.pop();
                sum += cur->val;
                if(cur->left) q2.push(cur->left);
                if(cur->right) q2.push(cur->right);
            }
            ans.push_back(sum / cnt);
            swap(q1,q2);
        }
        return ans;
    }
};

515. 在每个树行中找最大值

class Solution {
public:
    vector<int> ans;
    queue<TreeNode *> q1,q2;
    vector<int> largestValues(TreeNode* root) {
        if(root == NULL) return ans;
        q1.push(root);
        while(q1.size()){
            int mx = q1.front()->val;
            while(q1.size()){
                TreeNode *cur = q1.front();q1.pop();
                mx = max(mx,cur->val);
                if(cur->left) q2.push(cur->left);
                if(cur->right) q2.push(cur->right);
            }
            ans.push_back(mx);
            swap(q1,q2);
        }
        return ans;
    }
};

面试题 16.17. 连续数列

class Solution {
public:
    vector<int> arr;
    struct node{
        int sum,pre,suf,ans;
    };
    node solve(int l,int r){
        if(l == r) {
            return {arr[l],arr[l],arr[r],arr[l]};
        }
        int mid = (l + r)>>1;
        node ansl = solve(l,mid);
        node ansr = solve(mid+1,r);
        return {ansl.sum + ansr.sum,max(ansl.pre,ansl.sum + ansr.pre),max(ansr.suf,ansr.sum + ansl.suf),max({ansl.ans,ansr.ans,ansl.suf + ansr.pre})};
        
    }
    int maxSubArray(vector<int>& nums) {
        arr = nums;
        node re = solve(0,arr.size()-1);
        return re.ans;
    }
};

62. 不同路径

const int maxn = 105;
class Solution {
public:
    int dp[maxn][maxn];
    int uniquePaths(int m, int n) {
        memset(dp,0,sizeof dp);
        dp[1][1] = 1;
        for(int i = 1;i<=m;i++){
            for(int j = 1;j<=n;j++){
                if(i == 1 && j == 1) continue;
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }
        return dp[m][n];
    }
};

63. 不同路径 II

const int maxn = 105;
class Solution {
public:
    int dp[maxn][maxn];
    int N,M;
    int uniquePathsWithObstacles(vector<vector<int>>& A) {
        memset(dp,0,sizeof dp);
        if(A[0][0] == 1) return 0;
        N = A.size(),M = A[0].size();
        dp[1][1] = 1;
        for(int i = 1;i<=N;i++){
            for(int j = 1;j<=M;j++){
                if(i == 1 && j == 1) continue;
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
                if(A[i-1][j-1] == 1) dp[i][j] = 0;
            }
        }
        return dp[N][M];
    }
};

64. 最小路径和

const int maxn = 205;
class Solution {
public:
    int dp[maxn][maxn];
    int N,M;
    int minPathSum(vector<vector<int>>& grid) {
        memset(dp,0x3f,sizeof dp);
        N = grid.size(),M = grid[0].size();
        dp[1][1] = grid[0][0];
        for(int i = 1;i<=N;i++){
            for(int j = 1;j<=M;j++){
                if(i == 1 && j == 1) continue;
                dp[i][j] = grid[i-1][j-1] + min(dp[i-1][j],dp[i][j-1]);
            }
        }
        return dp[N][M];
    }
};

152. 乘积最大子数组

const int maxn = 1e5 + 10;
class Solution {
public:
    struct node{
        int mx,mi;
    }dp[maxn];
    int maxProduct(vector<int>& nums) {
        memset(dp,0,sizeof dp);
        dp[0] = {nums[0],nums[0]};
        int ans = nums[0];
        for(int i = 1;i<nums.size();i++){
            dp[i].mx = max({nums[i],nums[i] * dp[i-1].mx,nums[i]*dp[i-1].mi});
            dp[i].mi = min({nums[i],nums[i] * dp[i-1].mx,nums[i]*dp[i-1].mi});
            ans = max(ans,dp[i].mx);
        }
        return ans;
    }
};