速刷算法#Day-01

 刷算法，冲秋招，酱紫~

1. 二分查找

二分查找是一种高效的搜索算法，用于在有序数组中查找特定元素。该算法将搜索范围逐渐缩小一半，直到找到目标元素或确定不存在。

两个二分查找的实现示例，它们都采用了不同的处理边界和更新指针的方式。第一个示例中的 search 函数使用闭区间 [left, right] 进行搜索，而第二个示例中的 Division 函数使用左闭右开区间 [left, right) 进行搜索。这两种方式都是有效的，关键是正确地更新指针和边界，以确保不会陷入死循环并找到目标值。

class Solution {
 
public:
    int search(vector& nums,int target){
        int left=0,right=nums.size()-1;
        while(left<=right){

            int middle=(left+right)/2;

            cout< target) {
                right = middle - 1; // target 在左区间，所以[left, middle - 1]
            } else if (nums[middle] < target) {
                left = middle + 1; // target 在右区间，所以[middle + 1, right]
            } else { // nums[middle] == target
                return middle; // 数组中找到目标值，直接返回下标
            }
            
        }
        // 未找到目标值
        return -1;
        }
    
};

class Solution {

public:
    int Divsion(vector& nums,int target){
        int left=0,right=nums.size()-1;
        while(left target) {
                right = middle; // target 在左区间，左闭右开，所以[left, middle ]
            } else if (nums[middle] < target) {
                left = middle + 1; // target 在右区间，所以[middle + 1, right]
            } else { // nums[middle] == target
                return middle; // 数组中找到目标值，直接返回下标
            }
            
        }
        // 未找到目标值
        return -1;
        }
}; 

2. 字符串反转

字符串反转是一种常见的操作，用于颠倒字符串中字符的顺序。提供了三种不同的实现方式，它们分别是：

• 使用双指针法：从字符串两端向中间遍历，交换字符。
• 使用标准库函数 reverse：直接调用标准库提供的字符串反转函数。（纯脑瘫）
• 基于之前提供的反转方法。

这些方法都可以有效地反转字符串，关键是理解双指针法的原理以及如何正确地交换字符。

 

class Solution{
public:
   void reverses(vector& s){
    
    for(int i=0,j=s.size()-1;i

 

class Solution{
public:
  string reverseString(string s)
    {
        int i = 0, j = s.size() - 1;
        while (i < s.size()/2)
        {
        swap(s[i++], s[j--]);
        }
        return s;
    }
};

class Solution{
    public:
        void reverseString(vector& s){
            //use reverse
            reverse(s.begin(), s.end());
        }
};

 

3. 移除元素

移除元素是指从数组中删除特定值的所有实例。提供了两种不同的实现方式，它们分别是：

• 使用两个指针：一个快指针用于遍历数组，一个慢指针用于指向下一个非目标值的位置，将非目标值覆盖到慢指针所指的位置。
• 使用单指针：遍历数组，当遇到非目标值时，将其复制到慢指针位置，并将慢指针右移。

这两种方式都是有效的，关键是正确地更新指针和数组元素，以达到移除目标元素的目的。

class Solution{
    public:
        int removeElement(vector& nums,int val){
            int size=nums.size();
            for(int i=0;i

class Solution{
    public:
        int removeElement(vector& nums,int val){
            int slow=0;
            for(int fast=0;fast

class Solution {
public:
    int removeElement(vector& nums, int val) {
        int leftIndex = 0;  // 左指针从数组开头开始
        int rightIndex = nums.size() - 1;  // 右指针从数组末尾开始
        while (leftIndex <= rightIndex) {
            // 找左边等于val的元素，一直移动左指针
            while (leftIndex <= rightIndex && nums[leftIndex] != val) {
                ++leftIndex;
            }
            // 找右边不等于val的元素，一直移动右指针
            while (leftIndex <= rightIndex && nums[rightIndex] == val) {
                --rightIndex;
            }
            // 如果左指针指向的位置在右指针左侧，将右指针指向的不等于val的元素覆盖左指针指向的等于val的元素
            if (leftIndex < rightIndex) {
                nums[leftIndex++] = nums[rightIndex--];
            }
        }
        return leftIndex;   // leftIndex 现在指向了最终数组末尾的下一个位置
    }
};

 

4. 爬楼梯

爬楼梯是一个经典的动态规划问题，其中你需要计算爬到第 n 级楼梯的不同方法数。你提供了两种不同的实现方式，它们都使用动态规划来计算不同方法数。

第一个示例中的 climbStairs 函数使用数组来存储中间结果，从而避免重复计算。第二个示例中的 climbStairs 函数使用滚动数组的方式，只存储最近两个状态，进一步优化了空间复杂度。

class Solution {
public:
    int climbStairs(int n) {
        if (n <= 1) return n; // 因为下面直接对dp[2]操作了，防止空指针
        vector dp(n + 1);
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++) { // 注意i是从3开始的
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
};

class Solution {
public:
    int climbStairs(int n) {
        if (n <= 1) return n;
        int dp[3];
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++) {
            int sum = dp[1] + dp[2];
            dp[1] = dp[2];
            dp[2] = sum;
        }
        return dp[2];
    }
};

 

5. 二叉树构建

用了前序遍历进行构造

class TreeNode{
    public:
        int val;
        TreeNode *left;
        TreeNode *right;
        TreeNode(int x):val(x),left(NULL),right(NULL){}

    void traversal(TreeNode* cur,vector & vec){
        if(cur==NULL)return;
        vec.push_back(cur->val);
        preorderTraversal(cur->left);
        preorderTraversal(cur->right);

    }

    vector preorderTraversal(TreeNode *root){
        vector vec;
        traversal(root,vec);
        return vec;
    }
};