牛客网-刷题汇总（持续更新）

• 链表

• 树

• 数组

  •  双指针

  • 二分

• 贪心

• 动态规划

  • 背包

  • 其他DP

• 队列

• 栈

• 搜索

数组

• 双指针
  • NC247 最接近的三数之和

  • 思路：三数之和如果按照o(n^3)遍历肯定会爆，所以需要将复杂度降低到o(n^2)，问题就来到了如何能完全枚举所有可能性结果呢；双指针（当value>target时，此时说明此处三数之和已经大于target，后面不需要进行遍历，故，先将nums进行排序之后进行双指针）
    int ClosestSum(vector<int>& nums, int target) {
        sort(nums.begin(), nums.end());
        int min_value = INT_MAX;
        int res = 0;
        for (int i = 0; i < nums.size() - 2; i++) {
            int left = i + 1, right = nums.size() - 1;
            while (left < right) {
                int value = nums[i] + nums[left] + nums[right];
                if (abs(value - target) < min_value) {
                    res = value;
                    min_value = abs(value - target);
                }
                //次处不需要接else： 上述最接近3数之和处不知道是大于target还是小于target，所以不能直接进行left++或者right--操作； [-10,20,10,40], target=20
                if (value > target) {
                    right -= 1;
                } else {
                    left += 1;
                }
            }
        }
        return res;
    }

  • NC251 多数组第K小数

  • //思路：双指针，由于2个数组都是有序的，故只需要二分判断即可；
    int findKthNum(vector<int>& arr1, vector<int>& arr2, int target) {
        // write code here
        int arr1_left = 0, arr1_right = arr1.size() - 1;
        int arr2_left = 0, arr2_right = arr2.size() - 1;
        int arr1_idx = 0;
        int arr2_idx = 0;
        while (target != 1) {
            // 取出一半元素的idx索引（索引需要-1）
            int k = target / 2 - 1;
            // 索引位置不能超出数组的长度，故去min
            arr1_idx = min(arr1_left + k, arr1_right);
            arr2_idx = min(arr2_left + k, arr2_right);
            // 判断2个数组索引位置大小，如果小值的话，肯定不是需要的结果；
            if (arr1[arr1_idx] < arr2[arr2_idx]) {
                target = target - (arr1_idx - arr1_left + 1);
                arr1_left = arr1_idx + 1;
            } else {
                target = target - (arr2_idx - arr2_left + 1);
                arr2_left = arr2_idx + 1;
            }
            // 必须是大于，由于你上面target已经去掉了不可能答案，所以，剩下的数组一定满足答案；
            // 如果是==的话，由于你上面加1，导致你idx已经到最后一个位置，直接返回的话就有问题；
            if (arr1_left >  arr1_right) {
                return arr2[arr2_left + target - 1];
            }
            if (arr2_left > arr2_right) {
                return arr1[arr1_left + target - 1];
            }
        }
        return min(arr1[arr1_left], arr2[arr2_left]);
    }

  • NC286 调整数组顺序使奇数位于偶数的前面

  • vector<int> reOrderArrayTwo(vector<int>& array) {
        // write code here
        int left = 0, right = array.size() - 1;
        while (left < right) {
            while (left < right && array[left] % 2 == 1) {
                left += 1;
            }
            while (left < right && array[right] % 2 == 0) {
                right -= 1;
            }
            if (left < right) {
                swap(array[left], array[right]);
                left += 1;
                right -= 1;
            }
        }
        return array;
    }