linux学习总结（数据结构——树、二叉树以及遍历）

二叉树的存储：

顺序存储浪费空间。

二叉树链式存储结构：

typedef int datatype;

typedef struct node{

　　datatype data;

struct node *lchild,*rchild;

}bitree,*root;

二叉树的遍历，由于二叉树的递归性质，遍历算法也是递归的。三种基本的遍历算法如下：

先访问树根，再访问左子树，最后访问右子树  先根遍历

先访问左子树，再访问树根，最后访问右子树 中根遍历

先访问左子树，再访问右子树，最后访问树根 后根遍历。

/********************

*二叉树

***********************/



#include <stdio.h>

#include <stdlib.h>



#define N  16

typedef struct _node_

{

    int no;

    struct _node_ *lchild, *rchild;

}bitree;



typedef bitree * datatype;

typedef struct 

{

    datatype data[N];

    int front, rear;

}sequeue;



sequeue *CreateEmptySequeue()

{

    sequeue *sq;



    sq = (sequeue*)malloc(sizeof(sequeue));

    sq->front = sq->rear = 0;



    return sq;

}



int EmptySequeue(sequeue *sq)

{

    return sq->front == sq->rear;

}



void EnSequeue(sequeue *sq, datatype x)

{

    sq->rear = (sq->rear + 1) % N;

    sq->data[sq->rear] = x;



    return;

}



datatype DeSequeue(sequeue *sq)

{

    sq->front = (sq->front + 1)%N;



    return sq->data[sq->front];

}



bitree *CreateBitree(int i, int n)

{

    bitree *root;



    root = (bitree *)malloc(sizeof(bitree));

    root->no = i;



    if(2*i <= n) root->lchild = CreateBitree(2*i, n);

    else  root->lchild = NULL;



    if(2*i+1 <= n) root->rchild = CreateBitree(2*i+1, n);

    else root->rchild = NULL;



    return root;

}

/***********遍历*************/

void PreOrder(bitree *root)

{

    if(root == NULL)    return;



    printf("%d ", root->no);

    PreOrder(root->lchild);

    PreOrder(root->rchild);



    return;

}



void InOrder(bitree *root)

{

    if(root == NULL)    return;



    InOrder(root->lchild);

    printf("%d ", root->no);

    InOrder(root->rchild);



    return;

}



void PostOrder(bitree *root)

{

    if(root == NULL)    return;



    PostOrder(root->lchild);

    PostOrder(root->rchild);

    printf("%d ", root->no);



    return;

}

/***********按层次遍历**************/

void NoOrder(bitree *root)

{

    sequeue *sq;



    sq = CreateEmptySequeue();

    EnSequeue(sq, root);



    while(!EmptySequeue(sq))

    {

        root = DeSequeue(sq);

        printf("%d ", root->no);



        if(root->lchild != NULL)

            EnSequeue(sq, root->lchild);

        if(root->rchild != NULL)

            EnSequeue(sq, root->rchild);

    }

    return;

}





int main()

{

    bitree *root;



    root = CreateBitree(1, 10);

    

    printf(" PreOrder:");

    PreOrder(root);

    printf("\n");



    printf("  InOrder:");

    InOrder(root);

    printf("\n");



    printf("PostOrder:");

    PostOrder(root);

    printf("\n");



    printf("  NoOrder:");

    NoOrder(root);

    printf("\n");





    return 0;

}