二叉树的顺序存储和基本操作

一、二叉树的定义：

二叉树是n个结点的有限集合，当n=0时称为空树，否则：（1）有且只有一个特殊的被称为树的根结点；（2）若n>1时，其余的结点被分为两个互不相交的子集，称为左右子树，并且左右子树都是二叉树；可以看出二叉树的定义是递归的。

二、二叉树的性质：

（1）在非空二叉树上，第i层至多有2^(i-1)个结点；

（2）深度为k的二叉树至多有2^k-1个结点；

（3）对任何一个二叉树，若其叶子结点数为n0，度为2的节点数为n2，则n0=n2+1；

满二叉树：一课深度为k且有2^k-1个结点的二叉树。

完全二叉树：如果深度为k，有n个结点的二叉树，当且仅当其每一个结点都与深度为k的满二叉树中编号从1到n的结点一一对应，该二叉树称为完全二叉树。2^(k-1)<=n<=2^k-1

（4）n个结点的完全二叉树的深度k=[log2 n]+1,这里这个符号[x]表示小于等于x的整数;(证明过程，对上述n的不等式取对数）

（5）若对一棵有n个结点的完全二叉树(深度为└㏒2n┘+1)的结点按层（从第1层到第㏒2n +1层)序自左至右进行编号,则对于编号为i（1≦i≦n)的结点：

1 、若i=1：则结点i是二叉树的根，无双亲结点；否则，若i>1，则其双亲结点编号是 [i/2]。
2、 如果2i>n：则结点i为叶子结点，无左孩子；否则，其左孩子结点编号是2i。
3、 如果2i+1>n：则结点i无右孩子；否则，其右孩子结点编号是2i+1。 

三、二叉树的存储结构

1、顺序存储结构：

typedef char ElemType;
typedef struct stree
{
    ElemType bitTree[MAX_SIZE];
    int pointer;   //number of points
}STree;
//init
void STree_Init(STree &T)
{
    for(int i=0;i<MAX_SIZE;++i)
        T.bitTree[i]='0';
    T.pointer=0;
}
//insert root
int STree_insert_Root(STree &T,ElemType e)
{
    T.bitTree[1]=e;
    T.pointer++;
    return 1;
}
//insert left
int STree_insert_Left(STree &T,int i,ElemType e)
{
    if(i>=MAX_SIZE || i<0)
    {
        cout<<"argument is false!"<<endl;
        return -1;
    }
    T.bitTree[2*(i+1)]=e;
    T.pointer++;
    return 1;
}
//insert right
int STree_insert_Right(STree &T,int i,ElemType e)
{
    if(i>=MAX_SIZE || i<0)
    {
        cout<<"argument is false!"<<endl;
        return -1;
    }
    T.bitTree[2*(i+1)+1]=e;
    T.pointer++;
    return 1;
}
//
int STree_delete_Left(STree &T,int i,ElemType *x_left)
{
    if(i>=MAX_SIZE || i<0)
    {
        cout<<"argument is false!"<<endl;
        return -1;
    }
    *x_left=T.bitTree[2*(i+1)];
    T.pointer--;
    return 1;
}
//
int STree_delete_Right(STree &T,int i,ElemType *x_right)
{
    if(i>=MAX_SIZE || i<0)
    {
        cout<<"argument is false!"<<endl;
        return -1;
    }
    *x_right=T.bitTree[2*(i+1)+1];
    T.pointer--;
    return 1;
}
int STree_delete_Root(STree &T,ElemType *x_root)
{
    *x_root=T.bitTree[1];
    T.pointer--;
    return 1;
}
//
bool STree_empty(STree &T)
{
    return T.pointer==0;
}

2、三种遍历方式：前序、中序、后序

递归形式的遍历方式

//前序遍历
void STree_Traver_1(STree &T,int i)
{
        cout<<T.bitTree[i]<<" ";
        if(T.bitTree[2*i]!='0')
            STree_Traver_1(T,2*i);
        if(T.bitTree[2*i+1]!='0')
            STree_Traver_1(T,2*i+1);
}
//中序遍历
void STree_Traver_2(STree &T,int i)
{
    if(T.bitTree[2*i]!='0')
        STree_Traver_2(T,2*i);
    cout<<T.bitTree[i]<<" ";
    if(T.bitTree[2*i+1]!='0')
        STree_Traver_2(T,2*i+1);
}
//后序遍历
void STree_Traver_3(STree &T,int i)
{
    if(T.bitTree[2*i]!='0')
        STree_Traver_3(T,2*i);
    if(T.bitTree[2*i+1]!='0')
        STree_Traver_3(T,2*i+1);
    cout<<T.bitTree[i]<<" ";
}

非递归形式的遍历方式

//前序遍历
int STree_Traver_1_no(STree &T)
{
    stack<int> s({'0'});
    int p=1,q;
    if(STree_empty(T))
    {
        cout<<"tree is empty!"<<endl;
        return -1;
    }
do{
    cout<<T.bitTree[p]<<" ";
    q=p*2+1;
    if(T.bitTree[q]!='0')
        s.push(q);
    p=p*2;
    if(T.bitTree[p]=='0') //到树的底部了，回退
    {
        p=s.top();
        s.pop();
    }
 }while(T.bitTree[p]!='0');

    return 1;
}
//中序遍历
int STree_Traver_2_no(STree &T)
{
    stack<int> s;
    int p=1;
    int b=1;
    /*
    if(STree_empty(T))
    {
        cout<<"tree is empty!"<<endl;
        return -1;
    }
    */
    do
    {
        while(T.bitTree[p]!='0')
        {
            s.push(p);
            p=p*2;
        }
        if(s.empty()) b=0;
        else {
        p=s.top();
        s.pop();
        cout<<T.bitTree[p]<<" ";
        p=p*2+1;
        }
    }while(b!=0);
    return 1;
}
//后序遍历
int STree_Traver_3_no(STree &T)
{
    int p=1;
    int b=1,top=0;
    int s1[20],s2[20];
    do
    {
        while(T.bitTree[p]!='0')
        {
            s1[++top]=p;
            s2[top]=0;
            p=p*2;
        }
        if(top==0) b=0;
        else if(s2[top]==0)
        {
            p=s1[top]*2+1;
            s2[top]=1;
        }
        else
        {
            p=s1[top];
            top--;
            cout<<T.bitTree[p]<<" ";
            T.bitTree[p]='0';
        }
    }while(b!=0);
    return 1;
}

关于二叉树的顺序存储结构和递归遍历方式以及非递归遍历方式，上边全部给出了实现代码，下一篇给出链式存储结构及其遍历方式的代码。