leecode 1：两数之和、27：移除元素、100:相同的树

lmy347771232

已于 2022-08-17 10:23:36 修改

阅读量65

点赞数

分类专栏： leecode 刷T 文章标签： leetcode 算法 c++

于 2022-08-10 11:52:56 首次发布

本文链接：https://blog.csdn.net/lmy347771232/article/details/126262589

版权

leecode 刷T 专栏收录该内容

29 篇文章 0 订阅

订阅专栏

两数之和
在这里插入图片描述

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int>tmp;
        for(int i=0;i<nums.size();++i)
        {    
            tmp.push_back(i);
            for(int j=i+1;j<nums.size();++j)
            {
                if(target==nums[j]+nums[i])
                {
                    tmp.push_back(j);
                    return tmp;
                }
            }
            tmp.pop_back();
        }
        return tmp;
    }
};

在这里插入图片描述
法2：哈希表

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int>tmp;
        unordered_map<int ,int >hash_map;
        for(int i=0;i<nums.size();i++)
        {
            hash_map.insert({nums[i],i});

        }
        for(int j=0;j<nums.size();++j)
        {
            tmp.push_back(j);
            
               int x=target-nums[j];
               if(hash_map.count(x)&&hash_map.at(x)!=j){
                tmp.push_back(hash_map.at(x));
                return tmp;
               
               }
            tmp.pop_back();
        }
        return tmp;
    }
};

12ms, 内存11mb

移除元素

在这里插入图片描述

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        ///sort(nums.begin(),nums.end());
        for(int i=0;i<nums.size();++i)
        {
            if(nums[i]==val)
            {
                nums.erase(nums.begin()+i);
                i--;//元素移除后i的值需要调整。
            }
        }
        return nums.size();
    }
};

很显然，如果删除的元素在数组中是n个，时间复杂度是0(N^2),空间复杂度为O（1）。本题如果要用O（n）方法去做，可以用快慢指针的方法：
快慢指针

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int slowIndex = 0;
        for (int fastIndex = 0; fastIndex < nums.size(); fastIndex++) {
            if (val != nums[fastIndex]) {
                nums[slowIndex++] = nums[fastIndex];
            }
        }
        return slowIndex;
    }
};

这样就实现了一遍遍历删除所有目标元素。

原文连接（有附图）：
https://programmercarl.com/0027.%E7%A7%BB%E9%99%A4%E5%85%83%E7%B4%A0.html#%E6%80%9D%E8%B7%AF

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q)
    {
        if(p==nullptr&&q==nullptr){return true;}
        if((p!=nullptr&&q!=nullptr)&&(q->val!=p->val)){return false;}
        if(q!=nullptr&&p==nullptr){return false;}
        if(q==nullptr&&p!=nullptr){return false;}
       bool tag= isSameTree(p->left, q->left);
        bool tag1=isSameTree(p->right, q->right);
        return  tag&&tag1;
    }
        
};