【刷题】LeetCode

11.盛最多水的容器

题目

代码

class Solution {
public:
    int maxArea(vector<int>& height) {
        int left = 0;
        int right = height.size()-1;
        int result = (right - left) * min(height[right] , height[left]);        

        while(right>left){
            
            // 这个是因为只有往前走  才可能遇到最大的  
            if(height[left]<height[right]){   
             left++;
             
         }
         else{
             right--;           
         }
         result = max(result,(right - left) * min(height[right] , height[left]));
        }
        return result;
    }
};

15.三数之和

题目

代码

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {  
        int n = nums.size();
        sort(nums.begin(), nums.end()); 
        vector<vector<int>> ans;
        // 枚举 a
        for (int first = 0; first < n; ++first) {
            // 需要和上一次枚举的数不相同
            if (first > 0 && nums[first] == nums[first - 1]) {
                continue;
            }
            // c 对应的指针初始指向数组的最右端
            int third = n - 1;
            int target = -nums[first];
            // 枚举 b
            for (int second = first + 1; second < n; ++second) {
                // 需要和上一次枚举的数不相同
                if (second > first + 1 && nums[second] == nums[second - 1]) {
                    continue;
                }
                // 需要保证 b 的指针在 c 的指针的左侧
                while (second < third && nums[second] + nums[third] > target) {
                    --third;
                }
                // 如果指针重合，随着 b 后续的增加
                // 就不会有满足 a+b+c=0 并且 b<c 的 c 了，可以退出循环
                if (second == third) {
                    break;
                }
                if (nums[second] + nums[third] == target) {
                     .push_back({nums[first], nums[second], nums[third]});
                }
            }
        }
        return ans;
    }
};

31. 下一个排列

题目

代码

// 寻找下一个排列
// 算法理论
/* 1. 给定一个数组 从后向前遍历 找到nums[k]<nums[k+1] 如果找不到  则反转整个数组
 * 2. 从k向后遍历  找到比k大且与k相邻最近的数  将其调换  此时k之后的数 是降序排列
 * 3. 为了得到下一个排列  再将k+1之后的数反转
 */
class Solution{
public:
    void nextPermutation(vector<int>& nums){
        int length = nums.size();
        int k = length; // 记录k的位置

        // 1
        for(int i=length-2;i>=0;--i){
            if(nums[i]<nums[i+1]){
                k = i;
                break;
            }
        }

        if(k==length){  // 说明没有nums[k]<nums[k+1]
            sort(nums.begin(),nums.end());
        }else{
            // 2
            for(int i=length-1;i>k;--i){
                if(nums[i]>nums[k]){
                    // 调换i 和 k的位置
                    int temp = nums[i];
                    nums[i] = nums[k];
                    nums[k] = temp;
                    break;
                }
            }

            // 3.
            sort(nums.begin()+k+1,nums.end());  // k到
        }
    }
};

33. 搜索旋转排序数组

题目

代码

// 1. 直接暴力遍历
class Solution {
public:
    int search(vector<int>& nums, int target) {
        for(int i=0;i<nums.size();++i){
            if(nums[i]==target){
                return i;
            }
        }
        return -1;

    }
};
// 2. 二分查找

34. 在排序数组中查找元素的第一个和最后一个位置

题目

代码

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        vector<int> result;
         int length = nums.size();
         if(length==0){
            result.push_back(-1);
            result.push_back(-1);
            return result;
        }
         // 寻找第一个target
         int count = 0;
         for(int i=0;i<length;++i){
             // 存在第一个元素
             count++;
             if(nums[i]==target){
                 result.push_back(i);
                 break;
             }
             // 不存在target
        if(count==length||length==0){
            result.push_back(-1);
            result.push_back(-1);
            return result;
        }
        }  

         // 寻找最后一个target  已经默认数组中存在target
         for(int i=length-1;i>=0;--i){
             if(nums[i]==target){
                 result.push_back(i);
                 break;
             }
         }
         return result;

    }
};

74. 搜索二维矩阵

题目

代码

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        // 关键在于每一行的第一个数与target比较  
        int rows = matrix.size()-1;// 行
        int cols = matrix[0].size()-1;// 列

        int index = rows;
        while(index>=0){
            if(matrix[index][0]<=target){
            // for循环这步可以换成二分查找
            for(int i=0;i<=cols;++i){
                if(matrix[index][i]==target){
                    return true;
                }
            }
            return false;   // 结束循环  没找到target
        }else{ 
            index--;
            
        }
        }
        
        return false;
    }
};

82. 删除排序链表中的重复元素 II

题目

代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(!head || !head->next)
            return head;

        // 开启一个虚拟头节点  指向head
        ListNode* dummy = new ListNode(-1);
        dummy->next = head;
        
        // 开辟链表头
        ListNode* pre = dummy;  // 在这里一直转不过弯来  需要再看看
        ListNode* cur = head;

        while(cur&&cur->next){
            if(cur->val==cur->next->val){  
                // 如果存在重复值的话
                while (cur->next && cur->val == cur->next->val) {
                    // (一直出现重复)
                    cur = cur->next;
                }
                // 更新节点信息
                pre->next = cur->next;
                cur = cur->next;
            }else{
                pre = cur;
                cur = cur->next;
            }

        }

        return dummy->next;
        
    }
};

153. 寻找旋转排序数组中的最小值（二分查找）

题目

代码

class Solution {
public:
    int findMin(vector<int>& nums) {
        int left = 0;
        int right = nums.size()-1;

        while(left<right){
            //int middle = (right - left)/2 + left;   // 中间的数  向下取整
            int middle = (right + left) >> 1;
            if(nums[middle]<nums[right]){
                // 如果中间的数小于右边的数  说明middle比右边数都小 
                right = middle;
            } else{
                // 如果大于的话  说明最小值在middle右边 
                left = middle + 1;  // mid肯定不是最小值
            }
        }

        return nums[right];

    }
};

162. 寻找峰值

题目

代码

class Solution {
public:
    int findPeakElement(vector<int>& nums) {
        // 因为nums[-1] = nums[n] = -oo  所以必存在峰值
        int left = 0;
        int right = nums.size()-1;

        // 二分查找
        while(left<right){
            int middle = (right - left)/2 + left;

            if(nums[middle]<nums[middle+1]){
                // 如果nums[middle]较大  说明 middle之前肯定有峰值
                // 如果nums[middle+1]会较大 说明middle+1之后肯定有峰值
                left = middle + 1;
            }else{
                right = middle;
            }
        }
        return left;
    }
};

844. 比较含退格的字符串

题目

代码

class Solution {
public:
    bool backspaceCompare(string s, string t) {
        vector<char> r_s;
        vector<char> t_s;
        r_s = back(s);
        t_s = back(t);

        // 判断是否相同
         if(t_s.size()==0&&r_s.size()==0) return true;
        if(r_s.size()!=t_s.size()) return false;
        for(int i=0;i<r_s.size();++i){
            if(r_s[i]!=t_s[i]){
                return false;
            }
        }
        return true;
    }

    // 遍历数组
    vector<char> back(string& s){
        vector<char> result;
        int length = s.size();
        for(int i=0;i<length;++i){
			
			// 推格前保证result中有数据
            if(s[i]=='#'&&result.size()==0){
                continue;
            }

            if(s[i]=='#'&&result.size()!=0){
                result.pop_back();
                continue;
            }
            result.push_back(s[i]);
        }
        return result;
    }
};

986. 区间列表的交集

题目

代码

class Solution {
public:
    vector<vector<int>> intervalIntersection(vector<vector<int>>& A, vector<vector<int>>& B) {
        int cnt = 0;
        vector<vector<int>> vec;
        vector<int> tmp(2);
        for(int i=0;i<A.size()&&cnt<B.size();)
        {
            // 将情况分成四种情况  
            // 1.A 在 B的右边    没有交集        
            if(A[i][0]>B[cnt][1])
            {
                cnt++;
            }
            // 2.A在B的左边 没有交集
            else if(A[i][1]<B[cnt][0])
            {
                i++;
            }
            // 3.A在B的左边 有交集
            else if(A[i][1]<B[cnt][1])
            {
                tmp[0] = max(A[i][0],B[cnt][0]);
                tmp[1] = A[i][1];
                vec.push_back(tmp);
                i++;
            }
             // 4.A在B的右边 有交集
            else
            {
                tmp[0] = max(A[i][0],B[cnt][0]);
                tmp[1] = B[cnt][1];
                vec.push_back(tmp);
                cnt++;
            }
        }
        return vec;
    }
};