二叉树_二叉树的定义及基础操作

二叉树：二叉树是n(n≥0)个结点的有限集合，二叉树的每个结点至多有两棵子树。二叉树的子树被称作左子树和右子树。
满二叉树：深度为k，且有2^k-1个节点的二叉树，这种树的特点是每一层上的节点数都是最大节点数。
完全二叉树：在一棵二叉树中，除最后一层外，其余层都是满的且最后一层或满、或是在右边缺少连续若干节点。

二叉树的性质：
(1) 在非空二叉树中，第i层的结点总数不超过  , i>=1；
(2) 深度为h的二叉树最多有  个结点(h>=1)，最少有h个结点；
(3)深度为k的完全二叉树，至少有2k-1个叶子节点，至多有2k-1个节点；
(4) 对于任意一棵二叉树，如果其叶结点数为N0，而度数为2的结点总数为N2，则N0=N2+1；
(5) 具有n个结点的完全二叉树的深度为  
(6)有N个结点的完全二叉树各结点如果用顺序方式存储，则结点之间有如下关系：
若s为结点编号则 如果s>1，则其父结点的编号为s/2；
如果2*s<=N，则其左子树的编号为2*s；若2*s>N，则无左子树；
如果2*s+1<=N，则其右子树的结点编号为2*s+1；若2*s+1>N，则无右子树。
(7)给定N个节点，能构成h(N)种不同的二叉树。

二叉树的定义：
#include<iostream>
#include<vector>
#include<stack>
#include<assert.h>
using namespace std;

typedef char  ElemType;      //定义元素类型为char类型
#define END  '#'                   //用数组来传递参数以‘#’代表子节点为空
typedef struct BtNode          //定义二叉树结构体
{
    BtNode *leftchild;
    BtNode *rightchild;
    ElemType data;
}BtNode,*BinaryTree;

BtNode * Buynode()            //购买结点，为二叉树的插入做准备
{
    BtNode *s = (BtNode*)malloc(sizeof(BtNode));
    if(NULL == s) exit(1);
    memset(s,0,sizeof(BtNode)); 
    return s;
}

void Freenode(BtNode *p)  //释放结点
{
    free(p);
}

有关二叉树的基本操作：
//给出数组元素和大小，查找元素结点位置
int FindPos(ElemType *is,ElemType x,int n)
{
    int pos = -1;
    for(int i = 0;i<n;++i)
    {
        if(is[i] == x)
        {
            pos = i;
            break;
        }
    }
    return pos;
}
//获取二叉树的大小，结点个数
int GetSize(BtNode *ptr)
{
    if(NULL == ptr) return 0;
    else return GetSize(ptr->leftchild)+ GetSize(ptr->rightchild) + 1;
}
//获取二叉树的深度
int Depth(BtNode *ptr)
{
    if(NULL == ptr) return 0;
    else return max(Depth(ptr->leftchild), Depth(ptr->rightchild)) + 1;
}
//判断二叉树是否为空
bool Is_Empty(BtNode *ptr)
{
    return NULL == ptr;
}
//查找二叉树中的结点位置
BtNode * FindValue(BtNode *ptr ,ElemType x)
{
    if(NULL == ptr || ptr->data == x)
    {
        return ptr;
    }
    else
    {
        BtNode *p =  FindValue(ptr->leftchild,x);
        if(NULL == p)
        {
            p = FindValue(ptr->rightchild,x);
        }
        return p;
    }
}
//查找二叉树中某一结点的双亲
BtNode * Parent(BtNode *ptr,BtNode *child);
BtNode * FindParent(BtNode *ptr,BtNode *child)
{
    if(NULL == ptr || NULL == child || ptr == child)
    {
        return NULL;
    }
    else
    {
        return Parent(ptr,child);
    }
}
BtNode * Parent(BtNode *ptr,BtNode *child)
{
    if(NULL == ptr || ptr->leftchild == child || ptr->rightchild == child)
    {
        return ptr;
    } 
    else
    {
        BtNode *p = Parent(ptr->leftchild,child);
        if(NULL == p)
        {
            p = Parent(ptr->rightchild,child);
        }
        return p;
    }
}
//二叉树中和为某一个值的路径
void PrintPath(BtNode *ptr,vector<int> &vec,int val)
{
    if(NULL != ptr)
    {
        vec.push_back(ptr->data);
        if(ptr->leftchild == NULL && ptr->rightchild == NULL)
        {
            int sum = 0;
            int n = vec.size();
            for(int i = 0;i<n;++i)
            {
                sum += vec[i];
            }
            if(sum == val)
            {
                for(int i = 0;i<n;++i)
                {
                    cout<<vec[i]<<" ";
                }
                cout<<"=> "<<sum<<endl;
            }
        }
        PrintPath(ptr->leftchild,vec,val);
        PrintPath(ptr->rightchild,vec,val);
        vec.pop_back();
    }
}
//打印二叉树第k层
void Print_KLevel(BtNode *ptr,int k)
{
    if(ptr != NULL && k == 0)
    {
        cout<<ptr->data<<" ";
    }
    else if(ptr != NULL)
    {
        Print_KLevel(ptr->leftchild,k-1);
        Print_KLevel(ptr->rightchild,k-1);
    }
}
//非递归层次打印二叉树
void NiceLevelOrder(BtNode *ptr)
{
    if(NULL == ptr) return ;
    queue<BtNode *> qu;
    qu.push(ptr);
    while(!qu.empty())
    {
        ptr = qu.front(); 
        cout<<ptr->data<<" ";
        qu.pop();
        if(ptr->leftchild != NULL)
        {
            qu.push(ptr->leftchild);
        }
        if(ptr->rightchild != NULL)
        {
            qu.push(ptr->rightchild);
        }
    }
    cout<<endl;
}