关于树的一些基本算法

树是一种递归定义的数据结构，也是一种无向无环图。

树的非递归遍历

中序遍历
vector<int> inorderTraversal(TreeNode* root) {

vector<int> result;

if(root==NULL)

return result;;

stack<TreeNode *> s;

s.push(root);

TreeNode * _front;

bool flag=true;

while(!s.empty()){

_front=s.top();

while(flag && (_front->left!=NULL)){

s.push(_front->left);

_front=_front->left;

}

flag=false;

s.pop();

result.push_back(_front->val);

if(_front->right!=NULL){

s.push(_front->right);

flag=true;

}

}

return result;

}
前序遍历
vector<int> preorderTraversal(TreeNode *root) {

stack<TreeNode *> s;

vector<int> result;

if(root!=NULL){

s.push(root);

while(!s.empty()){

TreeNode * current=s.top();

s.pop();

result.push_back(current->val);

if(current->right!=NULL)

s.push(current->right);

if(current->left!=NULL)

s.push(current->left);

}

}

return result;

}

后序遍历
vector<int> postorderTraversal(TreeNode *root) {

stack<TreeNode *> s;

vector<int> result;

if(root!=NULL){

s.push(root);

while(!s.empty()){

TreeNode * current=s.top();

s.pop();

result.push_back(current->val);

if(current->left!=NULL)

s.push(current->left);

if(current->right!=NULL)

s.push(current->right);

}

}

reverse(result.begin(), result.end());

return result;

}
层序遍历
vector<vector<int>> levelOrder(TreeNode* root) {

if (!root) { return {}; }

vector<int> row;

vector<vector<int> > result;

queue<TreeNode*> q;

q.push(root);

int count = 1;

while (!q.empty()) {

if (q.front()->left) { q.push(q.front()->left); }

if (q.front()->right) { q.push(q.front()->right); }

row.push_back(q.front()->val), q.pop();

if (--count == 0) {

result.emplace_back(row), row.clear();

count = q.size();

}

}

return result;

}

二叉搜索树，从一个有序的链表创建一个p平衡二叉搜索树
TreeNode *sortedListToBST(ListNode *head)

{

return sortedListToBST( head, NULL );

}

private:

TreeNode *sortedListToBST(ListNode *head, ListNode *tail)

{

if( head == tail )

return NULL;

if( head->next == tail ) //

{

TreeNode *root = new TreeNode( head->val );

return root;

}

ListNode *mid = head, *temp = head;

while( temp != tail && temp->next != tail ) // 寻找中间节点

{

mid = mid->next;

temp = temp->next->next;

}

TreeNode *root = new TreeNode( mid->val );

root->left = sortedListToBST( head, mid );

root->right = sortedListToBST( mid->next, tail );

return root;

}

求path的和
vector<vector<int>> result;

void help(TreeNode *root,int num,int sum,vector<int> temp){

if(root==NULL)

return;

temp.push_back(root->val);

num+=root->val;

if(root->left==NULL && root->right==NULL){

if(num==sum)

result.push_back(temp);

}

else{

help(root->left,num,sum,temp);

help(root->right,num,sum,temp);

}

}

vector<vector<int> > pathSum(TreeNode *root, int sum) {

vector<int> temp;

int num=0;

help(root,num,sum,temp);

return result;

}

vector<vector<int>> result;

void help(TreeNode *root,int& num,int sum,vector<int>& temp){

if(root==NULL)

return;

temp.push_back(root->val);

num+=root->val;

if(root->left==NULL && root->right==NULL){

if(num==sum)

result.push_back(temp);

}

else{

help(root->left,num,sum,temp);

help(root->right,num,sum,temp);

}

num-=root->val;

temp.pop_back();

}

vector<vector<int> > pathSum(TreeNode *root, int sum) {

vector<int> temp;

int num=0;

help(root,num,sum,temp);

return result;

}
层序遍历
检查二叉排序树的有效性
int x=-100;

void f(TreeNode *root, bool& flag){

if(flag==false)

return;

if(root==NULL)

return;

f(root->left,flag);

if(x==-100){

x=root->val;

}

else{

if(flag==false) return;

flag=(root->val>x);

x=root->val;

}

f(root->right,flag);

}

bool isValidBST(TreeNode *root) {

bool flag=true;

f(root,flag);

return flag;

}

一个二叉树的最大深度

int maxDepth(TreeNode *root) {

if(root==NULL)

return 0;

return max(maxDepth(root->left),maxDepth(root->right))+1;

}

最大路径和

int maxnum=INT_MIN;

int f(TreeNode *root){

if(root==NULL)

return 0;

int l=f(root->left);

int r=f(root->right);

maxnum=max(max(l,0)+max(r,0)+root->val,maxnum);

return max(max(l+root->val,r+root->val),root->val);

}

int maxPathSum(TreeNode *root) {

if(root==NULL)

return 0;

f(root);

return maxnum;

}

拍平一个二叉树

TreeNode * p=NULL;

void f(TreeNode * root){

if(root==NULL)

return;

p->right=root;

p=p->right;

TreeNode * l=root->left;

TreeNode * r=root->right;

root->left=NULL;

f(l);

f(r);

}

void flatten(TreeNode *root) {

p=new TreeNode(0);

f(root);

}

算一个完全二叉树的节点数

int leftheight(TreeNode* root){

int h=0;

while(root){

root=root->left;

h++;

}

return h;

}

int rightheight(TreeNode* root){

int h=0;

while(root){

root=root->right;

h++;

}

return h;

}

int countNodes(TreeNode* root) {

if(root==NULL)

return 0;

if(root->left==NULL && root->right==NULL)

return 1;

if(root->left!=NULL && root->right==NULL)

return 2;

int l=leftheight(root->left);

int r=rightheight(root->right);

if(l==r) return pow(2,l+1)-1;

else return countNodes(root->left)+countNodes(root->right)+1;

}

转换一个有序链表到二叉排序树

TreeNode * f(ListNode *head, int length){

if(length==0)

return NULL;

else if(length==1)

return new TreeNode(head->val);

else{

ListNode * p=head;

for(int i=0;i<length/2-1;i++){

p=p->next;

}

TreeNode * root=new TreeNode(p->next->val);

root->right=f(p->next->next,length-1-length/2);

p->next=NULL;

root->left=f(head,length/2);

return root;

}

}

TreeNode *sortedListToBST(ListNode *head) {

int L=0;

for(ListNode * p=head;p!=NULL;p=p->next){

L++;

}

return f(head, L);

}

转换一个有序数组到二叉排序树

TreeNode *sortedArrayToBST(vector<int> &num) {

return sortedArrayToBST2(num,0,num.size()-1);

}

TreeNode *sortedArrayToBST2(vector<int> &num, int m, int n){

int size=n-m+1;

if(size==0){

return NULL;

}

else if(size==1){

TreeNode * a=new TreeNode(num[m]);

return a;

}

else if(size==2){

TreeNode * a=new TreeNode(num[m]);

TreeNode * b=new TreeNode(num[m+1]);

a->right=b;

return a;

}

else if(size==3){

TreeNode * a=new TreeNode(num[m]);

TreeNode * b=new TreeNode(num[m+1]);

TreeNode * c=new TreeNode(num[m+2]);

b->left=a;

b->right=c;

return b;

}

else{

TreeNode * a=new TreeNode(num[(m+n)/2]);

a->left=sortedArrayToBST2(num,m,(m+n)/2-1);

a->right=sortedArrayToBST2(num,(m+n)/2+1,n);

return a;

}

}

卡特兰数，生成多少二叉树

vector<TreeNode *> generateTrees(int n) {

return f(1,n);

}

vector<TreeNode *> f(int start, int end){

vector<TreeNode *> result;

if(start>end){

result.push_back(NULL);

return result;

}

for(int k=start;k<=end;k++){

vector<TreeNode *> left=f(start,k-1);

vector<TreeNode *> right=f(k+1,end);

for(int i=0;i<left.size();i++){

for(int j=0;j<right.size();j++){

TreeNode * root=new TreeNode(k);

root->left=left[i];

root->right=right[j];

result.push_back(root);

}

}

}

return result;

}

最小高度

int minDepth(TreeNode *root) {

if(root==NULL)

return 0;

if(root->left==NULL && root->right==NULL)

return 1;

else if(root->left==NULL && root->right!=NULL)

return minDepth(root->right)+1;

else if(root->left!=NULL && root->right==NULL)

return minDepth(root->left)+1;

else

return min(minDepth(root->left),minDepth(root->right))+1;

}

int level;

int result;

int minDepth(TreeNode *root) {

level++;

if(root==NULL){

}

else if(root->left==NULL && root->right==NULL){

if(result==0)

result=level;

else

result=min(level,result);

}

else{

minDepth(root->left);

minDepth(root->right);

}

level--;

return result;

}

判断一棵树是不是平衡二叉树

int height(TreeNode *root, bool & result){

if(root==NULL || result==false)

return 0;

int l=height(root->left, result);

int r=height(root->right, result);

if(abs(l-r)>1)

result=false;

return max(l,r)+1;

}

bool isBalanced(TreeNode *root) {

bool result=true;

height(root,result);

return result;

}

找一棵二叉搜素树的最近公共祖先

TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q){

if(p==root || q==root) return root;

switch((p->val > root->val)+(q->val > root->val)){

case 0:

return lowestCommonAncestor(root->left,p,q);

case 1:

return root;

case 2:

return lowestCommonAncestor(root->right,p,q);

}

}

判断一棵树是不是对称的

bool help(TreeNode * root0, TreeNode * root1){

if(root0==NULL && root1==NULL)

return true;

if(root0==NULL || root1==NULL)

return false;

return root0->val==root1->val && help(root0->left,root1->right) && help(root0->right,root1->left);

}

bool isSymmetric(TreeNode *root) {

if(root==NULL)

return true;

return help(root->left,root->right);

}

判断两棵树是不是一样的

bool isSameTree(TreeNode *p, TreeNode *q) {

if(p==NULL && q==NULL)

return true;

if(p==NULL || q==NULL)

return false;

return p->val==q->val && isSameTree(p->left,q->left) && isSameTree(p->right,q->right);

}

层序遍历

vector<vector<int> > levelOrder(TreeNode *root) {

vector<vector<int> > result;

if(root!=NULL){

deque<TreeNode *> queue;

queue.push_back(root);

vector<int> vec;

int size=1;

while(!queue.empty()){

if(queue.front()!=NULL){

vec.push_back(queue.front()->val);

if(queue.front()->left!=NULL)

queue.push_back(queue.front()->left);

if(queue.front()->right!=NULL)

queue.push_back(queue.front()->right);

queue.pop_front();

size--;

}

if(size==0){

size=queue.size();

result.push_back(vec);

vec.clear();

}

}

}

return result;

}

倒排的层序遍历

vector<vector<int> > levelOrderBottom(TreeNode *root) {

vector<vector<int> > result;

if(root!=NULL){

deque<TreeNode *> queue;

queue.push_back(root);

vector<int> vec;

int size=1;

while(!queue.empty()){

if(queue.front()!=NULL){

vec.push_back(queue.front()->val);

if(queue.front()->left!=NULL)

queue.push_back(queue.front()->left);

if(queue.front()->right!=NULL)

queue.push_back(queue.front()->right);

queue.pop_front();

size--;

}

if(size==0){

size=queue.size();

result.insert (result.begin(),vec);

vec.clear();

}

}

}

return result;

}

右向视图

vector<int> rightSideView(TreeNode *root) {

vector<int> result;

if(root==NULL)

return result;

int first=0;

int second=0;

queue<TreeNode*> Q;

Q.push(root);

first++;

while(!Q.empty()){

TreeNode *head=Q.front();

Q.pop();

first--;

//cout<<first<<endl;

if(head->left!=NULL){

Q.push(head->left);

second++;

}

if(head->right!=NULL){

Q.push(head->right);

second++;

}

if(first==0){

result.push_back(head->val);

first=second;

second=0;

}

}

return result;

}

实现字典树

class TrieNode {

public:

int bitmap;

vector<TrieNode *> children;

// Initialize your data structure here.

TrieNode() {

bitmap=0;

}

};

class Trie {

public:

Trie() {

root = new TrieNode();

}

// Inserts a word into the trie.

void insert(string word) {

TrieNode* temp=root;

for(int i=0;i<word.length();i++){

int offset=word[i]-'a';

int index=0;

int sum=0;

while(index<offset){

sum+=(temp->bitmap>>index)&0x01;

index++;

}

if(temp->bitmap & 0x01<<offset){

temp=(temp->children)[sum];

}

else{

TrieNode* a=new TrieNode();

temp->bitmap |= 0x01<<offset;

temp->children.insert(temp->children.begin()+sum,a);

temp=a;

}

}

temp->bitmap |= 0x80000000;

}

// Returns if the word is in the trie.

bool search(string word) {

TrieNode* temp=root;

for(int i=0;i<word.length();i++){

int offset=word[i]-'a';

int index=0;

int sum=0;

while(index<offset){

sum+=(temp->bitmap>>index)&0x01;

index++;

}

if(temp->bitmap & 0x01<<offset){

temp=(temp->children)[sum];

}

else{

return false;

}

}

return (temp->bitmap & 0x80000000) !=0;

}

// Returns if there is any word in the trie

// that starts with the given prefix.

bool startsWith(string prefix) {

TrieNode* temp=root;

for(int i=0;i<prefix.length();i++){

int offset=prefix[i]-'a';

int index=0;

int sum=0;

while(index<offset){

sum+=(temp->bitmap>>index)&0x01;

index++;

}

if(temp->bitmap & 0x01<<offset){

temp=(temp->children)[sum];

}

else{

return false;

}

}

return true;

}

private:

TrieNode* root;

};