二叉树

一、二叉树的概念
一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵分别称为左子树和右子树组成。

二、二叉树的特点
1、每个结点最多有两棵子树，即二叉树不存在度大于2的结点。
2、二叉树的子树有左右之分，其子树的次序不能颠倒。

三、二叉树的表示方法
1、双亲表示法
2、孩子表示法
3、双亲孩子表示法
4、孩子兄弟表示法

四、二叉树的遍历
遵循某种次序，遍历二叉树中的所有节点，使得每个结点被访问一次，而且仅访问一次。“访问”：即对结点施行某些操作。二叉树的遍历有四种顺序。
1、先序：先访问根结点，再访问左子树，最后访问右子树。
2、中序：先访问左子树，再访问根结点，最后访问右子树。
3、后序：先访问左子树，再访问右子树，最后访问根结点。
4、层序：按照二叉树的每一层从左到右一次排列。
下面我举个例子

先序：A B D E G C F
中序：D B G E A C F
后序：D G E B F C A
层序：A B C D E F G
下面我们用代码来实现一个用孩子表示法来表示的二叉树的基本操作。

.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
typedef char TreeNodeType;
typedef struct TreeNode
{
    TreeNodeType data;
    struct TreeNode* lchild;
    struct TreeNode* rchild;
}TreeNode;
void TreePreOrder(TreeNode* root);
void TreeInOrder(TreeNode* root);
void TreePostOrder(TreeNode* root);
void TreeLevelOrder(TreeNode* root);

1、先序

void TreePreOrder(TreeNode* root)   //先序遍历
{
    if(root == NULL)
    {
        return;
    }
    printf("%c",root->data);
    TreePreOrder(root->lchild);
    TreePreOrder(root->rchild);
    return;
}

测试函数

void test_TreePreOrder()
{
    printf("#######先序#######\n");
    TreeNode* A = TreeNodeCreat('a');
    TreeNode* B = TreeNodeCreat('b');
    TreeNode* C = TreeNodeCreat('c');
    TreeNode* D = TreeNodeCreat('d');
    TreeNode* E = TreeNodeCreat('e');
    TreeNode* F = TreeNodeCreat('f');
    TreeNode* G = TreeNodeCreat('g');
    A->lchild = B;
    A->rchild = C;
    B->lchild = D;
    B->rchild = E;
    C->rchild = F;
    E->lchild = G;
    TreePreOrder(A);
    printf("\n");

}

2、中序

void TreeInOrder(TreeNode* root)
{
    if(root == NULL)
    {
        return;
    }
    TreeInOrder(root->lchild);
    printf("%c",root->data);
    TreeInOrder(root->rchild);
    return;
}

测试函数

void test_TreeInOrder()
{
    printf("#######中序#######\n");
    TreeNode* A = TreeNodeCreat('a');
    TreeNode* B = TreeNodeCreat('b');
    TreeNode* C = TreeNodeCreat('c');
    TreeNode* D = TreeNodeCreat('d');
    TreeNode* E = TreeNodeCreat('e');
    TreeNode* F = TreeNodeCreat('f');
    TreeNode* G = TreeNodeCreat('g');
    A->lchild = B;
    A->rchild = C;
    B->lchild = D;
    B->rchild = E;
    C->rchild = F;
    E->lchild = G;
    TreeInOrder(A);
    printf("\n");
}

3、后序

void TreePostOrder(TreeNode* root)
{
    if(root == NULL)
    {
        return;
    }
    TreePostOrder(root->lchild);
    TreePostOrder(root->rchild);
    printf("%c",root->data);
    return;
}

测试函数

void test_TreePostOrder()
{
    printf("#######后序#######\n");
    TreeNode* A = TreeNodeCreat('a');
    TreeNode* B = TreeNodeCreat('b');
    TreeNode* C = TreeNodeCreat('c');
    TreeNode* D = TreeNodeCreat('d');
    TreeNode* E = TreeNodeCreat('e');
    TreeNode* F = TreeNodeCreat('f');
    TreeNode* G = TreeNodeCreat('g');
    A->lchild = B;
    A->rchild = C;
    B->lchild = D;
    B->rchild = E;
    C->rchild = F;
    E->lchild = G;
    TreePostOrder(A);
    printf("\n");
}

4、层序

void TreeLevelOrder(TreeNode* root)
{
    if(root == NULL)
    {
        return;
    }
    SeqQueue queue;
    SeqQueueInit(&queue);
    SeqQueuePush(&queue,root);
    while(1)
    {
        SeqQueueType front;
        int ret = SeqQueueGetFront(&queue,&front);
        if(ret == 0)
        {
            break;
        }
        printf("%c",front->data);
        SeqQueuePop(&queue);
        if(front->lchild != NULL)
        {
            SeqQueuePush(&queue,front->lchild);
        }
        if(front->rchild != NULL)
        {
            SeqQueuePush(&queue,front->rchild);
        }
    }
}

测试函数

void test_TreeLevelOrder()
{
    FOR_BINTREE;
    printf("#######层序#######\n");
    TreeNode* A = TreeNodeCreat('a');
    TreeNode* B = TreeNodeCreat('b');
    TreeNode* C = TreeNodeCreat('c');
    TreeNode* D = TreeNodeCreat('d');
    TreeNode* E = TreeNodeCreat('e');
    TreeNode* F = TreeNodeCreat('f');
    TreeNode* G = TreeNodeCreat('g');
    A->lchild = B;
    A->rchild = C;
    B->lchild = D;
    B->rchild = E;
    C->rchild = F;
    E->lchild = G;
    TreeLevelOrder(A);
    printf("\n");