DayTwentyTwo 依旧是笔记呀

今天用到的数据结构

//如果可以的话，尽量使用pair替代简单的结构体，方便使用，且pair在排序的时候，会自动按照first域进行排。
struct ListNode
{
	int val;
	ListNode* next;
	ListNode(int x) : val(x), next(NULL){}
};

struct TreeNode
{
	int val;
	TreeNode* left;
	TreeNode* right;
	TreeNode(int x) : val(x), left(NULL), right(NULL){}
};

加法模拟

	vector<int> plusOne(vector<int>& digits) {
		int t = 1;//这里的t为加数。加一 t = 1，加n t = n
		for (int i = digits.size() - 1; i >= 0; i--)
		{
			digits[i] += t;
			t = digits[i] / 10;
			digits[i] %= 10;
		}
		if (t)
		{
			digits.push_back(0);
			for (int i = digits.size() - 2; i >= 0; i--)
				digits[i + 1] = digits[i];
			digits[0] = 1;
		}
		return digits;
	}

给出一种二维vector数组的定义方法（第二维可以不是bool 且在定义时，如果不指定，程序会自动将bool值置为false）

vector<vector<bool>> st(n, vector<bool>(m, false));

翻转链表

	ListNode* reverseList(ListNode* head)
	{
		ListNode* pre = nullptr;
		auto cur = head;
		while (cur) {
			auto next = cur->next;
			cur->next = pre;
			pre = cur;
			cur = next;
		}
		return pre;
	}

合并链表

ListNode* merge(ListNode* l1, ListNode* l2)
	{
		auto dummy = new ListNode(-1);
		auto cur = dummy;
		while (l1 && l2)
		{
			if (l1->val < l2->val) {
				cur->next = l1;
				cur = l1;
				l1 = l1->next;
			}
			else {
				cur->next = l2;
				cur = l2;
				l2 = l2->next;
			}
		}
		if (l1) cur->next = l1;
		else cur->next = l2;
		return dummy->next;
	}

获取传入整数的每一位的和 例如 传入 23 返回 2 + 3

int get_single_sum(int x)
	{
		int s = 0;
		while (x) s += x % 10, x / 10;
		return s;
	}

	int get_sum(pair<int, int> p)
	{
		return get_single_sum(p.first) + get_single_sum(p.second);
	}

一个可以返回当前栈最小值的实现

class MinStack {
public:
	stack<int> stkValue;
	stack<int> stkMin;
	/** initialize your data structure here. */
	MinStack() {

	}

	void push(int x) {
		stkValue.push(x);
		if (stkMin.empty() || stkMin.top() >= x)stkMin.push(x);
	}

	void pop() {
		if (stkValue.top() == stkMin.top())stkMin.pop();
		stkValue.pop();
	}

	int top() {
		return stkValue.top();
	}

	int getMin() {
		return stkMin.top();
	}
};