二叉树特性及详细例子

二叉树的性质

一般二叉树性质：

1. 在非空二叉树的k层上，至多有2^k个节点(k>=0)
2. 高度为k的二叉树中,最多有2^k+1-1个节点(k>=0)
3. 对于任何一棵非空的二叉树,如果叶节点个数为n₀，度数为2的节点个数为n₂，则有: n0 = n₂ + 1

完全二叉树性质:
只有最下面的两层结点度数小于2，其余各层的结点度数都等于2，并且最下面一层的结点都集中在该层最左边得若干位置上，则此二叉树称为完全二叉树。

1. 具有n个节点的完全二叉树的高度k为[log₂n]
2. 对于具有n个节点的完全二叉树,如果按照从上(根节点)到下(叶节点)和从左到右的顺序对二叉树中的所有节点从0开始到n-1进行编号,则对于任意的下标为k的节点，有：

• 如果k=0,则它是根节点，它没有父节点；如果k>0,则它的父节点的下标为[(i-1)/2];
• 如果2k+1 <= n-1,则下标为k的节点的左子结点的下标为2k+1;否则,下标为k的节点没有左子结点.
• 如果2k+2 <= n-1,则下标为k的节点的右子节点的下标为2k+2;否则,下标为k的节点没有右子节点

满二叉树性质:
任何结点或者是树叶，或有两颗非空子树。

在满二叉树中，叶节点的个数比分支节点的个数多1

扩充二叉树性质:

1. 在扩充二叉树中，外部节点的个数比内部节点的个数多1
2. 对任意扩充二叉树，外部路径长度E和内部路径长度I之间满足以下关系：E = I + 2n, 其中n是内部节点个数

二叉树的实现与周游

二叉树的顺序表示：

二叉树的顺序表示适用于完全二叉树，根据完全二叉树的第2性质，可以建立处节点之间的关系，对于一般的二叉树，可以将其扩充为完全二叉树，然后用一维数组顺序存储.

以下是程序代码:

bintree.h

#include<stdio.h>
#include<stdlib.h>
#define USED 1
#define NOTUSED 0
typedef int Type;

// 二叉树节点结构体
typedef struct treenode
{
    int nodeIndex;
    // 标志是否为外部节点，如果是则为0，否则为1
    int isIn;
    // 0表示这个节点不在二叉树中，1表示在树中
    int isUsed;
    Type element;
}TreeNode;

// 二叉树结构体
typedef struct bintree
{
    int MAXN;
    int n;
    TreeNode *nodelist;
}*Tree;

// 创建最大节点为m的空二叉树
Tree createBinTree(int m)
{
    int i;
    Tree tree = NULL;
    TreeNode *nodelist = NULL;
    tree = malloc(sizeof(struct bintree));
    if (NULL != tree)
    {
        nodelist = malloc(m * sizeof(TreeNode));
        if (NULL != nodelist)
        {
            tree->MAXN = m;
            tree->n = -1;
            for (i = 0; i < m; i++)
            {
                nodelist[i].isUsed = NOTUSED;
                nodelist[i].nodeIndex = i;
            }
            printf("\n");    
            tree->nodelist = nodelist;
        }
    }
    return tree;
}

// 在二叉树末尾加入元素
void inTree(Tree tree, Type x, int isIn)
{
    void replaceTree(Tree, Type, int, int);
    if (tree->n + 1 < tree->MAXN)
    {
        replaceTree(tree, x, tree->n + 1, isIn);
        tree->n = tree->n + 1;
    }
    return;
}

// 替换二叉树中指定下标的元素
void replaceTree(Tree tree, Type x, int index, int isIn)
{
    if (tree->n == -1 || (index >= 0 && index <= tree->n + 1))
    {
        tree->nodelist[index].element = x;
        tree->nodelist[index].isIn = isIn;
        tree->nodelist[index].isUsed = USED;
    }
    return;
}

// 得到指定下标的元素
Type getNode(Tree tree, int index)
{
    int re;
    if (index >= 0 && index <= tree->n)
        re = tree->nodelist[index].element;
    return re;
}

// 得到父节点的元素下标
int parent(Tree tree, int child)
{
    if (child < 0 || child > tree->n)
        return -1;
    else
        return (child - 1) / 2;
}

// 得到右子节点的元素下标
int rightChild(Tree tree, int parent)
{
    if (parent < 0 || parent > tree->n)
        return -1;
    else
        return 2 * parent + 2;
}

// 得到左子节点的元素下标
int leftChild(Tree tree, int parent)
{
    if (parent < 0 || parent > tree->n)
        return -1;
    else
        return 2 * parent + 1;
}

这里用的是非递归的周游方法，所以要用到栈，一下是自定义的栈.

stack.h

#include "bintree.h"
typedef TreeNode DataType;

typedef struct mystack
{
    //数组最大长度
    int MAXN;
    //指定栈顶位置
    int index;
    DataType *ele;
    
}*MyStack, Stack;


//创建一个空栈
MyStack createStack(int num)
{
    MyStack stack = NULL;
    stack = malloc(sizeof(Stack));
    if(stack != NULL)
    {
        stack->ele = malloc(sizeof(DataType) * num);
        if(stack ->ele != NULL)
        {
            stack ->MAXN = num;
            stack ->index = -1;
        }
    }
    return stack;
}

//判断栈是否为空
int isEmptyStack(MyStack stack)
{
    return stack ->index == -1;
}

//元素入栈,如果栈已经满则返回0,否则返回1
int push(MyStack stack, DataType x)
{
    int index = stack ->index + 1;
    if(index >= stack ->MAXN)
        return 0;
    else
    {
        stack ->ele[index] = x;
        stack ->index = index;    
        return 1;
    }
}

//元素出栈,如果栈已经为空返回０，否则返回１
int pop(MyStack stack)
{
    if(isEmptyStack(stack))
        return 0;
    else
    {
        stack ->index--;
        return 1;
    }
}

//取栈顶元素
DataType top(MyStack stack)
{
    DataType get;
    if(!isEmptyStack(stack))
        get = stack ->ele[stack ->index];
    return get;
}

bintree.c

#include "stack.h"

//访问节点信息
int visit(TreeNode node)
{
    printf(" %d", node.element);
    return node.nodeIndex;
}

//先根次序周游
void preOrder(Tree tree, MyStack stack)
{
    int index = 0;
    TreeNode node;
    if(!tree->nodelist[index].isUsed)
        return;
    push(stack,tree->nodelist[index]);
    while(!isEmptyStack(stack))
    {
        node = top(stack);
        pop(stack);
        if(node.isUsed == USED)
        {
            index = visit(node);
            push(stack,tree->nodelist[rightChild(tree, index)]);
            push(stack,tree->nodelist[leftChild(tree, index)]);
        }
        
    }
}

//中根次序周游
void inOrder(Tree tree, MyStack stack)
{
    int index = 0;
    TreeNode node;
    if(tree->nodelist[index].isUsed == NOTUSED)
        return;
    do 
    {
        while(tree->nodelist[index].isUsed == USED)
        {
            push(stack,tree->nodelist[index]);
            index = leftChild(tree, index);
        }
        node = top(stack);
        pop(stack);
        index = visit(node);
        index = rightChild(tree,index);
    } while(tree->nodelist[index].isUsed == USED || !isEmptyStack(stack));
        
}

//后根次序周游
void postOrder(Tree tree, MyStack stack)
{
    int index = 0, rightIndex;
    TreeNode node;
    if(tree->nodelist[index].isUsed == NOTUSED)
        return;
    while(tree->nodelist[index].isUsed == USED || !isEmptyStack(stack))
    {
        while(tree->nodelist[index].isUsed == USED)
        {
            push(stack,tree->nodelist[index]); 
            rightIndex = rightChild(tree, index);
            index = leftChild(tree ,index);
            if(tree->nodelist[index].isUsed == NOTUSED)
                index = rightIndex;
        }
        node = top(stack);
        pop(stack);
        index = visit(node);
        //如果栈不为空，且从左子树退回,进入到右子树遍历
        if(!isEmptyStack(stack) && index == leftChild(tree,top(stack).nodeIndex))
            index = rightChild(tree,top(stack).nodeIndex);
        else tree->nodelist[index].isUsed = NOTUSED;
    }
    
}

int main()
{
    int m = 0, isIn = 1, j, buffer = 0;
    Tree tree = NULL;
    MyStack stack = NULL;

    printf("请输入节点个数:");
    scanf("%d",&m);
    tree = createBinTree(m);
    stack = createStack(m);
    printf("请输入%d个数字:",m);
    //将0到5六个元素依次放入二叉树中
    for(j = 0; j < m; j++)
    {
        scanf(" %d", &buffer);
        inTree(tree, buffer, isIn);
    }

    printf("先根次序周游结果为:");
    preOrder(tree,stack);
    printf("\n");

    printf("中根次序周游结果为:");
    inOrder(tree, stack);
    printf("\n");

    printf("后根次序周游结果为:");
    postOrder(tree, stack);
    printf("\n");

    return 1;
}

按图示二叉树输出:

输出结果为：

 

二叉树连接表示:

#include<stdio.h>
#include<stdlib.h>
typedef int DataType;
typedef struct treenode *TreeNode;
typedef struct treenode *BinTree;

struct treenode
{
    DataType element;
    TreeNode llink;
    TreeNode rlink;
};

BinTree createBinTree(DataType x)
{
    BinTree tree = NULL;
    tree = malloc(sizeof(struct treenode));
    tree->element = x;
    return tree;
}

BinTree addToLeft(BinTree t, DataType x)
{
    TreeNode node = NULL;
    node = malloc(sizeof(struct treenode));
    if (node != NULL)
        node->element = x;
    t -> llink = node;
    return node;
}

BinTree addToRight(BinTree t, DataType x)
{
    TreeNode node = NULL;
    node = malloc(sizeof(struct treenode));
    if (node != NULL)
        node->element = x;
    t-> rlink = node;
    return node;
}

void visitRoot(BinTree tree)
{
    printf("%d ", tree->element);
}

BinTree leftChild(BinTree tree)
{
    return tree->llink;
}

BinTree rightChild(BinTree tree)
{
    return tree->rlink;
}
//用递归方法
//先根周游
void preOrder(BinTree tree)
{
    if(tree == NULL)
        return;
    visitRoot(tree);
    preOrder(leftChild(tree));
    preOrder(rightChild(tree));
}

//中根周游
void inOrder(BinTree tree)
{
    if(NULL == tree)
        return;
    inOrder(leftChild(tree));
    visitRoot(tree);
    inOrder(rightChild(tree));
}

//后根周游
void postOrder(BinTree tree)
{
    if(NULL == tree)
        return;
    postOrder(leftChild(tree));
    postOrder(rightChild(tree));
    visitRoot(tree);
}

int main()
{
    BinTree left, right;
    BinTree tree = createBinTree(5);
    left = addToLeft(tree, 4);
    right = addToRight(tree, 3);
    addToLeft(left, 8);
    addToRight(left, 7);
    addToLeft(right, 6);
    
    printf("先根周游次序：");
    preOrder(tree);
    printf("\n");
    printf("中根周游次序：");
    inOrder(tree);
    printf("\n");
    printf("后根周游算法：");
    postOrder(tree);
    printf("\n");
    return 1;
}