zoukankan      html  css  js  c++  java
  • The order of a Tree HDU

    The order of a Tree  HDU - 3999 

    题意:

    给出二叉树的插入顺序求二叉树的先序遍历。

    注意:

    题目要求输出字典序最小的序列,对于二叉搜索树来说,生成序列的左右子树不会影响树的形态,但必须先输出父节点。

    所以输出序列的顺序就是 头结点->左结点->右结点 即先序遍历。

    模版:

    #include <iostream>
    #include <queue>
    #include <stack>
    using namespace std;
    const int maxn=1e5+10;;
    
    struct node
    {
        int value;
        node *l,*r;
    
        node()
        {
            this->l=NULL;
            this->r=NULL;
        }
    
        node(int v)
        {
            this->value=v;
            this->l=NULL;
            this->r=NULL;
        }
    };
    
    class binarySearchTree
    {
    public:
        node* root;
        /**
         二叉搜索树建树
         @a 输入数组 a[0]为根结点
         @n  数组a的长度
         */
        void buildTree(int a[],int n)
        {
            this->root=new node(a[0]);
            for(int i=1;i<n;i++)
            {
                node *now=new node(a[i]);
                node *fa=this->root;
                while(1)
                {
                    if(now->value<fa->value)
                    {
                        if(fa->l==NULL)
                        {
                            fa->l=now;
                            break;
                        }
                        else fa=fa->l;
                    }
                    else
                    {
                        if(fa->r==NULL)
                        {
                            fa->r=now;
                            break;
                        }
                        else fa=fa->r;
                    }
                }
            }
        }
        /**
         层序遍历序列
         返回一个数组
         */
        int* getLevelOrder()
        {
            int* a=new int[maxn];
            int cnt=0;
            queue<node>q;
            q.push(*this->root);
            while(!q.empty())
            {
                node now=q.front();
                a[cnt++]=now.value;
                q.pop();
                if(now.l) q.push(*now.l);
                if(now.r) q.push(*now.r);
            }
            return a;
        }
        /**
         先序遍历序列
         返回一个数组
         */
        int* getPreOrder()
        {
            int* a=new int[maxn];
            int cnt=0;
            node *now=this->root;
            stack<node*>st;
            while(now||st.size())
            {
                while(now)
                {
                    a[cnt++]=now->value;
                    st.push(now);
                    now=now->l;
                }
                if(st.size())
                {
                    now=st.top();
                    st.pop();
                    now=now->r;
                }
            }
            return a;
        }
        /**
         中序遍历序列
         返回一个数组
         */
        int* getInOrder()
        {
            int* a=new int[maxn];
            int cnt=0;
            node *now=this->root;
            stack<node*>st;
            while(now||st.size())
            {
                while(now)
                {
                    st.push(now);
                    now=now->l;
                }
                if(st.size())
                {
                    now=st.top();
                    st.pop();
                    a[cnt++]=now->value;
                    now=now->r;
                }
            }
            return a;
        }
        /**
         后序遍历序列
         返回一个数组
         */
        int* getPostOrder()
        {
            int* a=new int[maxn];
            int cnt=0;
            node* now=this->root;
            stack<node*>st1;
            stack<node*>st2;
            while(now||st1.size())
            {
                while(now)
                {
                    st1.push(now);
                    st2.push(now);
                    now=now->r;
                }
                if(st1.size())
                {
                    now=st1.top();
                    st1.pop();
                    now=now->l;
                }
            }
            while(st2.size())
            {
                now=st2.top();
                st2.pop();
                a[cnt++]=now->value;
            }
            return a;
        }
    };
    板子

    代码:

      1 #include <iostream>
      2 #include <queue>
      3 #include <stack>
      4 using namespace std;
      5 const int maxn=1e5+10;;
      6 
      7 struct node
      8 {
      9     int value;
     10     node *l,*r;
     11     
     12     node()
     13     {
     14         this->l=NULL;
     15         this->r=NULL;
     16     }
     17     
     18     node(int v)
     19     {
     20         this->value=v;
     21         this->l=NULL;
     22         this->r=NULL;
     23     }
     24 };
     25 
     26 class binarySearchTree
     27 {
     28 public:
     29     node* root;
     30     /**
     31      二叉搜索树建树
     32      @a 输入数组 a[0]为根结点
     33      @n  数组a的长度
     34      */
     35     void buildTree(int a[],int n)
     36     {
     37         this->root=new node(a[0]);
     38         for(int i=1;i<n;i++)
     39         {
     40             node *now=new node(a[i]);
     41             node *fa=this->root;
     42             while(1)
     43             {
     44                 if(now->value<fa->value)
     45                 {
     46                     if(fa->l==NULL)
     47                     {
     48                         fa->l=now;
     49                         break;
     50                     }
     51                     else fa=fa->l;
     52                 }
     53                 else
     54                 {
     55                     if(fa->r==NULL)
     56                     {
     57                         fa->r=now;
     58                         break;
     59                     }
     60                     else fa=fa->r;
     61                 }
     62             }
     63         }
     64     }
     65     /**
     66      层序遍历序列
     67      返回一个数组
     68      */
     69     int* getLevelOrder()
     70     {
     71         int* a=new int[maxn];
     72         int cnt=0;
     73         queue<node>q;
     74         q.push(*this->root);
     75         while(!q.empty())
     76         {
     77             node now=q.front();
     78             a[cnt++]=now.value;
     79             q.pop();
     80             if(now.l) q.push(*now.l);
     81             if(now.r) q.push(*now.r);
     82         }
     83         return a;
     84     }
     85     /**
     86      先序遍历序列
     87      返回一个数组
     88      */
     89     int* getPreOrder()
     90     {
     91         int* a=new int[maxn];
     92         int cnt=0;
     93         node *now=this->root;
     94         stack<node*>st;
     95         while(now||st.size())
     96         {
     97             while(now)
     98             {
     99                 a[cnt++]=now->value;
    100                 st.push(now);
    101                 now=now->l;
    102             }
    103             if(st.size())
    104             {
    105                 now=st.top();
    106                 st.pop();
    107                 now=now->r;
    108             }
    109         }
    110         return a;
    111     }
    112     /**
    113      中序遍历序列
    114      返回一个数组
    115      */
    116     int* getInOrder()
    117     {
    118         int* a=new int[maxn];
    119         int cnt=0;
    120         node *now=this->root;
    121         stack<node*>st;
    122         while(now||st.size())
    123         {
    124             while(now)
    125             {
    126                 st.push(now);
    127                 now=now->l;
    128             }
    129             if(st.size())
    130             {
    131                 now=st.top();
    132                 st.pop();
    133                 a[cnt++]=now->value;
    134                 now=now->r;
    135             }
    136         }
    137         return a;
    138     }
    139     /**
    140      后序遍历序列
    141      返回一个数组
    142      */
    143     int* getPostOrder()
    144     {
    145         int* a=new int[maxn];
    146         int cnt=0;
    147         node* now=this->root;
    148         stack<node*>st1;
    149         stack<node*>st2;
    150         while(now||st1.size())
    151         {
    152             while(now)
    153             {
    154                 st1.push(now);
    155                 st2.push(now);
    156                 now=now->r;
    157             }
    158             if(st1.size())
    159             {
    160                 now=st1.top();
    161                 st1.pop();
    162                 now=now->l;
    163             }
    164         }
    165         while(st2.size())
    166         {
    167             now=st2.top();
    168             st2.pop();
    169             a[cnt++]=now->value;
    170         }
    171         return a;
    172     }
    173 };
    174 
    175 
    176 int main()
    177 {
    178     int a[maxn];
    179     int n;
    180     cin>>n;
    181     for(int i=0;i<n;i++) cin>>a[i];
    182     
    183     binarySearchTree t;
    184     t.buildTree(a,n);
    185     
    186     int *b=t.getPreOrder();
    187     for(int i=0;i<n;i++) cout<<b[i]<<(i==n-1?'
    ':' ');
    188     return 0;
    189 }
  • 相关阅读:
    数组集合之间的转换
    eclipse 大小写转换
    Linux下查看文件内容的命令
    linux常用命令:创建文件和文件夹
    Error Downloading Packages: yum更新出现错误
    XShell上传文件到Linux服务器上
    linux最常用的20个命令
    Sonar理论篇
    如何查看DLL文件的函数列表
    C++在C的基础上的扩充
  • 原文地址:https://www.cnblogs.com/lihahahahaji/p/13905476.html
Copyright © 2011-2022 走看看