weixin_42684313的博客

给定一个整数 n，生成所有由 1 … n 为节点所组成的 二叉搜索树 。方法：递归（递归的精髓：假定子问题已经获取了正确解）

TreeNode* invertTree(TreeNode* root) { if (root == NULL) return NULL; TreeNode* tmp=root->left; root->left = root->right; root->right = tmp; invertTree(root->left); invertTree(root->right);}

递归bool isSameTree(TreeNode* p, TreeNode* q) { if (p == NULL && q == NULL) return true; if (p == NULL && q != NULL) return false; if (p != NULL && q == NULL) return false; return (p->val == q->val) && isSameTree(p

TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) { int N = postorder.size(); if (postorder.size() == 0 || inorder.size() == 0) return NULL; int root = postorder[N-1]; //找到树根 TreeNode* node = new TreeNode(root); v

class Solution {public: bool isSymmetric(TreeNode* root) { if (root == NULL) return false; return isSymmetric3(root->left, root->right); } //递归函数写成左右孩子的形参 bool isSymmetric2(TreeNode* p, TreeNode* q) { if (p == NULL && q == NULL) re

struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {}};vector<vector<int>> levelOrder(TreeNode* root) { vector<vector<int>> res; std::queue<TreeNode*> queue

这道题难点，是找到那两个交换节点，把它交换过来就行了。这里我们二叉树搜索树的中序遍历(中序遍历遍历元素是递增的)class Solution { TreeNode firstNode = null; TreeNode secondNode = null; TreeNode preNode = new TreeNode(Integer.MIN_VALUE); public void recoverTree(TreeNode root) { in_orde

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。分别用递归和迭代。

vector<vector<int>> zigzagLevelOrder(TreeNode* root) { vector<vector<int>> res; if (root == NULL) return res; queue<TreeNode*> q; q.push(root); int level = 0; while (!q.empty()) { int n = q.size(); deque<i

树的很多问题都可以用递归解决。int maxDepth(TreeNode* root) { if (root == NULL) return 0; int left = maxDepth(root->left); int right = maxDepth(root->right); return max(left, right) + 1; }

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

#第一次一遍过，噢耶，虽然还有很多需要优化的地方TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) { if (preorder.size() == 0 || inorder.size() == 0) return NULL; int root = preorder[0]; //找到树根 TreeNode* node = new TreeNode(root); vecto

struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {}};二叉树的中序遍历##二叉树的中序遍历class Solution {public: //递归 vector<int> inorderTraversal(TreeNode* root) { if (root) { inorderTrave

链表类的题都是那几步比如断链、接链、反转、排序的操作而已。难题也只不过是简单题的组合或者几个简单的思路的组合而已。ListNode* reverseKGroup(ListNode* head, int k) { if (!head || !head->next || k == 1) return head; ListNode *dummyhead = new ListNode(-1); // 虚拟头节点 dummyhead->next = head; ListNode *pos = d

链表双指针经典题目//我的解答 struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; ListNode* removeNthFromEnd(ListNode* head, int n) { if (head == NULL) return NULL; //边界条件判定 ListNode* fast = head; ListNode* slow

对链表进行插入，归并，快速排序

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) { if(l1==nullptr) return l2; if(l2==nullptr ) return l1; ListNode* head=new ListNode(-1); //构造头节点 ListNode* tmp=head; while(l1!=nullptr || l2!=nullptr){

提示：1、hash表2、原地hash

class Solution {public: string convertToTitle(int n) { string ans = ""; while (n > 0) { n -= 1; //重点 ans.push_back('A' + (n % 26)); n /= 26; } reverse(ans.begin(), ans.end());

提示：查找target和查找target+1。

假设按照升序排序的数组在预先未知的某个点上进行了旋转。( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。你可以假设数组中不存在重复的元素。你的算法时间复杂度必须是 O(log n) 级别。必然二分。关键是判断进入那一侧进行继续搜索（提示：某一侧必定有序，数组可以通过下标直接取到开头，结尾等值）。...

实现获取下一个排列的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。必须原地修改，只允许使用额外常数空间。以下是一些例子，输入位于左侧列，其相应输出位于右侧列。1,2,3 → 1,3,23,2,1 → 1,2,31,1,5 → 1,5,1提示：找到第一个升序的位置，交换到正确的位置，再反转该位置后面的所有元素。...

在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。...

反转单词，逆序输出，至少应该想到用stack解决。#include<iostream>#include<set>#include<unordered_map>#include<stack>#include<algorithm>using namespace std;//双指针解法void reverse_world(string str) { int L = 0, R= 0; for (int i = 0; i < str

两个stack模拟Queue#include<iostream>#include<stack>#include<algorithm>class MyQueue {public: int pop_front() { if (!stack_out.empty()) { int value= stack_out.top(); stack_out.pop(); return value; } else { //最重要的一步，如果

典型的二维动态规划题目；状态转移方程：边界条件：dp[0][0]=grid[0][0];int minPathSum(vector<vector<int>>& grid) { if (grid.size() == 0 || grid[0].size() == 0) { return 0; } int rows = grid.size(), columns = grid[0].size(); vector<vector<int>>

双指针＋排序#define error INT_MAXint threeSumClosest(vector<int>& nums, int target) { int N = nums.size(); if (N < 3) return error; std::sort(nums.begin(), nums.end()); int mincut = nums[0] + nums[1] + nums[2]; for(int

排序+双指针vector<vector<int>> threeSum(vector<int>& nums) { vector<vector<int>> res; int N = nums.size(); if (N < 3) return res; //特殊情况判断 std::sort(nums.begin(), nums.end()); //排序，不然不能用首尾双指

string longestCommonPrefix(vector<string>& strs) { int N = strs.size(); if (N == 0) return ""; //特殊情况处理（关键） if (N == 1) return strs[0];//特殊情况处理 string prefix = strs[0]; //刚开始假设前缀就是第一个字符串 int end= prefix.size(); //前缀字符串的结尾下标 for (string&am

##一般的循环解法int romanToInt(string s) { int result=0; map<char,int> map={ {'I',1}, {'V',5}, {'X',10}, {'L',50}, {'C',100}, {'D', 500}, {'M', 1000}

class Solution { string intToRoman(int num) { // 把阿拉伯数字与罗马数字可能出现的所有情况和对应关系，放在两个数组中 // 并且按照阿拉伯数字的大小降序排列，这是贪心选择思想 vector<int> nums= { 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1 }; vector<string> romans= { "M", "CM", "D", "CD",

双指针经典题目。int maxArea(vector<int>& height) { int L = 0, R = height.size() - 1; int ans = 0; while (L < R) { int area = min(height[L], height[R]) * (R - L); ans = max(ans, area); if (height[L] <= height[R]) { //移动高度较低的一侧，才有可能获得比当前值大的

bool isMatchFromTailToHead1(string s, string p) { int m = s.length, n = p.length; // 这里dp矩阵是要大一圈的，用来处理s或者p为空串的情况，矩阵的行标i对应s的i-1，矩阵的列标j对应p的j-1 vector<vector<bool>> dp(m + 1, vector<bool>(n + 1)); // s和p都是空串的时候自然true dp[0][0] = true;

考察的是日常开发过程中繁琐的处理过程，重点是要条理清晰。//普通解法int myAtoi(string str) { unsigned long len = str.length(); // 去除前导空格 int index = 0; while (index < len) { if (str[index] != ' ') { break; }

这道题难度不大，但是对于考虑溢出的题型很有参考价值。int reverse(int x) { int m, res = 0; while (x != 0) { m = x % 10; //余数 x /= 10; //乘以10之前就进行判断，否则可能溢出 if (res > INT_MAX / 10 || (res == INT_MAX && m > 7)) return 0; if (res < INT_MIN / 10 || (res == IN

题目描述本题至少应该想到用一个二维数组存储结果，但是这样会造成很多空间浪费。string convert(string s, int numRows) { if (numRows == 1) return s; //特例判断，非常重要 vector<string> rows(min(numRows, int(s.size()))); //vector保存每一行的字符串 int curRow = 0; bool goingDown = false; //指定row应该向下增加还是向

动态规划算法核心是状态转移方程和边界条件。一般情况下，对于递推问题可以用递归解决，但是如果出现重复子结构，此时递归会造成时间复杂度剧增，可以采用备忘录算法（如hash表暂存）或者动态规划求解。此题的递推公式是：P(i,j)=P(i+1,j−1)&(S i==S j)边界条件是：P(i,i)=trueP(i,i+1)=(S i==S i+1)#include <iostream>#include<string>#include<vector&gt

double middle(vector<int> &nums) { //求中位数（很重要） int n = nums.size(); if (n == 0) return 0; if (n & 1) return nums[n / 2]; //奇数 return (nums[n / 2 - 1] + nums[n / 2]) / 2.0; //偶数}double findMedianSortedArrays(vector<int>& nums1

#include<iostream>#include<set>#include<unordered_map>#include<algorithm>using namespace std;class Solution {public: //用set（红黑树） int lengthOfLongestSubstring(string s) { std::set<char> set; int res = 0, left = 0,

我的解法：执行用时：40 ms, 在所有 C++ 提交中击败了30.19%的用户内存消耗：9.4 MB, 在所有 C++ 提交中击败了39.80%的用户ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) { ListNode* res = new ListNode(-1); ListNode* p1 = l1; ListNode* p2 = l2; ListNode* head = res; int sum=0;