数据结构----二叉树遍历

二叉树的多种遍历方式的递归和非递归方法

```c++
#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
#include<stack>
using namespace std;


class node {//二叉树的数据结构 数据域val 左孩子指针 右孩子指针
public:
	int val;
	node* left;
	node* right;
};

vector<int> preOrderTraverseByRa(node* head) {//先序遍历
	vector<int> v;
	if (head) {
		v.push_back(head->val);
		preOrderTraverseByRa(head->left);
		preOrderTraverseByRa(head->right);
	}
	return v;
}

vector<int> inOrderTraverseByRa(node* head) {//中序遍历
	vector<int> v;
	if (head) {
		inOrderTraverseByRa(head->left);
		v.push_back(head->val);
		inOrderTraverseByRa(head->right);
	}
	return v;
}

vector<int> postOrderTraverseByRa(node* head) {//后序遍历
	vector<int> v;
	if (head) {
		postOrderTraverseByRa(head->left);
		postOrderTraverseByRa(head->right);
		v.push_back(head->val);
	}
	return v;
}

vector<vector<int>> levelOrderTraverse(node* head,int level) {//层序遍历 非递归
	vector<vector<int>> v;
	queue<node*> q;
	if (head) {
		q.push(head);
		while (!q.empty()) {
			int curLevelSize = 0;
			v.push_back(vector<int>());
			for (int i = 0; i < curLevelSize; i++) {
				node* Node = q.front(); q.pop();
				v.back().push_back(Node->val);
				if (Node->left) q.push(Node->left);
				if (Node->right) q.push(Node->right);
			}
		}
	}
	reverse(v.begin(), v.end());
	return v;
}

vector<int> preOrderTraverse(node* head) {//前序遍历
	vector<int> v;
	if (head) {
		stack<node*> s;
		s.push(head);
		while (!s.empty()) {
			head = s.top();
			s.pop();
			v.push_back(head->val);
			if (head->right) s.push(head->right);
			if (head->left) s.push(head->left);
		}

	}
	return v;
}

vector<int> preOrderTraverse(node* head) {//先序遍历
	vector<int> v;
	if (head) {
		stack<node*> s;
		s.push(head);
		while(!s.empty()) {
			head = s.top();
			s.pop();
			v.push_back(head->val);
			if (head->right) s.push(head->right);
			if (head->left) s.push(head->left);
		}
	}
	return v;
}


vector<int> inOrderTraverse(node* head) {//中序遍历
	vector<int> v;
	if (head) {
		stack<node*> s;
		while (!s.empty() || head) {
			if (head) {
				s.push(head);
				head = head->left;
			}
			else {
				head = s.top();
				s.pop();
				v.push_back(head->val);
				head = head->right;
			}	
		}
	}
	return v;
}

vector<int> posOrderTreverse(node* head) {//后序遍历
	vector<int> v;
	if (head) {
		stack<node*> s;
		s.push(head);
		while (!s.empty()) {
			head = s.top();
			s.pop();
			v.push_back(head->val);
			if (head->right) s.push(head->right);
			if (head->left) s.push(head->left);
		}
	}
	return v;
}

int mian() {



	return 0;
}```