【牛客刷题】最小k个数

最小k个数

https://www.nowcoder.com/share/jump/9321389651694956999635
采用优先级队列构造小顶堆，时间复杂度为O(n * log n)，空间复杂度O(n)：
priority_queue<int, vector, greater> qp;

vector<int> GetLeastNumbers_Solution(vector<int>& input, int k) {
        // write code here
        if (k == 0 || k > input.size()) return vector<int>();
        priority_queue<int, vector<int>, greater<int>> pq;
        for (auto i : input) {
            pq.push(i);
        }
        vector<int> res(k);
        for (int i = 0; i < k; i++) {
            res[i] = pq.top();
            pq.pop();
        }
        return res;
    }

或者手动维护一个k大小的数组que和一个最大值以及最小值，分几种情况处理，每次都需要用max_element来查找que里面的最大值并更新。这种方法时间复杂度为O(kn)，空间复杂度为O(k)：

    vector<int> GetLeastNumbers_Solution(vector<int>& input, int k) {
        // write code here
        if (k == 0 || k > input.size()) return vector<int>();
        vector<int> que(k);
        pair<int, int> maxNum = {-1, -1};
        pair<int, int> minNum = {-1, -1};
        for (int i = 0; i < k; i++) {
            que[i] = input[i];
            if (maxNum.first < input[i]) {
                maxNum = {input[i], i};
            }
            if (minNum.first > input[i]) {
                minNum = {input[i], i};
            }
        }

        for (int i = k; i < input.size(); i++) {
            if (input[i] > minNum.first && input[i] < maxNum.first) {
                que[maxNum.second] = input[i];
                maxNum = {*max_element(que.begin(), que.end()), max_element(que.begin(), que.end()) - que.begin()};
            } 
            else if (input[i] < minNum.first) {
                que[maxNum.second] = input[i];
                maxNum = {*max_element(que.begin(), que.end()), max_element(que.begin(), que.end()) - que.begin()};
                
                minNum = {input[i], i};
            }
            else if (input[i] > maxNum.first) continue;
        }
        return que;
    }

因此可以联想到采用大顶堆，直接用pq.top()代替max_element：

    vector<int> GetLeastNumbers_Solution(vector<int>& input, int k) {
        // write code here
        if (k == 0 || k > input.size()) return vector<int>();
        priority_queue<int> pq;
        for (int i = 0; i < k; i++) {
            pq.push(input[i]);
        }
        for (int i = k; i < input.size(); i++) {
            if (input[i] < pq.top()) {
                pq.pop();
                pq.push(input[i]);
            }
        }
        vector<int> res;
        while (!pq.empty()) {
            res.push_back(pq.top());
            pq.pop();
        }
        return res;
    }

寻找第K大

https://www.nowcoder.com/share/jump/9321389651694962217445
快速排序的变种——快速选择：把排序的步骤分离出来，每一次排序就是找到pivot在数组中应该在的下标，将返回的下标与k值比较，要是大于k就回传pivot左边数组继续找，小于k就回传pivot右边数组找：

    int partition(vector<int>& arr, int left, int right) {
        int i = left, j = right;
        int pivot = arr[left];

        while (i < j) {
            while (i < j && arr[j] >= pivot) j--;
            while (i < j && arr[i] <= pivot) i++;
            if (i < j) swap(arr[i], arr[j]);
        }
        swap(arr[left], arr[i]); //找准元素在数组中的下标
        return i;
    }

    int quickSelect(vector<int>& arr, int K, int left, int right) {
        if (left >= right) return arr[left];

        int pivotIndex = partition(arr, left, right);//从第一个元素开始找下标
        if (pivotIndex == K) return arr[pivotIndex];
        else if (pivotIndex < K) {
            return quickSelect(arr, K, pivotIndex+1, right);
        }
        else return quickSelect(arr, K, left, pivotIndex-1);
    }

    int findKth(vector<int>& a, int n, int K) {
        // write code here
        return quickSelect(a, n-K, 0, n-1);
    }

之前写的暴力快排：

    void quickSort(vector<int>& arr, int left, int right) {
        if (left >= right) return;
        int i = left, j = right;
        int pivot = arr[left];
        while (i < j) {
            while (i < j && arr[j] >= pivot) j--;
            while (i < j && arr[i] <= pivot) i++;
            if (i < j) swap(arr[i], arr[j]);
        }
        swap(arr[left], arr[i]);
        quickSort(arr, left, i-1);
        quickSort(arr, i+1, right);
    }

    int findKth(vector<int>& a, int n, int K) {
        // write code here
        quickSort(a, 0, n-1);
        return a[n-K];
    }
};

两数之和

https://www.nowcoder.com/share/jump/9321389651695003531423
哈希法，遍历整个数组，查找target与当前元素的差值是否在哈希表里，如果在，就直接输出当前下标以及差值的下标，如果不在，就把当前元素以及对应的下标存进哈希表，然后继续遍历：

    vector<int> twoSum(vector<int>& numbers, int target) {
        // write code here
        unordered_map<int, int> numIndex;
        vector<int> res;
        for (int i = 0; i < numbers.size(); i++) {
            int diff = target - numbers[i];
            if (numIndex[diff] != 0) {
                res.push_back(min(i+1, numIndex[diff]));
                res.push_back(max(i+1, numIndex[diff]));
                break;
            }
            else {
                numIndex[numbers[i]] = i+1;
            }
        }
        return res;
    }

两个栈实现队列

https://www.nowcoder.com/share/jump/9321389651695022226386
思路：每次push后，stack1为空，stack2存反向序列。所以第一步将2里面的元素全部转移到1里面，然后2栈底存新加入的元素，再把1的元素回灌到2里面。

class Solution
{
public:
    void push(int node) {
        if (stack1.empty() && stack2.empty()) {
            stack2.push(node);
        }
        else if (stack1.empty() && !stack2.empty()) {
            //把2里面的元素转移到1里面
            while (!stack2.empty()) {
                stack1.push(stack2.top());
                stack2.pop();
            }
            //2里面加入新的元素和1里面的元素
            stack2.push(node);
            while (!stack1.empty()) {
                stack2.push(stack1.top());
                stack1.pop();
            }
        }
    }

    int pop() {
        int popNum = stack2.top();
        stack2.pop();
        return
    }

private:
    stack<int> stack1;
    stack<int> stack2;
};

跳台阶

https://www.nowcoder.com/share/jump/9321389651695022674212

    int jumpFloor(int number) {
        // write code here
        vector<int> dp(number+1);
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= number; i++) {
            dp[i] = dp[i-1] + dp[i-2];
        }
        return dp[number];
    }

合并两个有序数组

https://www.nowcoder.com/share/jump/9321389651695024694688

    void merge(int A[], int m, int B[], int n) {
        int indexA = m - 1, indexB = n - 1, i = m + n - 1;
        while (i >= 0) {
            if (indexA + 1 == 0) {
                A[i] = B[indexB];
                indexB--;
                i--;
            } else if (indexB + 1 == 0) {
                A[i] = A[indexA];
                indexA--;
                i--;
            } else if (A[indexA] >= B[indexB]) {
                A[i] = A[indexA];
                indexA--;
                i--;
            } else {
                A[i] = B[indexB];
                indexB--;
                i--;
            }
        }
        return;
    }

chatGPT修改的，更为简洁：
当A的大小（即m）大于B的大小（即n）时，实际上不需要处理剩余的A中的元素，因为它们已经在正确的位置上了。

class Solution {
  public:
    void merge(int A[], int m, int B[], int n) {
        int indexA = m - 1, indexB = n - 1, i = m + n - 1;
        while (indexA >= 0 && indexB >= 0) {
            if (A[indexA] >= B[indexB]) {
                A[i] = A[indexA];
                indexA--;
            } else {
                A[i] = B[indexB];
                indexB--;
            }
            i--;
        }

        while (indexB >= 0) {
            A[i] = B[indexB];
            indexB--;
            i--;
        }
        return;
    }
};

有效括号

在获取栈顶元素st.top()前一定要先判断是否为空st.empty()，不然会引起错误：

    bool isValid(string s) {
        // write code here
        stack<char> st;
        st.push(s[0]);
        for (int i = 1; i < s.size(); i++) {
            if (!st.empty() && st.top() == '(' && s[i] == ')') {
                st.pop();
                continue;
            } 
            else if (!st.empty() && st.top() == '[' && s[i] == ']') {
                st.pop();
                continue;
            } 
            else if (!st.empty() && st.top() == '{' && s[i] == '}') {
                st.pop();
                continue;
            } 
            else {
                st.push(s[i]);
            }
        }
        return st.empty();
    }

简洁版：

    bool isValid(string s) {
        stack<char> st;
        for (int i = 0; i < s.size(); i++) {
            if (!st.empty() && ((st.top() == '(' && s[i] == ')') || (st.top() == '[' &&
                                s[i] == ']') || (st.top() == '{' && s[i] == '}'))) {
                st.pop();
            } else {
                st.push(s[i]);
            }
        }
        return st.empty();
    }

大数加法

https://www.nowcoder.com/share/jump/9321389651695027603035
自己写的，逻辑比较清晰

    string solve(string s, string t) {
        // write code here
        int carry = 0, remainder = 0;
        int lenS = s.size(), i = lenS - 1;
        int lenT = t.size(), j = lenT - 1;
        vector<int> res;
        while (i >= 0 && j >= 0) {
            int sum = (s[i] - '0') + (t[j] - '0') + carry;
            carry = sum / 10;
            remainder = sum % 10;
            res.push_back(remainder);
            i--, j--;
        }
        while (j >= 0) {
            int sum = (t[j] - '0') + carry;
            carry = sum / 10;
            remainder = sum % 10;
            res.push_back(remainder);
            j--;
        }
        while (i >= 0) {
            int sum = (s[i] - '0') + carry;
            carry = sum / 10;
            remainder = sum % 10;
            res.push_back(remainder);
            i--;
        }
        if (carry) res.push_back(carry);
        string result = "";
        for (int i = res.size()-1; i >= 0; i--) {
            result = result + to_string(res[i]);
        }
        return result;
    }

GPT改的简洁版：

    string solve(string s, string t) {
        // write code here
        int carry = 0;
        int i = s.size() - 1;
        int j = t.size() - 1;
        string res = "";
        while (i >= 0 || j >= 0 || carry) {
            int sum = carry;
            if (i >= 0) sum += s[i--] - '0';
            if (j >= 0) sum += t[j--] - '0';

            carry = sum / 10;
            res += to_string(sum % 10);
        }
        reverse(res.begin(), res.end());
        return res;
    }

之字形层序遍历二叉树

https://www.nowcoder.com/share/jump/9321389651695029332931
采用双端队列deque实现，当奇数层的时候从左往右打印，偶数层的时候从右往左打印，对应双端队列就是：奇数层从前pop，从后push；偶数层从后pop，从前push。

    vector<vector<int> > Print(TreeNode* pRoot) {
        // write code here
        if (!pRoot) return vector<vector<int>> ();
        deque<TreeNode*> dq;
        bool even = false;
        vector<vector<int>> result;
        dq.push_back(pRoot);
        while (!dq.empty()) {
            int size = dq.size();
            vector<int> res;
            for (int i = 0; i < size; i++) {
                if (!even) {
                    TreeNode* temp = dq.front();
                    dq.pop_front();
                    res.push_back(temp->val);

                    if (temp->left) dq.push_back(temp->left);
                    if (temp->right) dq.push_back(temp->right);
                }
                else {
                    TreeNode* temp = dq.back();
                    dq.pop_back();
                    res.push_back(temp->val);
                    
                    if (temp->right) dq.push_front(temp->right);
                    if (temp->left) dq.push_front(temp->left);
                }
            }
            result.push_back(res);
            even = !even;
        }
        return result; 
    }