数据结构与算法分析—树的概念和有关二叉树基本算法的实现（C语言）

 

 一 ：树的概念和一些术语

  以下来自陈越姥姥DS课的PPT，英文比较短小精悍

【Definition】A tree is a collection of nodes.  The collection can be empty; otherwise, a tree consists of

  (1)  a distinguished node r, called the root;

  (2)  and zero or more nonempty (sub)trees T1...Tk, each of whose roots are connected by a directed edge from r.

 Note:

 1  Subtrees must not connect together.  Therefore every node in the tree is the root of some subtree.

 2  There are   N   —   1  edges in a tree with N nodes.

 3  Normally the root is drawn at the top.

 degree of a node : number of subtrees of the node.  For example, degree(A) = 3, degree(F) = 0

 degree of a tree : max{degree(node)} node belong tree For example, degree of this tree = 3.

 parent : a node that has subtrees.

 children : the roots of the subtrees of a parent.

 siblings : children of the same parent.

 leaf ( terminal node ) : a node with degree 0 (no children).

 path from n1 to nk : a (unique) sequence of nodes n1, n2, …, nk  such that ni is the parent of ni+1 for 1 <=i < k.

 length of path : number of edges on the path. 

 depth of ni : length of the unique path from the root to ni.   Depth(root) = 0.

 height of ni : length of the longest path from ni to a leaf.  Height(leaf) = 0, and height(D) = 2.

 height (depth) of a tree : height(root) = depth(deepest leaf).

 ancestors of a node : all the nodes along the path from the node up to the root.

 descendants of a node : all the nodes in its subtrees.

二：有关二叉树基本算法的实现

二叉树是一颗棵树，不存在有多于两个的儿子的节点

有一些比较特殊的二叉树

满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。

完全二叉树：若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。

以下是一些关于二叉树的基本算法，比如前序 后序 中序 层序遍历 求树的高度

/*
        2
       / \  
      3   1
     /   / \  
    5   6   4
*/
#include <stdio.h>
#include <stdlib.h>

#define MAXN 1000
typedef struct TNode *Position;
typedef Position BinTree;
struct TNode{
    int Data;
    BinTree Left;
    BinTree Right;
};

void preorder(BinTree T)
{
    if(T != NULL) {
        printf("%d\n",T -> Data);
        preorder(T -> Left);
        preorder(T -> Right);
    }
}
void inorder(BinTree T)
{
     if(T != NULL) {
        inorder(T -> Left);
        printf("%d\n",T -> Data);
        inorder(T -> Right);
    }
}
void postorder(BinTree T)
{
    if(T != NULL) {
        postorder(T -> Left);
        postorder(T -> Right);
        printf("%d\n",T -> Data);
    }
}
int getHeight(BinTree T)
{
    if(T == NULL) return 0;
    else {
        int Left_Height = getHeight(T -> Left);
        int Right_Height = getHeight(T -> Right);

        if(Left_Height >= Right_Height) return Left_Height + 1;
        return Right_Height + 1;
    }
}
void levelorder(BinTree T)
{
    if(T == NULL) return;
    BinTree Que[MAXN];
    int Front = 0,Rear = 0;
    Que[Rear++] = T;
    while(Front < Rear) {
        BinTree _T = Que[Front++];
        printf("%d\n",_T -> Data);
        if(_T -> Left != NULL) Que[Rear++] = _T -> Left;
        if(_T -> Right != NULL) Que[Rear++] = _T -> Right;
    }
}
BinTree create()
{
    return (Position)malloc(sizeof(struct TNode));
}
int main(void)
{
    BinTree T1,T2,T3,T4,T5,T6;
    //分配内存
    T1 = create();
    T2 = create();
    T3 = create();
    T4 = create();
    T5 = create();
    T6 = create();
    //赋值
    T1 -> Data = 1;
    T2 -> Data = 2;
    T3 -> Data = 3;
    T4 -> Data = 4;
    T5 -> Data = 5;
    T6 -> Data = 6;
    //建树
    T2 -> Left = T3;
    T2 -> Right = T1;
    T3 -> Left = T5;
    T3 -> Right = NULL;
    T1 -> Left = T6;
    T1 -> Right = T4;
    T5 -> Left = NULL;
    T5 -> Right = NULL;
    T6 -> Left = NULL;
    T6 -> Right = NULL;
    T4 -> Left = NULL;
    T4 -> Right = NULL;
    printf("--------preorder-----------\n");
    preorder(T2);
    printf("--------inorder------------\n");
    inorder(T2);
    printf("--------postorder------------\n");
    postorder(T2);
    printf("--------levelorder---------\n");
    levelorder(T2);
    printf("Height is %d\n",getHeight(T2));
    return 0;
}

 下面分别是根据前序遍历和中序遍历找后序遍历，根据后序遍历和中序遍历找前序遍历

#include <stdio.h>
#include <stdlib.h>

#define MAXN 1000
typedef struct TNode *Position;
typedef Position BinTree;
struct TNode{
    char Data;
    BinTree Left;
    BinTree Right;
};
BinTree build(char *pre,char *mid,int size)
{
    if(size <= 0) return NULL;
    int i = 0;
    for(i = 0; i < size; i++) {
        if(*(mid + i) == *pre) {
            break;
        }
    }
    BinTree T;
    T = (Position)malloc(sizeof(struct TNode));
    T -> Data = mid[i];
    T -> Left = build(pre + 1,mid,i);
    T -> Right = build(pre + 1 + i,mid + i + 1,size - i - 1);
    return T;
}
void postorder(BinTree T)
{
    if(T != NULL) {
        postorder(T -> Left);
        postorder(T -> Right);
        printf("%c\n",T -> Data);
    }
}
int main(void)
{
    char pre[55],mid[55];
    scanf("%s %s",pre,mid);
    BinTree T = build(pre,mid,strlen(pre));
    postorder(T);
    return 0;
}

 

#include <stdio.h>
#include <stdlib.h>

#define MAXN 1000

typedef struct TNode *Position;
typedef Position BinTree;
struct TNode{
    char Data;
    BinTree Left;
    BinTree Right;
};
BinTree build(char *post,char *mid,int size)
{
    if(size <= 0) return NULL;
    int i = 0;
    for(i = 0; i < size; i++) {
        if(*(mid + i) == *(post + size - 1)){
            break;
        }
    }
    BinTree T;
    T = (Position)malloc(sizeof(struct TNode));
    T -> Data = mid[i];
    T -> Left = build(post,mid,i);
    T -> Right = build(post + i,mid + i + 1,size - i - 1);
    return T;
}
void preorder(BinTree T)
{
    if(T != NULL) {
        printf("%c\n",T -> Data);
        preorder(T -> Left);
        preorder(T -> Right);
    }
}
int main(void)
{
    char post[55],mid[55];
    scanf("%s %s",post,mid);
    BinTree T = build(post,mid,strlen(post));
    preorder(T);
    return 0;
}