小代码 二叉树 添加树状打印及倒立打印

  //bug    last line can not swap with n-1
//http://www.zhihu.com/question/22547591/
 #include
 #include
#include   
#include   
#include   
#include  
#include  
using namespace std;
  int ii=0;
int Find( char x,int size,int zeroIndex)
{
    switch (x)
    {
    case 's': //上移 就是找到零下面的那个数字的位置 也就是序号增加一行 也就是+4
        {
        if ( zeroIndex3)
        if (  zeroIndex>3)
        {
            return zeroIndex - 4;
        }
        }
        break;
    case 'c': 
        {
        if ( zeroIndex%4!=0 )
        {
            return zeroIndex - 1;
        }
        }
        break;
    case 'z':  //左移 主要是判断空白是否在右边缘
        {
        if (zeroIndex%4!=3)
        {
            return zeroIndex + 1;
        }
        }
        break;
    default:
        break;
    }   
    return -1;
}
 
 
//交换数组中zero和next的位置
void SwapIndex(int *ary,int zero, int next)
{
    if (-1 == next)
    {
        return ;
    }
    int t = ary[zero];
    ary[zero] = ary[next];
    ary[next] = t; 
}//DLR
 
void Update(int *ary, int size,char com)
{
    int zeroIndex = 0; //零的序号
    for (int i = 0.; i< size ; i++)
    {
        if (ary[i] == 0)
        {
            zeroIndex = i;
            break;
        }
    }
     
    int nextIndex = Find(com,size,zeroIndex); //获取跟零相邻(根据com不同 取上下左右)的那个数字的序号
    SwapIndex(ary,zeroIndex,nextIndex);
 
}
 
void Show(int *ary, int size)
{  ii++;
    for (int i  = 0 ; i >test;//先测试一下
return test;
}
 
 
void Process(int *ary, int size)
{
   /// int com = 0;
   char  com='s';
    while(ProcessCommand(ary,size,com))
    {
         com = GetCommand();    
    }
 
}
 
 
int pintu()
{
    int ary[16]; //数字0 代表空白
    for (int i=0;i<16; i++)
    {
        ary[i] = i;
    }
    Process(ary,16);
    return 0;
}


















/////////////////////////////////////////////////////////////////////////


















template  
struct Binary_node  
{  
    T data;  
    Binary_node* left;  
    Binary_node* right;  
    Binary_node();  
    Binary_node(const T &x);  
};  
    
template  
class Binary_tree  
{  
public:  
    Binary_tree():root(NULL){}; 
    Binary_tree(const Binary_tree&original);  
    Binary_tree & operator=(const Binary_tree&original); 
    ~Binary_tree();   
    bool empty() const;  
    void preorder(void (*visit)(T &));  /*/ DLR   /*/ 
    void inorder(void  (*visit)(T &));  /*/ LDR  /*/
    void postorder(void (*visit)(T &)); /*/ LRD  /*/ 
    int size() const;                       /*/ Binary_tree大小/*/      
    int height() const;  
    void clear();  
    void insert(const T& x);  
    void reverse();                         /*/ 镜像翻转 /*/
    const Binary_node* get_root() const; 
    void leaf()
   {
    Binary_node *b;
   cout<<"leaf number:"<<_leaf(root)+1<data<<" "<*cur=root;
    Binary_node*p=root;
     queue* > q;  
     Binary_node *b;
    int f=1,r=0;
    T c;
    cin>>c;
    root=new Binary_node; q.push(root);  root->data=c;
   while(c!=-1)
    {
       if(r%2==0)
              {root->left=new Binary_node;  q.push(root->left);}
       else
              {root->right=new Binary_node;  q.push(root->right);}
       if(r%2==1)f++;if(f%2==0)root=q.front(); q.pop();
      r++;
    cin>>c;
    }
   }  
void fun(int n)
{ 
int m=pow(2,n)-1; queue p;
int i,j,k=0;
  n=n+1;
 while(n--)
 { m=pow(2,k+1)-1;
   for(i=0;i *b ;
  _fun(root);
  q.push(root);
//while((!p.empty())&&(!q.empty()))
while((q.size()>1))
{  p.pop();
for(i=0;idata<<" "<*b=root;
   _createBiTree(root);
   }  
 
    void lay(int n)                         /*/ 层次打印 /*/
   {  //assert(root)
      int k=1; int m=1;int i=0;
      Binary_node *b=root;
      queue* > q;  
          q.push(b);  
    while(!q.empty())
  {
     b=q.front();  if(b->left) q.push(b->left); if(b->right) q.push(b->right);
     m=pow(2,k-1); for(i=0;idata; q.pop();
     while(--m)
       {
        for(i=0;i<2*(n/2)+1;i++) cout<<" "; if(!q.empty()){ b=q.front();  if(b->left) q.push(b->left); if(b->right) q.push(b->right);cout<data; q.pop();}
else cout<<"#";
       }
      cout<*root) const;  
    int recursive_height(const Binary_node*root) const;  
    void equal(Binary_node*&sub_root,const Binary_node*orig_node);  
    void recursive_reverse(Binary_node * & sub_root);  
    void recursive_clear(Binary_node * & sub_root);  
    void recursive_insert(Binary_node * & sub_root, const T& x);  
    void recursive_inorder(Binary_node * sub_root, void (*visit)(T &));  
    void recursive_preorder(Binary_node * sub_root, void (*visit)(T &));  
    void recursive_postorder(Binary_node * sub_root, void (*visit)(T &)); 
    void _fun(Binary_node * sub_root)
{
if(sub_root==NULL){q.push(root);  return;}
_fun(sub_root->right);
if(sub_root!=NULL) {q.push(sub_root);}
  
_fun(sub_root->left);
}
    int _leaf(Binary_node * sub_root)
{ 
    if(NULL == sub_root) return 0;  
    if(NULL == sub_root->left&& NULL == sub_root->right)  
       { return 1;  q.push(sub_root);}
    return _leaf(sub_root->left) + _leaf(sub_root->right); 
}
 void _createBiTree(Binary_node *&sub_root)
 {
    T c;  
    cin >> c;  
     
/*************/
  if(-1== c)  sub_root = NULL;  
    else  
    {  
        sub_root = new Binary_node; 
        sub_root->data = c;  
        _createBiTree(sub_root->left);  
        _createBiTree(sub_root->right);  
    }  
 
/*************/ 
} 
protected:  
    Binary_node* root;  
    queue* > q;
    
};
////////////////////////////////////////////  

#ifndef BINARY_TREE_CPP_X  
#define BINARY_TREE_CPP_X  
  
template  
Binary_node::Binary_node()  
{  
    left = right = NULL;  
}  
template  
Binary_node::Binary_node(const T &x)  
{  
    left = right = NULL;  
    data = x;  
}  
template  
Binary_tree::Binary_tree(const Binary_tree&original)  
{  
    root = original.get_root();  
}  
template  
void Binary_tree::recursive_preorder(Binary_node*sub_root, void (*visit)(T&))  
{//先序遍历的递归函数  
    if (sub_root!=NULL)  
    {  
        (*visit)(sub_root->data);  
        recursive_preorder(sub_root->left, visit);  
        recursive_preorder(sub_root->right, visit);  
    }  
}  
template  
void Binary_tree::preorder(void (*visit)(T&))  
{//先序遍历  
    recursive_preorder(root, visit);  
}
template  
void Binary_tree::recursive_inorder(Binary_node*sub_root, void(*visit)(T&))  
{//中序遍历的递归函数  
    if(sub_root!=NULL)  
    {  
        recursive_inorder(sub_root->left, visit);  
        (*visit)(sub_root->data);  
        recursive_inorder(sub_root->right, visit);  
    }  
}  
template  
void Binary_tree::inorder(void (*visit)(T&))  
{//中序遍历  
    recursive_inorder(root, visit);  
}  
 
template  
void Binary_tree::recursive_postorder(Binary_node*sub_root, void (*visit)(T&))  
{//后序遍历的递归函数  
    if (sub_root!=NULL)  
    {  
        recursive_postorder(sub_root->left, visit);  
        recursive_postorder(sub_root->right, visit);  
        (*visit)(sub_root->data);  
    }  
}  
template  
void Binary_tree::postorder(void (*visit)(T&))  
{//后序遍历  
    recursive_postorder(root, visit);  
}  
 
  
 
//return tree height, if only one node then return 1  
template  
int Binary_tree::height() const  
{  
    return recursive_height(root);  
}  
#endif
#define max MAX  
template  
Comparable MAX(const Comparable& a, const Comparable& b)  
{  
    return a > b ? a : b;  
}  
template  
int Binary_tree::recursive_height(const Binary_node*root) const  
{  
    if(root == NULL)  
        return 0;  
    else  
        return 1 + max(recursive_height(root->left) , recursive_height(root->right)) ;  
}  
#undef max  
 
//return the size of tree  
template  
int Binary_tree::size() const  
{  
    return recursive_size(root);  
}  
template  
int Binary_tree::recursive_size(const Binary_node*root) const  
{  
    if(root == NULL)  
        return 0;   
    else  
        return 1 + recursive_size(root->left) + recursive_size(root->right) ;  
}  
//the tree is empty ?  
template  
bool Binary_tree::empty() const  
{  
    return root == NULL;  
}  
//insert x to the tree  
template  
void Binary_tree::insert(const T& x)  
{  
    recursive_insert(root, x);  
}  
//the recursive function of insert,  
//insert x in the less height side,  
//if both sides are same height then insert to the left  
//第一个参数必须使用引用否则插入失败,而其他不涉及数据改动的函数则不需要  
//引用传参时不会发生值拷贝,如果不加引用,会先在函数的栈空间拷贝一个root,但当函数  
//结束时这个拷贝就会被销毁,所以会导致插入失败  
template  
void Binary_tree::recursive_insert(Binary_node*&sub_root, const T& x)  
{  
    if(sub_root == NULL)  
    {  
        Binary_node* ins_data = new Binary_node(x);  
        sub_root = ins_data;  
        return;  
    }  
    else  
    {  
        if(recursive_height(sub_root->left) > recursive_height(sub_root->right))  
            recursive_insert(sub_root->right, x);  
        else  
            recursive_insert(sub_root->left, x);  
    }  
}  
 


template  
Binary_tree::~Binary_tree()  
{  
    clear();  
}  
template  
void Binary_tree::clear()  
{  
    recursive_clear(root);  
}  
/*/ recursive function for destroy tree /*/ 
template  
void Binary_tree::recursive_clear(Binary_node*&sub_root)  
{/*/两个版本都OK /*/ 
#if 0  
    if(sub_root != NULL)  
    {  
        recursive_clear(sub_root->left);  
        recursive_clear(sub_root->right);  
        delete sub_root;  
        sub_root = NULL;  
    }  
#else  
    if(sub_root->left!=NULL)  
        recursive_clear(sub_root->left);  
    if(sub_root->right!=NULL)  
        recursive_clear(sub_root->right);  
    delete sub_root;  
    sub_root = NULL;  
#endif  
}  
/*/  get the root /*/ 
template  
const Binary_node* Binary_tree::get_root() const  
{  
    return root;  
}  
/*/ deep copy /*/ 
template  
Binary_tree& Binary_tree::operator =(const Binary_tree&original)  
{  
    equal(root, original.get_root());  
    return *this;  
}  
template  
void Binary_tree::equal(Binary_node*&sub_root,const Binary_node*orig_node)  
{  
    if(empty())  
        sub_root = new Binary_node(orig_node->data);  
    if(orig_node->left!=NULL)  
    {  
        sub_root->left = new Binary_node(orig_node->left->data);  
        equal(root->left, orig_node->left);  
    }  
    if(orig_node->right!=NULL)  
    {  
        sub_root->right = new Binary_node(orig_node->right->data);  
        equal(root->right, orig_node->right);  
    }  
}  
 
template  
void Binary_tree::reverse()  
{  
    recursive_reverse(root);  
}  
template  
void Binary_tree::recursive_reverse(Binary_node * & sub_root)  
{  
    if(sub_root!=NULL)  
    {  
        Binary_node* temp = NULL;  
        temp = sub_root->left;  
        sub_root->left = sub_root->right;  
        sub_root->right = temp;  
        recursive_reverse(sub_root->left);  
        recursive_reverse(sub_root->right);  
    }  
}  
 
 
  void test10()
{
Binary_tree dd;  
//dd.createBiTree(); 
dd.createlay();
dd.lay(9); 
}
void print( int& x);  
void test11()  
{  
    Binary_tree dd;  
    dd.insert(1);  
    dd.insert(2);  
    dd.insert(3);  
   
 dd.insert(4);  
    dd.insert(5);  
    dd.insert(6);  
    dd.insert(7);
   /***************  
Binary_tree ww;  
    ww = dd;  
    ww.insert(10);  
     ww.insert(7);  
     cout<<"preorder:";  
    dd.preorder(print);  
     cout<left->data<<"left"<left==NULL&&b->right==NULL){cout<<"#"<data<<" "<left->data!=2&&b->left->data!=3){cout<<"#"<data<<" "<