2020.05.08之算法:二叉樹基礎代碼的練習

三種遍歷，求後驅與前驅，判斷二叉搜索樹，判斷二叉平衡樹，判斷完全二叉樹，求完全二叉樹的個數

#include <iostream>
#include <vector>
#include <stack>
#include <math.h>
#include <algorithm>
#include <queue>
using namespace std;

struct Node{
	Node *left=NULL;
	Node *right=NULL;
	int val;
	Node(int val) :left(NULL), right(NULL), val(val) {}
};
vector<int> preorder(Node* root) {
	vector<int> res;
	if (root == NULL) {
		return res;
	}
	stack<Node*> s;
	s.push(root);
	while (!s.empty()) {
		root = s.top();
		s.pop();
		res.push_back(root->val);
		if (root->right) {
			s.push(root->right);
		}
		if(root->left) {
			s.push(root->left);
		}
	}
	return res;
};
vector<int> Inoreder(Node* root) {
	vector<int> res;
	if (root == NULL) {
		return res;
	}
	stack<Node*> s;
	while (!s.empty() || root != NULL) {
		while (root != NULL) {   //直接求root本身
			s.push(root);
			root = root->left;
		}
		root = s.top();
		s.pop();
		res.push_back(root->val);
		root = root->right;
	}
	return res;
}
//記住主要是判斷當前root

vector<int> afterorder(Node* root) {
	vector<int> res;
	if (root == NULL) {
		return res;
	}
	stack<Node*> s;
	stack<int> sres;
	s.push(root);
	while (!s.empty()) {
		root = s.top();
		s.pop();
		sres.push(root->val);
		if (root->left) {
			s.push(root->left);
		}
		if (root->right) {
			s.push(root->right);
		}
	}
	while (!sres.empty()) {
		res.push_back(sres.top());
		sres.pop();
	}
	return res;

}


//後繼者
struct TreeNode
{
	TreeNode *parent;
	TreeNode *left;
	TreeNode *right;
	int val;
	TreeNode(int val) :val(val), parent(NULL), left(NULL), right(NULL) {}
};
TreeNode* first(TreeNode*p) {
	while (p->left != NULL) {
		p = p->left;
	}
	return p;
}
TreeNode * Successor(TreeNode* root, TreeNode *p) {
	//分爲兩種情況
	//1.p結點有右子樹
	if (p->right != NULL) {
		return first(p->right);
	}
	else {
		TreeNode* parent = p->parent;
		while (parent!=NULL&&parent->left != p) {
			p = parent;
			parent = p->parent;
		}
		return parent;
	}
}

vector<TreeNode*> inoreder(TreeNode* root) {
	vector<TreeNode*> res;
	if (root == NULL) {
		return res;
	}
	stack<TreeNode*> s;
	while (!s.empty() || root != NULL) {
		while (root != NULL) {   //直接求root本身
			s.push(root);
			root = root->left;
		}
		root = s.top();
		s.pop();
		res.push_back(root);
		root = root->right;
	}
	return res;
}
//沒有父節點的情況下
TreeNode* inorderSuccessor(TreeNode* root, TreeNode* p) {
	vector<TreeNode*> inordernum = inoreder(root);
	int sz = inordernum.size();
	for (int i = 0; i<sz; i++) {
		if (inordernum[i] == p) {
			if (i == sz - 1) {
				return NULL;
			}
			else {
				return inordernum[i + 1];
			}
		}
	}
	return NULL;
}
TreeNode* first1(TreeNode* p) {
	while (p->right != NULL) {
		p = p->right;
	}
	return p;
}

//前驅結點
TreeNode* Successor1(TreeNode* root, TreeNode *p) {
	//分爲兩種情況
	//1.p結點有左子樹
	if (p->left != NULL) {
		return first1(p->left);
	}
	else {
		TreeNode* parent = p->parent;
		while (parent != NULL&&parent->right != p) {
			p = parent;
			parent = p->parent;
		}
		return parent;
	}
}

//判斷一棵樹是否是平衡二叉樹
int TreeNodeHeight(TreeNode* root) {
	if (root == NULL) {
		return 0;
	}
	return max(TreeNodeHeight(root->left), TreeNodeHeight(root->right)) + 1;
}
bool isBalanced(TreeNode* root) {
	if (root == NULL) {
		return true;
	}
	else {
		if(abs(TreeNodeHeight(root->left)-TreeNodeHeight(root->right))>1){
			return false;
		}
		else {
			return isBalanced(root->left) && isBalanced(root->right);
		}
	}
}

//判斷是否是一個BST

bool isValidBST(TreeNode* root) {
	//特性就是二叉搜索樹的中序遍歷是一個遞增的數組
	if (root == NULL) {
		return true;
	}
	stack<TreeNode*> s;
	TreeNode * pre = NULL;
	int i = 0;
	while (!s.empty() || root != NULL) {
		while (root != NULL) {
			s.push(root);
			root = root->left;
		}
		root = s.top();
		s.pop();
		if (pre != NULL&&pre->val >= root->val) return false;
		pre = root;
		root = root->right;
	}

}
//判斷CST
bool isCompleteTree(TreeNode* root) {
	if (root == NULL) {
		return true;
	}
	queue<TreeNode*> qt;
	qt.push(root);
	bool state = false;
	TreeNode* l;
	TreeNode* r;
	while (!qt.empty()) {
		root = qt.front();
		qt.pop();
		l = root->left;
		r = root->right;
		if ((state && (l != nullptr || r != nullptr)) || (l == nullptr && r != nullptr)) return false;
		if (l != nullptr) {
			qt.push(l);
		}
		if (r != nullptr) {
			qt.push(r);
		}
		else {
			state = true;
		}
		
	}
	return true;
		
}

//求完全二叉樹的個數
//第一步要求出高度，這個完全二叉樹的高度
//再查看下右子樹是不是等於這個高度
int CTSHeight(TreeNode * root,int level) {
	//int level = 0;
	while(root != nullptr) {
		level++;
		root = root->left;
	}
	return level-1;
}
int bs(TreeNode* root, int l, int h) {
	if (l == h) {
		return 1;
	}
	if (CTSHeight(root->right, l + 1) == h) {
		return (1 << (h - l)) + bs(root->right, l + 1, h);
	}
	else {
		return(1 << (h - l-1)) + bs(root->left, l + 1, h);
	}

}
int countNodes(TreeNode* root) {
	if (root == nullptr) {
		return 0;
	}
	return bs(root, 1, CTSHeight(root, 1));
}