OSC上的二叉树《代码》

最新推荐文章于 2022-02-25 19:38:17 发布
wangpengqi
最新推荐文章于 2022-02-25 19:38:17 发布
阅读量589
点赞数
#include <iostream> 
 
 002#include <stack> 
 
 003#include <queue> 
 
 004  
 
 005using  namespace std; 
 
 006  
 
 007typedef  struct Node{ 
 
 008    int     data; 
 
 009    Node    *left; 
 
 010    Node    *right; 
 
 011    int     tag; 
 
 012    Node(int val):data(val),left(NULL),right(NULL),tag(0){} 
 
 013}Node; 
 
 014  
 
 015//插入二叉树节点--递归实现 
 
 016Node *InsertTree(Node *root,int val) 
 
 017{ 
 
 018    Node *e = NULL; 
 
 019    if(root == NULL){ 
 
 020        e = new Node(val); 
 
 021        if(e == NULL) return NULL; 
 
 022        return e; 
 
 023    }else{ 
 
 024        if(val < root->data){ 
 
 025            root->left = InsertTree(root->left,val);//创建左子树 
 
 026        } 
 
 027        else if(val > root->data){ 
 
 028            root->right = InsertTree(root->right,val);//创建右子树 
 
 029        } 
 
 030    }  
 
 031    return root; //递归函数返回时返回的根节点  
 
 032} 
 
 033  
 
 034  
 
 035//在二叉树中插入节点--非递归实现 
 
 036void  InsertTree_(Node **root,int  val) 
 
 037{ 
 
 038    if(root == NULL) return;  
 
 039    Node *e = new Node(val); 
 
 040    if(e == NULL) return;  
 
 041    if(*root == NULL){ 
 
 042        *root = e; 
 
 043    }else{ 
 
 044        Node *p = *root,*pre = NULL; 
 
 045        while(p != NULL){ 
 
 046            pre = p; 
 
 047            if(e->data < p->data){ 
 
 048                p = p->left; 
 
 049            } 
 
 050            else if(e->data > p->data){ 
 
 051                p = p->right; 
 
 052            }else{//有相同的元素就退出 
 
 053                delete e; 
 
 054                return; 
 
 055            } 
 
 056        } 
 
 057  
 
 058        if(e->data < pre->data){ 
 
 059            pre->left = e; 
 
 060        }else{ 
 
 061            pre->right = e; 
 
 062        } 
 
 063    }  
 
 064} 
 
 065  
 
 066//销毁二叉树 
 
 067void  DeleteTree(Node *root) 
 
 068{ 
 
 069    if(root != NULL){ 
 
 070        if(root->left != NULL){ 
 
 071            DeleteTree(root->left); 
 
 072        } 
 
 073        if(root->right != NULL){ 
 
 074            DeleteTree(root->right); 
 
 075        } 
 
 076        cout<<"delete :"<<root->data<<endl; 
 
 077        delete root; 
 
 078    }  
 
 079} 
 
 080  
 
 081//递归先序遍历二叉树 
 
 082void  PreOrder(Node *root) 
 
 083{ 
 
 084    if(root != NULL){ 
 
 085        cout<< root->data <<" "; 
 
 086        PreOrder(root->left); 
 
 087        PreOrder(root->right); 
 
 088    }  
 
 089} 
 
 090  
 
 091//递归中序遍历二叉树 
 
 092void  MidOrder(Node *root) 
 
 093{ 
 
 094    if(root != NULL){ 
 
 095        MidOrder(root->left); 
 
 096        cout<<root->data<<" "; 
 
 097        MidOrder(root->right); 
 
 098    }  
 
 099} 
 
 100  
 
 101//递归后续遍历二叉树 
 
 102void  LastOrder(Node *root) 
 
 103{ 
 
 104    if(root != NULL){ 
 
 105        LastOrder(root->left); 
 
 106        LastOrder(root->right); 
 
 107        cout<<root->data<<" "; 
 
 108    }  
 
 109} 
 
 110  
 
 111//非递归先序遍历 
 
 112void  PreOrder_(Node *root) 
 
 113{ 
 
 114    if(root == NULL) return;  
 
 115    Node *p = root; 
 
 116    stack<Node *> s; 
 
 117    while(!s.empty() || p != NULL) 
 
 118    {  
 
 119        while( p != NULL){ 
 
 120            cout<<p->data <<" "; 
 
 121            s.push(p); 
 
 122            p = p->left; 
 
 123        } 
 
 124  
 
 125        if(!s.empty()){ 
 
 126            p = s.top(); 
 
 127            s.pop(); 
 
 128            p = p->right; 
 
 129        } 
 
 130    }  
 
 131    cout<<endl; 
 
 132} 
 
 133  
 
 134//非递归中序遍历 
 
 135void  MidOrder_(Node *root) 
 
 136{ 
 
 137    if(root == NULL) return;  
 
 138    stack<Node *> s; 
 
 139    Node *p = root; 
 
 140    while(!s.empty()|| p != NULL) 
 
 141    {  
 
 142        //将左子树压入栈中 
 
 143        while(p != NULL){ 
 
 144  
 
 145            s.push(p); 
 
 146            p = p->left; 
 
 147        } 
 
 148        //当栈不为空时弹出左子树，输出左子树的值再遍历右子树 
 
 149        if(!s.empty()) 
 
 150        { 
 
 151            p = s.top(); 
 
 152            cout<<p->data<<" "; 
 
 153            s.pop(); 
 
 154            p = p->right; //将右子树压入栈中 
 
 155        } 
 
 156    }  
 
 157    cout<<endl; 
 
 158} 
 
 159  
 
 160//非递归后续遍历 
 
 161//需要判断根结点的左右子树是否都遍历过了 
 
 162void  LastOrder_(Node *root) 
 
 163{ 
 
 164    if(root == NULL) return;  
 
 165    stack<Node *> s; 
 
 166    Node *p = root; 
 
 167    while(!s.empty() || p != NULL) 
 
 168    {  
 
 169        while(p != NULL){ 
 
 170            s.push(p); 
 
 171            p = p->left; 
 
 172        } 
 
 173  
 
 174        if(!s.empty()) 
 
 175        { 
 
 176            p = s.top();//弹出左子树 
 
 177            //如果左子树已经遍历 
 
 178            if(p->tag == 1) 
 
 179            { 
 
 180                cout<<p->data<<" "; 
 
 181                s.pop(); 
 
 182                p = NULL; //为了弹出p的父结点 
 
 183            }else{ 
 
 184                p->tag = 1; 
 
 185                p = p->right; 
 
 186            } 
 
 187        } 
 
 188    }  
 
 189    cout<<endl; 
 
 190} 
 
 191  
 
 192//广度优先遍历二叉树 
 
 193void  LevelOrder(Node *root) 
 
 194{ 
 
 195    if(root == NULL)return; 
 
 196    queue<Node *> queue; 
 
 197    Node *p = NULL; 
 
 198    //根结点入队 
 
 199    queue.push(root); 
 
 200    while(!queue.empty()) 
 
 201    {  
 
 202        p = queue.front(); //取出队首元素 
 
 203        cout<<p->data<<" "; 
 
 204        queue.pop(); 
 
 205        if(p->left != NULL) 
 
 206            queue.push(p->left); 
 
 207        if(p->right != NULL) 
 
 208            queue.push(p->right); 
 
 209    }  
 
 210    cout<<endl; 
 
 211} 
 
 212  
 
 213//判断是否为二叉排序树，通过中序遍历，中序遍历的输出结果是从小到大排列的， 
 
 214//从跟节点开始记录每次弹出的数，如果比后一个弹出的数大，说明不是二叉排序树 
 
 215//是返回1，不是返回 0，错误 返回 -1 
 
 216  
 
 217int  IsSortedTree(Node *root) 
 
 218{ 
 
 219    if(root == NULL) return -1;  
 
 220    Node *p = root; 
 
 221    stack<Node *> s; 
 
 222    int pre_data = 0; 
 
 223    while(!s.empty() || p != NULL) 
 
 224    {  
 
 225        while(p != NULL){ 
 
 226            s.push(p); 
 
 227            p = p->left; 
 
 228        } 
 
 229        if(!s.empty()) 
 
 230        { 
 
 231            p = s.top(); 
 
 232            if(pre_data == 0 || pre_data < p->data) 
 
 233            { 
 
 234                pre_data = p->data; 
 
 235            } 
 
 236            if(pre_data > p->data){ 
 
 237                return 0; 
 
 238            } 
 
 239            s.pop(); 
 
 240            p = p->right; 
 
 241        } 
 
 242    }  
 
 243    return 1; 
 
 244} 
 
 245  
 
 246int  main() 
 
 247{ 
 
 248    /* 
 
 249    Node *root = NULL; 
 
 250    int arr[] = {8,2,5,1,7,9,3,6,0,4}; 
 
 251    int len = sizeof(arr)/sizeof(int); 
 
 252    for(int i = 0; i < len;i++){ 
 
 253        //root = InsertTree(root,arr[i]); 
 
 254        InsertTree_(&root,arr[i]); 
 
 255    }  
 
 256    */
 
 257  
 
 258    Node *root = NULL; 
 
 259    Node* a = new Node(1); 
 
 260    Node* b = new Node(2); 
 
 261    Node* c = new Node(3); 
 
 262    root = a; 
 
 263    a->left = b; 
 
 264    a->right = c; 
 
 265  
 
 266    cout<<"pre order :"; 
 
 267    PreOrder(root); 
 
 268    cout<<endl; 
 
 269    cout<<"\t   "; 
 
 270    PreOrder_(root); 
 
 271  
 
 272    cout<<"mid order :"; 
 
 273    MidOrder(root); 
 
 274    cout<<endl; 
 
 275    cout<<"\t   "; 
 
 276    MidOrder_(root); 
 
 277  
 
 278    cout<<"last order :"; 
 
 279    LastOrder(root); 
 
 280    cout<<endl; 
 
 281  
 
 282    cout<<"\t   "; 
 
 283    LastOrder_(root); 
 
 284  
 
 285    cout<<"Level Order:"; 
 
 286    LevelOrder(root); 
 
 287  
 
 288    int ret = IsSortedTree(root); 
 
 289    if(ret == 1){ 
 
 290        cout<<"Is BST"<<endl; 
 
 291    }else{ 
 
 292        cout<<"Is NOT BST"<<endl; 
 
 293    }  
 
 294    DeleteTree(root); 
 
 295  
 
 296  
 
 297
         
return0; 
 
 298}