数据结构 树

#include<iostream>
#include<vector>
#include<queue>
#include<stack>
using namespace std;
struct node{
    int val;
    node *left, *right;
    bool vis;
    int tag;
};

void insert(node* &root, int val){
    if(root==NULL){
        root = new node;
        root->val = val;
        root->left=root->right=NULL;
        root->vis=true;
    }else{
        if(val<root->val) insert(root->left, val);
        else insert(root->right, val);
    }
}

void level(node* root){
    if(root==NULL) return;
    queue<node*> q;
    cout<<"level: ";
    q.push(root);
    while(q.size()){
        node* temp=q.front();
        q.pop();
        cout<<temp->val<<" ";
        if(temp->left) q.push(temp->left);
        if(temp->right) q.push(temp->right);
    }
    cout<<endl;
}

void reverselevel(node* root){
    //从下到上， 从右到左的层序遍历
    //可以发现和正常的层序遍历是相反的顺序， 可以把正常层序遍历的
    //的结果压栈，层序遍历结束之后，再出栈，就能得到结果
    //栈能很方便的得到反序序列
    queue<node*> q;
    stack<node*> ans;
    cout<<"reverselevel: ";
    q.push(root);
    while(q.size()){
        node* temp=q.front();
        q.pop();
        ans.push(temp);
        if(temp->left) q.push(temp->left);
        if(temp->right) q.push(temp->right);
    }
    while(ans.size()){
        cout<<ans.top()->val<<" ";
        ans.pop();
    }
    cout<<endl;
}

void preorder(node* root){
    stack<node*> s;
    node* p=root;
    cout<<"preorder: ";
    while(p || s.size()){
        if(p){
            cout<<p->val<<" ";
            s.push(p);
            p = p->left;
        }else{
            p = s.top();
            s.pop();
            p = p->right;
        }
    }
    cout<<endl;
}

void inorder(node* root){
    stack<node*> s;
    cout<<"inorder: ";
    node* p=root;
    while(s.size() || p){
        if(p){//一路访问到左下角
            s.push(p);
            p = p->left;
        }else{
            p = s.top();
            s.pop();
            cout<<p->val<<" ";
            p = p->right;
        }
    }
    cout<<endl;
}

void post(node* root){
    stack<node*> s;
    cout<<"post: ";
    node *p=root, *r=NULL;
    while(p || s.size()){
        if(p){
            s.push(p);
            p=p->left; //一路访问到左下角
        }else{
            //已经访问到最底部
            p=s.top();
            if(p->right && p->right!=r){//对右子树进行后续遍历
                p=p->right;
                s.push(p);
                p=p->left;
            }else{//栈顶节点的右节点为空或者右节点已经访问
                /*
                    左下角节点的右节点必定为空，访问该节点的值
                    让r记录最近访问的节点
                    为什么要把当前节点指向空指针呢？ 为了能遍历右子树
                */
                p=s.top();
                s.pop();
                cout<<p->val<<" ";
                r = p;
                p=NULL;
            }
        }
    }
    cout<<endl;
}

//采用该方式进行后续遍历的时候， 栈中左右的节点均为当前节点的父节点
void post1(node* root){
    cout<<"post1: ";
    stack<node*> s;
    s.push(root);
    node* temp=root;
    while(s.size()){
        if(temp->left && temp->left->vis) {
            s.push(temp->left);
            temp->left->vis=false;
            temp = temp->left;
            
        }
        else if(temp->right && temp->right->vis) {
            s.push(temp->right);
            temp->right->vis=false;
            temp = temp->right;
        }
        else{
            temp = s.top();
            s.pop();
            cout<<temp->val<<" ";
            temp = s.top();
        }
    }
    cout<<endl;
}

int h=-1;
/*
    很巧妙的一个算法
    用last来记录每一层最后一个节点的位置， 当访问到该层的最后一个节点时，高度就加一
    怎么判断访问最后一个节点呢？ 用front记录访问的位置， 当front==last就表示一层访问完成了；
    此外用rear表示队列中最后一个节点的位置， 当访问完上一层的所有节点的时候，rear一定指向的是当前层的
    最后一个节点的位置，把last更新为该位置
*/
int height(node* root, int size){
    if(root==NULL) return 0;
    int front=-1, rear=-1;
    int last=0, level=0;
    vector<node*> q(size);
    q[++rear]=root;
    node *p;
    while(front<rear){
        p = q[++front];
        if(p->left) q[++rear] = p->left;
        if(p->right) q[++rear] = p->right;
        if(last==front){
            level++;
            last = rear;
        }
    }
    cout<<"height: "<<level<<endl;
    return level;
}
//二叉树中一定要先判断二叉树是否是空树
//思路是如果有一个节点的左节点不存在，其后又出现叶子节点，那么一定不是完全二叉树
bool isComplete(node* root){
    if(root==NULL) return root;
    queue<node*> q;
    q.push(root);
    bool exist_left=true;
    while(q.size()){
        node* temp=q.front();
        q.pop();
        if(temp->left){
            q.push(temp->left);
            if(!exist_left) return false;
        }else exist_left = false;
        if(temp->right){
            if(!exist_left) return false;
            q.push(temp->right);
        }
    }
    return true;
}

//层序遍历二叉树， 把所有的节点添加到队列中，包括空节点， 当遇到空节点的时候，查看其后是否
//有非空节点， 有则不是完全二叉树
bool isComplete1(node* root){
    if(root==NULL) return true;
    queue<node*> q;
    q.push(root);
    while(q.size()){
        node* temp=q.front();
        q.pop();
        if(temp){
            q.push(temp->left);
            q.push(temp->right);
        }else{
            while(q.size()){
                if(q.front()) return false;
                q.pop();
            }
        }
    }
    return true;
}

int DsonNode(node* root){
    if(root==NULL) return 0;
    if(root->left && root->right) return DsonNode(root->left) + DsonNode(root->right) + 1;
    return DsonNode(root->left) + DsonNode(root->right);
}

void reverse(node* &root){
    if(root==NULL) return;
    node* temp = root->left;
    root->left = root->right;
    root->right = temp;
    reverse(root->left);
    reverse(root->right);
}

//删除root以及其所有子节点
void deleteNodes(node* root){
    if(root){
        deleteNodes(root->left);
        deleteNodes(root->right);
        delete(root);
    }
}

//删除所有值为x的节点
void deleteX(node* root, int x){
    queue<node*> q;
    if(root->val==x){
        deleteNodes(root);
        return ;
    }
    q.push(root);
    while(q.size()){
        node* temp = q.front();
        q.pop();
        if(temp->left){
            if(temp->left->val==x){
                deleteNodes(temp->left);
                temp->left=NULL;
            }else q.push(temp->left);
        }
        if(temp->right){
            if(temp->right->val==x){
                deleteNodes(temp->right);
                temp->right=NULL;
            }else q.push(temp->right);
        }
    }
}

void rootsOfX(node* root, int x){
    stack<node*> s;
    node *p=root, *r;
    while(p || s.size()){
        if(p){
            if(p->val==x){
                while(s.size()){
                    cout<<s.top()->val<<" ";
                    s.pop();
                }
                cout<<endl;
                return;
            }
            s.push(p);
            p = p->left;
        }else{
            p = s.top();
            if(p->right && p->right!=r){
                p=p->right;
                s.push(p);
                p=p->left;
            }else{
                p = s.top();
                s.pop();
                r = p;
                p = NULL;
            }
        }
    }
}


 
int main(){
    int a[]={7, 4, 10, 2, 5, 8, 11};
    int a1[]={7, 4, 10, 2, 5, 9, 8};
    char ch[]={'*','+','*','a','b','c','-','d'};
    node* root=NULL;
    for(int i=0; i<7; i++) insert(root, a[i]);
     
    level(root);
    rootsOfX(root, 4);
    level(root);
    preorder(root);
    inorder(root);
    reverselevel(root);
    post1(root);
  return 0;
}