每天一遍

#include <iostream>
#include<algorithm>
#include<vector>
#include<map>
#include<unordered_map>
#include<string>
#include<stack>
using namespace std;

struct TreeNode
{
	TreeNode(int n):val(n){}
	int val;
	TreeNode* left = nullptr;
	TreeNode* right = nullptr;
};


class Solution {
public:
	vector<int>preOrderTraversal(TreeNode* root)
	{
		vector<int>ans;
		if (root == nullptr) return ans;
		stack<TreeNode*>st;
		st.push(root);
		while (!st.empty())
		{
			TreeNode* temp = st.top();
			st.pop();
			ans.push_back(temp->val);
			if (temp->right)
				st.push(root->right);
			if (temp->left)
				st.push(root->left);
		}
		return ans;
	}




	vector<int>midOrderTraversal(TreeNode* root)
	{
		vector<int>ans;
		if (root == nullptr) return ans;
		stack<TreeNode*>st;
		TreeNode* p = root;
		while (!st.empty()||p)
		{
			if (p)
			{
				st.push(p);
				p = p->left;
			}
			else
			{
				TreeNode* temp = st.top();
				st.pop();
				ans.push_back(temp->val);
				p = temp->right;
			}
		}
		return ans;
	}

	class Solution {
public:
    
    vector<int> postorderTraversal(TreeNode* root)
	{
		vector<int>ans;
		if (root == nullptr) return ans;
		stack<TreeNode *>st;
		TreeNode *pre = nullptr;
		TreeNode* cur = root;
		st.push(cur);
		while (!st.empty())
		{
			cur = st.top();
			if ((cur->left == nullptr && cur->right == nullptr) || (pre != nullptr &&
				(pre == cur->left || pre == cur->right)))
			{
				st.pop();
				ans.push_back(cur->val);
				pre = cur;
			}
			else
			{
				if (cur->right)
					st.push(cur->right);
				if (cur->left)
					st.push(cur->left);
					
			}
		}
		return ans;
	}
    


};



template<typename T>
int partition(vector<T>&nums, int left, int right)
{
	int temp = nums[left];
	while (left<right)
	{
		while (left<right && nums[right]>=temp) right--;
		nums[left] = nums[right];
		while (left < right && nums[left] <= temp) left++;
		nums[right] = nums[left];
	}
	nums[left] = temp;
	return left;
}

template<typename T> 
void choose_mid(vector<T>&nums, int left, int right)
{
	if (left < right)
	{
		int mid = left + (right - left) / 2;
		if (nums[mid] > nums[right]) swap(nums[mid], swap[right]);
		if (nums[left] > nums[right]) swap(nums[left], nums[right]);
		if (nums[left] < nums[mid]) swap(nums[left], nums[mid]);
	}
	return;
}



template<typename T>
void quickSort(vector<T>&nums, int left, int right)
{
	if (left < right)
	{
		int mid = partition(nums, left, right);
		quickSort(nums, left, mid - 1);
		quickSort(nums, mid + 1, right);
	}
}

template<typename T>
void quickSort3(vector<T>&nums, int left, int right)
{
	if (left < right)
	{
		int temp = nums[left];
		int low = left;
		int i = low + 1;
		int high = right + 1;
		while (i<high)
		{
			if (nums[i] < temp)
			{
				swap(nums[i], nums[low+1]);
				low++;
				i++;
			}
			else if (nums[i] > temp)
			{
				swap(nums[i], nums[high - 1]);
				high--;
				
			}
			else
			{
				i++;
			}
		}
		swap(nums[left], nums[low]);
		quickSort3(nums, left, low - 1);
		quickSort3(nums, high, right);
	}
	return;
}

template<typename T>
void merge(vector<T>&nums, int L1, int R1, int L2, int R2)
{
	int i = L1, j = L2;
	int index = 0;
	vector<int>temp;
	while (i<=R1&&j<=R2)
	{
		if (nums[i] < nums[j])
		{
			temp.push_back(nums[i++]);
		}
		else
		{
			temp.push_back(nums[j++]);
		}
	}
	while (i<=R1)
	{
		temp.push_back(nums[i++]);
	}

	while (j<=R2)
	{
		temp.push_back(nums[j++]);
	}

	for (int n = 0; n < temp.size(); n++)
	{
		nums[L1 + n] = temp[n];
	}

}

template<typename T>
void mergeSort(vector<T>&nums,int left,int right)
{
	if (left < right)
	{
		int mid = left + (right - left) / 2;
		mergeSort(nums, left, mid);
		mergeSort(nums, mid+1, right);
		merge(nums, left, mid, mid+1, right);
	}
}

void adjust(vector<int>&nums,int len,int index)
{
	int left = index * 2 + 1, right = index * 2 + 2;
	int mid = index;
	if (left < len && nums[left] < nums[mid]) mid = left;
	if (right < len && nums[right] < nums[mid]) mid = right;
	if (mid != index)
	{
		swap(nums[mid], nums[index]);
		adjust(nums, len, mid);
	}
}

void heapSort(vector<int>&nums,int len)
{
	if (len == 0) return;
	for (int i = len / 2 - 1; i >= 0; i--)
	{
		adjust(nums, len, i);
	}
	swap(nums[0], nums[len-1]);
	heapSort(nums, len - 1);
}