Leetcode 高频算法题

已于 2023-11-09 13:58:23 修改
阅读量179 收藏
点赞数
文章标签： 算法 leetcode
于 2023-10-25 18:12:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dezhonger/article/details/134040453
版权

目录

4. 寻找两个正序数组的中位数

  1. 转为求数组的第k个数的问题
  2. 比较a数组的中间的那个数x，和b数组中间的那个数y。如果x > y，则可以抛弃b数组的前半部分，否则抛弃a数组的前半部分.
class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int tot = nums1.size() + nums2.size();
        if (tot % 2 == 0) {
            int left = find(nums1, 0, nums2, 0, tot / 2);
            int right = find(nums1, 0, nums2, 0, tot / 2 + 1);
            return (left + right) / 2.0;
        } else {
            return find(nums1, 0, nums2, 0, tot / 2 + 1);
        }
    }

    int find(vector<int>& nums1, int i, vector<int>& nums2, int j, int k) {
    	// 保证nums1.size() <= nums2.size()
        if (nums1.size() - i > nums2.size() - j) return find(nums2, j, nums1, i, k);
        if (k == 1) {
            if (nums1.size() == i) return nums2[j]; //nums1是空
            else return min(nums1[i], nums2[j]);
        }
        if (nums1.size() == i) return nums2[j + k - 1];
        //这里的si,sj是中间那个数的下一个位置
        int si = min((int)nums1.size(), i + k / 2), sj = j + k - k / 2;
        if (nums1[si - 1] > nums2[sj - 1])
        	// 扔掉nums2数组的前面部分的数
            return find(nums1, i, nums2, sj, k - (sj - j));
        else
            return find(nums1, si, nums2, j, k - (si - i));
    }
}

80. 删除有序数组中的重复项 II

lc26和这一题是差不多的，区别是26是只出现一次，本题

class Solution {
public:
    int removeDuplicates(vector<int>& a) {
        int k = 2; //对应题意中的只出现两次，根据题意可以动态改变为1次，3次都可以
        int u = 0;
        for (int x: a) if (u < k || x != a[u - k]) a[u++] = x;
        return u;
    }
};

42. 接雨水

class Solution {
public:
  int trap(vector<int>& height) {
        int n = height.size(), ans = 0;
        stack<int> st;
        for (int i = 0; i < n; i++) {
            // 这里>和>=都可以AC
            while (st.size() && height[i] >= height[st.top()]) {
                int k = st.top();
                st.pop();
                if (st.empty()) break;
                ans += (i - st.top() - 1) * (min(height[i], height[st.top()]) - height[k]);
            }
            st.push(i);
        }
        return ans;
    }
};

45. 跳跃游戏 II

和lc55题差不多，区别是本题需要求出跳跃到n-1这个位置的最小次数.
f[i]表示到达位置i的最小次数，定义last为第一次到达位置i的时候上一步的位置。 归纳可知，从小到达遍历过程中，第一次通过x可以到达y时，y的最小步数就是到达x的最小步数+1.因此有f[i] = f[last] + 1.
时间复杂度为O(N)

class Solution {
public:
    int jump(vector<int>& a) {
        int n = a.size(), last = 0;
        vector<int> f(n);
        for (int i = 1; i < n; i++)
        {
            while (last + a[last] < i) last++;
            f[i] = f[last] + 1;
        }
        return f[n - 1];
    }
};

55. 跳跃游戏

给你一个非负整数数组，你最初位于数组的 第一个下标 。数组中的每个元素代表你在该位置可以跳跃的最大长度。
使用一个整数维护当前能调到的最远的位置即可。

class Solution {
public:
    bool canJump(vector<int>& nums) {
        for (int i = 0, k = 0; i < nums.size(); i++) {
            if (k < i) return false;
            k = max(k, i + nums[i]);
        }
        return true;
    }
};

75. 颜色分类

三指针处理

class Solution {
public:
    void sortColors(vector<int>& a) {
        int i = 0, j = 0, k = a.size() - 1;
        // 始终满足以下的条件
        // [0, i - 1]都是0
        // [i, j - 1]都是1
        // [k + 1, n - 1]都是2
        // 其余都是还未处理的 也就是[j, k]
        for (;j <= k;) {
            if (a[j] == 0) swap(a[i++], a[j++]);
            else if (a[j] == 2) swap(a[j], a[k--]);
            else j++;
           
        }
    }
};

76. 最小覆盖子串

双指针，然后用hash和cnt维护字符剩余的数量。

class Solution {
public:
    string minWindow(string s, string t) {
        int n = s.size();
        unordered_map<char, int> hash;
        // cnt表示t里一共有多少种字符，hash存储每个字符有多少个
        int cnt = 0;
        for (char c: t) {
            hash[c]++;
            if (hash[c] == 1) cnt++;
        }
        string res = "";
        // j, i表示两个指针 c表示当前区间内已经满足的字符的种类数
        for (int i = 0, j = 0, c = 0; i < n; i++) {
            if (hash[s[i]] == 1) c++; //s[i]这个字符还缺一个就够了
            hash[s[i]]--;
            while (c == cnt && hash[s[j]] < 0) hash[s[j++]]++; //移动左指针，尽可能缩小区间
            if (c == cnt && (res.empty() || res.size() > (i - j + 1))) res = s.substr(j, i - j + 1);
        }
        return res;
    }
};

117. 填充每个节点的下一个右侧节点指针 II

116和本题类似，区别是116是完美二叉树
下面的代码可以AC这两个题目。

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        if (root == nullptr) return root;
        Node* cur = root;
        // cur每一层的第一个节点
        while (cur)
        {
            auto head = new Node(-1);
            auto tail = head;
            // 用tail指针把下一层的节点都连了起来. 这些为什么可以使用 p->next遍历的原因.
            // 注意第一次的时候，第一层只有一个根节点，这里只循环一次，然后把第二层的节点横着连了起来
            for (auto p = cur; p; p = p -> next)
            {
                if (p -> left) tail = tail -> next = p -> left;
                if (p -> right) tail = tail -> next = p -> right;
            }
            // head -> next是下一层的第一个节点
            cur = head -> next;
            delete head;
        }
        return root;
    }
};

128. 最长连续序列

做法1：维护每个数字以它为左端点和右端点的最长连续长度 时间复杂度:O(N)

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        int res = 0;
        unordered_map<int, int> tr_left, tr_right;
        for (auto & x : nums)
        {
            int left = tr_right[x - 1];
            int right = tr_left[x + 1];
            tr_left[x - left] = max(tr_left[x - left], left + 1 + right);
            tr_right[x + right] = max(tr_right[x + right], left + 1 + right);
            res = max(res, left + 1 + right);
        }
        return res;
    }
};

做法2：枚举每一段的起点即可 时间复杂度:O(N)

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        unordered_set<int> S;
        for (auto x: nums) S.insert(x);

        int res = 0;
        for (auto x: nums) {
        	// 保证枚举的是起点
            if (S.count(x) && !S.count(x - 1)) {
                int y = x;
                // 删除掉，避免nums里有重复的数会重复枚举的情况
                S.erase(x);
                while (S.count(y + 1)) {
                    y ++ ;
                    S.erase(y);
                }
                res = max(res, y - x + 1);
            }
        }

        return res;
    }
};

133. 克隆图

使用hash表，然后dfs.这个算是一个通用的解法

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> neighbors;
    Node() {
        val = 0;
        neighbors = vector<Node*>();
    }
    Node(int _val) {
        val = _val;
        neighbors = vector<Node*>();
    }
    Node(int _val, vector<Node*> _neighbors) {
        val = _val;
        neighbors = _neighbors;
    }
};
*/

class Solution {
public:
    unordered_map<Node*, Node*> hash;

    Node* cloneGraph(Node* node) {
        if (!node) return NULL;
        dfs(node);  // 复制所有点

        for (auto [s, d]: hash) {
            for (auto ver: s->neighbors)
                d->neighbors.push_back(hash[ver]);
        }

        return hash[node];
    }

    void dfs(Node* node) {
        hash[node] = new Node(node->val);

        for (auto ver: node->neighbors)
            if (hash.count(ver) == 0)
                dfs(ver);
    }
};

165. 比较版本号

class Solution {
public:
    int compareVersion(string v1, string v2) {
        for (int i = 0, j = 0; i < v1.size() || j < v2.size();) {
            int a = i, b = j;
            while (a < v1.size() && v1[a] != '.') a ++ ;
            while (b < v2.size() && v2[b] != '.') b ++ ;
            // 当第一个字符串已经枚举完，也就是i < v1.size()不满足的情况下，会走到 (a == i)的逻辑
            int x = a == i ? 0 : stoi(v1.substr(i, a - i));
            int y = b == j ? 0 : stoi(v2.substr(j, b - j));
            if (x > y) return 1;
            if (x < y) return -1;
            i = a + 1, j = b + 1;
        }
        return 0;
    }
};

215. 数组中的第K个最大元素

是快速排序的一部分代码，我们先看快速排序怎么写的. 这个可以当做模板使用

const int N = 100005;
int n;
int a[N];

void qsort(int a[], int l, int r) {
    if (l >= r) return ;
    int x = a[l + r >> 1], i = l - 1, j = r + 1;
    while (i < j) {
        do i++; while (a[i] < x);
        do j--; while (a[j] > x);
        if (i < j) swap(a[i], a[j]);
    }
    qsort(a, l, j);
    qsort(a, j + 1, r);
}

int main() {
    ios::sync_with_stdio (false);
    cin.tie (0);
    cin >> n;
    for (int i = 0; i < n; i++) cin >> a[i];
    qsort(a, 0, n - 1);
    for (int i = 0; i < n; i++) cout << a[i] << " ";
    cout << endl;
    return 0;
}

下面是这部分的代码

class Solution {
public:
    // 找到a[l...r]中第k小的时候，k是从1开始，k=1表示最小的数.
    int findKth(vector<int>& a, int l, int r, int k) {
        if (l == r) return a[l];
        int x = a[(l + r) >> 1], i = l - 1, j = r + 1;
        while (i < j) {
            do i++; while (a[i] < x);
            do j--; while (a[j] > x);
            if (i < j) swap(a[i], a[j]);
        }
        // 把区间分为了[l, j], [j + 1, r]两部分
        int c = j - l + 1;
        if (k <= c) return findKth(a, l, j, k);
        else return findKth(a, j + 1, r, k - c);
    }

    int findKthLargest(vector<int>& nums, int k) {
        int n = nums.size();
        // 这个题目是求k大,这里转为求第k小的问题
        k = n + 1 - k;
        return findKth(nums, 0, n - 1, k);
    }
};

236. 二叉树的最近公共祖先

题解

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* ans;
    bool dfs(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (root == nullptr) return false;
        bool lson = dfs(root->left, p, q);
        bool rson = dfs(root->right, p, q);
        if ((lson && rson) || ((root->val == p->val || root->val == q->val) && (lson || rson))) {
            ans = root;
        }
        return lson || rson || (root->val == p->val || root->val == q->val);
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        dfs(root, p, q);
        return ans;
    }
};

比较简单的写法，用state维护状态

class Solution {
public:
    TreeNode* ans = NULL;

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        dfs(root, p, q);
        return ans;
    }

    int dfs(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (!root) return 0;
        // 已经找到答案了
        if (ans != nullptr) return 0;
        int state = 0;
        if (root == p) state |= 1;
        if (root == q) state |= 2;
        state |= dfs(root->left, p, q);
        state |= dfs(root->right, p, q);
        if (state == 3 && !ans) ans = root;
        return state;
    }
};

297. 二叉树的序列化与反序列化

这里用前序遍历的方法来做

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Codec {
public:

    void solve(TreeNode* root, string& s) {
        if (root == nullptr) s += "#,";
        else {
            s += to_string(root -> val) + ',';
            solve(root -> left, s);
            solve(root -> right, s);
        }
    }

    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        string s;
        solve(root, s);
        return s;
    }

    TreeNode* solve(string& data, int& u) {
        if (data[u] == '#') {
            u += 2;
            return nullptr;
        } else {
            int k = u;
            // 找到连续的数字，对应val
            while (data[u] != ',') u++;
            TreeNode* root = new TreeNode(stoi(data.substr(k, u - k)));
            u++;
            root -> left = solve(data, u);
            root -> right = solve(data, u);
            return root;
        }
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        int u = 0;
        return solve(data, u);
    }
};

384. 打乱数组

循环一遍。假设当前下标为i，数组长度为n, 每次交换索引i，与索引[i, n-1]中的某一个

class Solution {
public:
    vector<int> a;
    Solution(vector<int>& nums) {
        a = nums;
    }
    
    vector<int> reset() {
        return a;
    }
    
    vector<int> shuffle() {
        int n = a.size();
        auto b = a;
        // 每次交换 b[i], 和 b[[i, n - 1]]内的一个数
        for (int i = 0; i < n; i++) swap(b[i], b[rand() % (n - i) + i]);
        return b;
    }
};

426. 将二叉搜索树转化为排序的双向链表 VIP

递归处理，null判断掉。对于X的子树，X需要子树转完链表后的头结点和尾节点, 我们定义一个Info结构体来处理。递归结束后要把整个链表的头尾也连上.

class Solution {
    struct Info {
        TreeNode * start;
        TreeNode *end;
        
        Info(TreeNode * start, TreeNode * end) : start(start), end(end){
        }
    };
    
    Info *process(TreeNode *x){
        if(x == nullptr) return new Info(nullptr, nullptr);
        auto left = process(x->left);
        auto right = process(x->right);
        
        //维护当前节点和左右子树的左右指针
        if(left->end != nullptr) left->end->right = x;
        x->left = left->end;
        x->right = right->start;
        if(right->start != nullptr) right->start->left = x;
        auto start = left->start != nullptr ? left->start : x;
        auto end = right->end != nullptr ? right->end : x;
        return new Info(start, end);
    }
public:
    TreeNode* treeToDoublyList(TreeNode *head) {
        if(head == nullptr) return nullptr;
        auto all = process(head);
        all->start->left = all->end;
        all->end->right = all->start;
        return all->start;
    }
};

449. 序列化和反序列化二叉搜索树

将树进行前序遍历后的字符串存下来，注意这里不需要存类似于lc297的空节点。因为这是一个二叉搜索树，它的中序遍历是有序的。也就是说前序里后的第一个节点为根节点，那么后面连续的一段小于当前值的节点即为它的左子树。递归处理即可。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Codec {
public:
    void solve(TreeNode* root, string& path) {
        if (!root) return;
        path += to_string(root -> val) + ' ';
        solve(root -> left, path);
        solve(root -> right, path);
    }
    string serialize(TreeNode* root) {
        string path;
        solve(root, path);
        return path;
    }
    
    TreeNode* solve(vector<int>& v, int &u, int lower, int upper) {
        if (v.size() == u || v[u] < lower || v[u] > upper) return nullptr;
        TreeNode* root = new TreeNode(v[u++]);
        root -> left = solve(v, u, lower, root -> val - 1);
        root -> right = solve(v, u, root -> val + 1, upper);
        return root;
    }

    TreeNode* deserialize(string data) {
        vector<int> v;
        stringstream ss(data);
        int x, u = 0;
        while (ss >> x) v.push_back(x);
        return solve(v, u, INT_MIN, INT_MAX);
    }
};
dezhonger
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Leetcode力扣常考高频题-动态规划
luy0710的博客
04-06 234
考察频率由两个部分组成 Leetcode100题 面试考察频率（https://codetop.cc/#/home）表格中默认超过30次即为高频题 题号 难度 题目描述 解法 考察频率 53 简单 最大子序列和 动归 -> 约化成<0则舍 Leetcode100+高频 6
万字长文 | 字节跳动面试高频算法题（先码再看）
最新发布
2401_83384536的博客
04-12 1219
今天给大家带来一篇，让算法不在成为进入大厂的绊脚石。
力扣高频|算法面试题汇总(一）：开始之前
qq_24739717的博客
04-11 1261
力扣高频|算法面试题汇总(一）：开始之前 力扣链接 目录： 1.只出现一次的数字 2.多数元素 3.搜索二维矩阵 II 4.合并两个有序数组 1.只出现一次的数字 给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。 说明： 你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？ 示例 1: 输入: [2,2,1] 输出: 1 示例...
力扣高频|算法面试题汇总(四）：堆、栈与队列
qq_24739717的博客
04-28 919
力扣高频|算法面试题汇总(四）：堆、栈与队列 力扣链接 目录： 1.最小栈 2.数组中的第K个最大元素 3.数据流的中位数 1.最小栈 设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。 push(x) —— 将元素 x 推入栈中。 pop() —— 删除栈顶的元素。 top() —— 获取栈顶元素。 getMin() —— 检索栈中的最小元素。 示例: ...
力扣高频|算法面试题汇总(八）：排序与检索
qq_24739717的博客
05-10 560
力扣高频|算法面试题汇总(八）：排序与检索 力扣链接 目录： 1.最大数 1.最大数 给定一组非负整数，重新排列它们的顺序使之组成一个最大的整数。 示例 1: 输入: [10,2] 输出: 210 示例 2: 输入: [3,30,34,5,9] 输出: 9534330 说明: 输出结果可能非常大，所以你需要返回一个字符串而不是整数。 思路: 刚开始直接想的就是用字典排序，然后进行字符串拼接...
LeetCode高频算法面试题,含解题思路及代码实现
02-17
以上是LeetCode高频算法面试题的一些主要知识点。通过深入学习和实践，你可以提升自己的算法能力，为面试做好充分准备。解题思路和代码实现的分享可以帮助你更好地理解和应用这些算法，从而在实际工作中解决复杂的...
leetCode 面试高频算法整理-2020
09-25
2020高频面试算法整理 leetcode ，18个大类，80+到常见算法题。 1.热身题|1)查找唯一数字|2)查找N/2数字|3)判断数字是否存在|4)合并二叉树|5)泡鸡蛋问题|2.互联网公司最常见的面试算法题有哪些？|3.TOP INTERVIEW ...
LeetCode每日一题高频面试算法题目1
08-03
LeetCode每日一题高频面试算法题目1 本资源是一个 LeetCode 高频面试算法题目集合，包括队列实现栈、反转单链表、合并两个排序数组等多个算法题目。 1. 队列实现栈： 在该题目中，我们使用了两个队列来实现栈的...
leetcode高频面试题-weekly_meeting:周会
07-06
leetcode高频面试题黑手党 这本书的重点是记录黑手党的每周讨论。 我们注重谈论人们感兴趣的面试问题和技术话题。编码问题通常来自面试中的高频算法。 如果您有兴趣了解更多关于任何成员的信息，请单击 。
入门算法leetcode面试题刷题
09-14
本篇文章将围绕“入门算法leetcode面试题刷题”这一主题展开讨论，重点解析其中提到的关键知识点，包括算法基础、常用及高级数据结构、递归与回溯、排序算法、深度与广度优先搜索、动态规划、二分搜索与贪婪算法以及...
力扣高频|算法面试题汇总(三）：数组
qq_24739717的博客
04-23 884
力扣高频|算法面试题汇总(三）：数组 力扣链接 目录： 1.乘积最大子数组 1.乘积最大子数组 给你一个整数数组 nums ，请你找出数组中乘积最大的连续子数组（该子数组中至少包含一个数字）。 示例 1: 输入: [2,3,-2,4] 输出: 6 解释: 子数组 [2,3] 有最大乘积 6。 示例 2: 输入: [-2,0,-1] 输出: 0 解释: 结果不能为 2, 因为 [-2,-1] ...
Leetcode（力扣）超高频题讲解（三）
立志成为一个前端、后端、测试全方位发展的程序员
02-08 577
高频题(三) 目录： Leetcode（力扣）超高频题讲解（一） Leetcode（力扣）超高频题讲解（二） 文章目录高频题(三)一、螺旋矩阵II(59)二、螺旋矩阵(54)三、岛屿的最大面积(695)四、岛屿数量(200)五、反转链表II(92)六、用栈实现队列(232)七、用队列实现栈(225)1. 两个队列2. 一个队列八、二叉树的右视图(199)1. BFS2. DFS九、链表中倒数第K个节点(剑指Offer22)十、链表的中间节点(876)1. 奇数返回中点，偶数返回上中点2. 奇数返回中点，偶数
Leetcode（力扣）超高频题讲解（一）
立志成为一个前端、后端、测试全方位发展的程序员
01-21 1249
高频题(一) 文章目录高频题(一)一、反转链表(206)1. 双指针迭代2. 递归二、无重复字符的最长字串(3)三、LRU缓存机制(146)1. 题目描述2. LRU算法的介绍3. 数据结构的选择4. 代码实现四、数组中的第k个最大元素(215)1. 快排变形2. 大顶堆五、K个一组翻转链表(25)六、两数之和(1)1. 一遍哈希表2. 两遍哈希表七、三数之和(15)八、环形链表II(142)1. 哈希表2. 快慢指针九、环形链表(141)1. 哈希表2. 快慢指针十、合并两个有序链表(21)1. 递归2.
Leetcode力扣常考高频题-字符串
luy0710的博客
04-06 277
考察频率由两部分组成： Leetcode100题 面试考察频率（https://codetop.cc/#/home）表格中默认超过30次即为高频题 题号 难度 题目描述 解法 考察频率 3 中等 最长不重复子串 哈希表记录字符上次出现位置 Leetcode100+高频 5
Leetcode力扣常考高频题-树
luy0710的博客
04-06 186
考察频率由两部分组成： Leetcode100题 面试考察频率（https://codetop.cc/#/home）表格中默认超过30次即为高频题 题号 难度 题目描述 解法 考察频率 94 中等 二叉树的中序遍历 1、递归 2、栈 Leetcode100+高频 96
Leetcode力扣常考高频题-其它
luy0710的博客
04-06 268
考察频率由两部分组成： Leetcode100题 面试考察频率（https://codetop.cc/#/home）表格中默认超过30次即为高频题 题号 难度 题目描述 解法 考察频率 31 中等 找到n个元素的下一个排列方式 找规律 Leetcode100 36
2018年力扣高频算法面试题1数学&位运算
会哭的孩子有奶喝
06-11 287
目录友链1、只出现一次的数字2、直线上最多的点数【需二刷】3、分数到小数【需二刷】4、阶乘后的零5、缺失数字6、3的幂7、颠倒二进制位【需二刷】Sum of Two Integers 友链 2018年力扣高频算法面试题汇总 题解参考-github1 题解参考-github2 1、只出现一次的数字 给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。 要求：线性时间复杂度、不使用额外空间 解答：典型的位运算，相同的两个数异或为0，扩展形式为，找出给定
Leetcode 高频考题整理
qq_41605114的博客
03-06 1797
You can＇t always get what you want But if you try sometimes well you just might find You get what you need ——The Rolling Stones 《Let it Bleed》 目录 链表 树 各大排序 滑动窗口 Hash Hash + 滑动窗口 回溯算法 双指针 DFS/BFS 二分 归并/数学 动态规划 背包问题 完全背包 栈 其他 链表 92. .
1.两数之和（力扣leetcode） 博主可答疑该问题
qq_40262372的博客
01-23 188
一、笔记部分 思路：1.看见数组还是无序的，那么就应想到排序试试，然后排完发现，砸门直接用双指针或者二分查找就可以找出他的和了。总的数减去最小值，二分查找另一个。 想要更NB 查找。那只剩下哈希表了。 将每个数的映射到Hashmap中。Hashmap原理红黑树+链表+数组 1.查谁就把谁设置为key，这样好获取 2.找到了直接返回，因为题目中说了只要一个的。所以根本不需要数组去解决 3.如果没有没有找到差值，那么之前的数组没有合适的，所以就压入，期待下一次来的数可以查询到。 秀的.
leetcode高频100题java
06-28
leetcode高频100题java是指LeetCode网站上的100道经典算法题目，使用Java语言进行解答。这些题目涵盖了各种算法和数据结构，包括数组、链表、树、图、排序、查找、动态规划等等。这些题目是程序员面试和算法学习的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值