TESE_yan的博客

力扣地址

力扣地址对称二叉树性质：左右子树值相等或者都为空左子树的左子树（即LL）的值等于右子树的右子树（即RR）的值左子树的右子树（即LR）的值等于右子树的左子树（即RL）的值/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), le

力扣地址二分查找：class Solution {public: int search(vector<int>& nums, int target) { if (!nums.size()) return 0; int low = 0; int high = nums.size() - 1; int pivot; while (low <= high) { p

力扣地址

力扣地址输入的数字代码需要打印的位数，当前位数的最大值则全部是 9，先用10来进位，最后减一则是当前位数的最大值class Solution {public: vector<int> printNumbers(int n) { int res = 10; for (int i = 1; i < n; ++i) { res = res * 10; } vector&l

力扣地址摩尔投票法：用变量 votes 记录变量 mode 的票数，当票数为 0 时，mode 更新为当前值当前值与 mode 不相等，则将 votes 减一class Solution {public: int majorityElement(vector<int>& nums) { int mode = 0; int votes = 0; for (int n : nums) { if

力扣地址用两个栈去接受数据，其中一个栈在入栈时，只更新比他小的值，这样保证栈顶最小，在出栈时，比较两个栈的栈顶元素，相同一起出栈，代码用 vector 模拟栈class MinStack {public: /** initialize your data structure here. */ MinStack() { } void push(int x) { s1.push_back(x); if (s2.empty

力扣地址典型链表题目判断第一个节点是不是符合要求的，如果是，直接返回下一个节点，不是，则需要 pre 和 cur 变量来控制/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public:

力扣地址直接使用gcc内建函数：class Solution {public: int hammingWeight(uint32_t n) { return __builtin_popcount(n); }};自己写判断方法一：逐个移位判断class Solution {public: int hammingWeight(uint32_t n) { int cnt = 0; while (n) {

力扣地址递归：将左右子树递归调换即可实现镜像/*** 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*

力扣地址移位：因为C++负数移位会报错，所以在与之前将负数转换为 unsigned int 类型class Solution {public: int add(int a, int b) { return b == 0 ? a : add(a^b, (unsigned int)(a&b) << 1); }};...

力扣地址使用队列，开始入队前，判断当前队列长度，作为接下来需要打印的节点数量/** * 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 {

力扣地址排序+遍历：判断条件：最大最小值相差不超过4，且其中除了 0 之外不能有重复class Solution {public: bool isStraight(vector<int>& nums) { sort(nums.begin(), nums.end()); int joker = 0; for (int i = 0; i < nums.size() - 1; ++i) { i

力扣地址最近公共祖先，就是同时包含两个节点，且离得最近的，其中包括自己包含另一个节点递归：通过递归判断当前节点是否就是我需要判断的节点，如果是则返回 true，且一路返回，包含这个节点的父节点也为 true ，通过左右两个变量来判断当前节点是否就是我需要的节点/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNo

力扣地址递归：中序反向遍历，先遍历右子树，再遍历左子树，因为中序正向遍历时得到的二叉搜索树的结果集是升序数组，反向则是降序，符合题目的第k大的节点/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), rig

力扣地址后序遍历/** * 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: bool isBalanced(Tr

力扣地址约瑟夫环问题：用数组模拟约瑟夫环：（力扣超时，牛客可以通过，主要力扣输入的n和m都太大了）主要有一个数组和三个变量数组 visit 表示是否被访问过cur 表示当前真实走过的位置step 表示值拜访过的步数record 表示当前拜访了多少个class Solution {public: int lastRemaining(int n, int m) { vector<bool> visit(n, false);

力扣地址双指针class Solution {public: vector<int> exchange(vector<int>& nums) { int left = 0, right = nums.size() - 1; while (left < right) { if ((nums[left] & 1) != 0) { ++left;

力扣地址双指针class Solution {public: vector<int> twoSum(vector<int>& nums, int target) { int left = 0, right = nums.size() - 1; int res = nums[left] + nums[right]; while (left < right) { if (res ==

力扣地址

力扣地址切片class Solution {public: string reverseLeftWords(string s, int n) { return s.substr(n) + s.substr(0, n); }};

力扣地址用deque维持单调递减队列deque中存入数组位置class Solution {public: vector<int> maxSlidingWindow(vector<int>& nums, int k) { deque<int> dq; vector<int> res; for (int i = 0; i < nums.size(); ++i) {

力扣地址双指针class Solution {public: void insertVec(vector<vector<int>>& ret, int low, int high) { vector<int> tmp; tmp.reserve(high - low + 1); for (int i = low; i <= high; ++i) { tmp.push_

力扣地址二分查找：class Solution {public: int minArray(vector<int>& numbers) { int low = 0, high = numbers.size() - 1; while (low < high) { int mid = (low + high) >> 1; if (numbers[mid] < numbe

力扣地址递归：/** * 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: int maxDepth(TreeNo

力扣地址题目描述有点问题，每个数字都在范围0～n之内，而不是0～n-1遍历：缺失的中间部分class Solution {public: int missingNumber(vector<int>& nums) { int len = nums.size(); if (nums[0] != 0) return 0; if (nums[len - 1] != len) return len;

力扣地址递归：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: vector<int> reversePrint(ListNode* head) {

力扣地址小顶堆：利用的就是堆排序的性质，只给k个数排序class Solution {public: void MinHeapSort(vector<int>& arr, int index, int end) { int parent = index; int child = (parent << 1) + 1; while (child <= end) { if (chi

力扣地址斐波那契数列：这题和青蛙跳台阶-2初始值稍有不同，需要审题清楚，状态转移方程是一样的class Solution {public: int fib(int n) { if (n <= 1) return n; int first = 0; int second = 1; int thrid; for (int i = 2; i <= n; ++i) { th

力扣地址哈希表：class Solution {public: char firstUniqChar(string s) { int len = s.size(); unordered_map<char, int> res; for (auto c : s) { res[c] += 1; } for (auto c : s) { if (res[c]

力扣地址双指针法：两个指针把两个链表都走一遍，必定在重合点相遇/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode* getIntersectionNode(

力扣地址斐波拉数列问题：f(n) = f(n - 1) + f(n - 2)class Solution {public: int numWays(int n) { if (0 == n || 1 == n) return 1; if (2 == n) return 2; int first = 1, second = 2; int third; for (int i = 3; i <=n; ++i

力扣地址按层模拟：难点在于边界问题需要有一行贯穿上下或者左右边界，担心类似 3 * 3 内圈只有一个的数组类型当只剩一列时，需要注意左右是否重复，因为可能是同一列，所以需要判断 left < right当只有一行时，需要注意上下是否重复，因为可能是同一行，所有需要判断 top < bottomclass Solution {public: vector<int> spiralOrder(vector<vector<int>>

力扣地址归并法：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {

力扣地址快慢指针：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode* getKthFromEnd(ListNode* head, int k) {

力扣地址双栈法：/** * Your CQueue object will be instantiated and called as such: * CQueue* obj = new CQueue(); * obj->appendTail(value); * int param_2 = obj->deleteHead(); */class CQueue {public: CQueue() { } void appendTail(i

力扣地址动态规划：/*转移方程： 若 dp[i-1] ≤0 ，说明 dp[i - 1] 对 dp[i] 产生负贡献，即 dp[i-1] + nums[i] 还不如 nums[i] 本身大。当 dp[i - 1] > 0 时：执行 dp[i] = dp[i-1] + nums[i];当 dp[i - 1] ≤ 0 时：执行 dp[i] = nums[i];由于 dp[i] 只与 dp[i-1] 和 nums[i] 有关系，因此可以将原数组 nums 用作 dp 列表，即直接在 nu

力扣地址哈希法（数组替代）class Solution {public: int findRepeatNumber(vector<int>& nums) { int len = nums.size(); vector<int> res(len, 0); for (int n : nums) { ++res[n]; if (res[n] > 1) {

循环法：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode* reverseList(ListNode* head) { ListNode* pre