看看世界看看你

void M_generate(string item,int left, int right, vector<string>& result){ if (left == 0 && right == 0) { result.push_back(item); return; } if (left > 0) M_generate(item + "(", left - 1, right, result); if (left < right) M_gener.

void addAllGroups(int i, vector<int>& nums,vector<int>&item,vector<vector<int>>& result){ if (i >= nums.size()) return; item.push_back(nums[i]); result.push_back(item); addAllGroups(i + 1, nums,item, result); i.

/** * 弹出k个元素，使得当前数组中的数最小 */string removeKdigits(string numbers, int k){ string result; vector<int> myStack; for (int i = 0; i < numbers.length();i++) { int number = numbers[i] - '0'; while (myStack.size() && myStack[myStack.si.

/** 孩子分糖果贪心算法g表示孩子的满足度s表示糖果的威力*/int findContentChildren(vector<int>& g, vector<int>& s){ std::sort(g.begin(), g.end(), [](int& a, int& b) {return a < b; }); std::sort(s.begin(), s.end(), [](int& a, int& b) {re.

/** * 加汽油游戏，计算从起点至终点最少需要加几次油 L 表示起点到终点的距离 P 表示起点的油量 stop中 first保存的是该汽油站距离终点的距离，second保存的是该汽油站的油量 */#include <queue>int calMinGasUp(int L, int P, vector<pair<int, int>>& stop){ int result = 0; priority_queue<int, vector&l.

/** * 射击气球 */int calShootBoolen(vector<pair<int, int>>& data){ if (data.size() < 2) return 1; std::sort(data.begin(), data.end(), [](auto&a, auto&b)->bool {return a.first < b.first; }); int shootNum = 1; int shoo.

采用两个变量记录pre和cur,贪心规则是当前无法到达下一个点时,再进行操作/**跳跃游戏2 * 计算跳跃的最小次数 */int calcJumpNums(vector<int> nums){ if (nums.size() < 2) { return 0; } int curMaxIndex = nums[0]; int preMaxIndex = nums[0]; int jumpMin = 1;//注意这个初始值是1 for (int i = 1; i.

通过构建当前位置可以到达的位置来更新最大值索引，如果走完之后可以走到终点，那么就可以，否则就是不可以。/** * 跳跃游戏 */bool judgeIsGoEnd(vector<int> nums){ vector<int> jumpIndex; //构建最大索引跳跃集合 for (int i = 0; i < nums.size(); i++) { jumpIndex.push_back(i + nums[i]); } int maxIndex..

原理分析快速排序（冒泡排序的升级版）快速排序原理分析：先选出一个基准元素（pivot），将数组变为基准元素左边的元素都比基准元素小，基准元素右边的元素都比基准元素大。我们下面将基准元素选择为数组最左边的元素。为了容易理解：我们可以认为是将基准元素进行挖空的操作，然后找到该位置适合填入的元素，从最右边开始往左找找出一个小于基准元素。然后将该元素填入到基准元素的位置，现在基准元素空出来，多了一个相同元素的较大值，那么我们再从左往右进行查找，看是否能找到一个大于基准元素的值来填补到空缺的那个位置上。这样一个

https://github.com/youngyangyang04/leetcode-master

一共三种状态，只有表现出折线图的节点才是符合摇摆队列的概念。//贪心算法之状态机转换int wiggleMaxLength(std::vector<int>& nums){ if (nums.size() == 1) return 1; if (nums.size() == 2) return 2; //状态 static const int BEGIN = 0; static const int UP = 1; static const int DOWN =

解题思路是：将节点先搬移至需要逆序的节点处，记录偏转起始点（为逆序后尾节点），偏转起始点的前一个节点。然后，开始逆序节点。最后，将四个节点连接。如果是从1号节点开始的话，那么不需要连接前面的节点。//翻砖链表的m->n个元素,m从0开始struct ListNode{ int val; ListNode* next = NULL; ListNode(int val) :val(val) {}};//从某个位置翻砖链表 ListNode* reverseBetween(Lis

链表逆序操作：步骤如下：首先先记住当前节点的下一个节点的位置，因为如果将该节点插入至新节点，需要改变它的next指向然后，将当前节点的next指向newhead指向的节点最后，将newhead指向当前节点，并将head节点遍历至下一个节点。//链表逆序操作ListNode* reverseList(ListNode* head){ ListNode* newHead = NULL; while (head) { ListNode* next = head->next;

维护一个最小堆和一个最大堆，平衡两个堆的个数，两种情况：最大堆比最小堆个数多 1最大堆和最小堆个数相同如果个数相等，返回两个数的平均值。如果最大堆比最小堆个数多1，那么返回最大堆的堆顶元素即为中位数。通过下面代码就可以实现：//寻找中位数double findMedian(vector<int>& data){ if (data.size() == 0) { return -1; } priority_queue<int, vector<i

class Solution{public: int findKthLargest(vector<int>& res, int k) { priority_queue<int, vector<int>, greater<int>> smallHeap; for (auto& i : res) { if (smallHeap.size() < k) { smallHeap.push(i); }

class Solution2: def IsPopOrder(self, pushV, popV): stack = [] for i in range(len(pushV)): stack.append(pushV[i]) while len(stack) and stack[-1] == popV[0]: stack.pop() popV.pop(0)

#返回栈内最小元素class Solution1: def __init__(self): self.stack = [] self.min = None self.minStack = [] def push(self, val): self.stack.append(val) if self.min is None: self.min = val if self.m

二叉树的前序、中序、后序遍历需要用到数据结构栈。下面给出一种统一写法：下面是中序遍历的写法：class Solution2: def midOrder(self, root): stack = [root] res = [] while stack: s = stack.pop() if type(s) is Node: if s.right: .