#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);
}