数据结构--二叉树（代码实现）

一、概念

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

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

二、存储结构、

二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址 。

三、二叉树的性质

若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有2^(i-1) 个结点.

若规定根节点的层数为1，则深度为h的二叉树的最大结点数是2^h- 1.

对任何一棵二叉树, 如果度为0其叶结点个数为 n0, 度为2的分支结点个数为 n2,则有n0＝n2＋1

若规定根节点的层数为1，具有n个结点的满二叉树的深度，h=Log2(n+1). (ps：Log2(n+1)是log以2为
底，n+1为对数)

对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对
于序号为i的结点有：   

   1. 若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点
   2. 若2i+1<n，左孩子序号：2i+1，2i+1>=n否则无左孩子
   3. 若2i+2<n，右孩子序号：2i+2，2i+2>=n否则无右孩子

四、二叉树的遍历

NLR：前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
LNR：中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
LRN：后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。
由于被访问的结点必是某子树的根，所以N(Node）、L(Left subtree）和R(Right subtree）又可解释为根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。

层序遍历：除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。
五、代码实现

#ifndef _TREE_H_
#define _TREE_H_

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

#define  M  32
#define  N  10
typedef int data_t;

struct tree
{
	struct tree *lchild;
	data_t data;
	struct tree *rchild;
};

typedef struct tree TREE;

TREE *CreateRoot();
void InsertTree(TREE *root,data_t *p,int size);
void PerOrder(TREE *r);
void InOrder(TREE *r);
void PostOrder(TREE *r);
void NoOrder(TREE *r);
#endif

#include "tree.h"

TREE *CreateRoot(void)
{
	TREE *p = (TREE *)malloc(sizeof(TREE));
	if(NULL == p)
	{
		printf("开辟根节点空间失败!\n");
		return NULL;	
	}
	memset(p,0,sizeof(TREE));
	return p;
}

void InsertTree(TREE *root,data_t *p,int size)
{
	if(NULL == root)
	{
		printf("二叉树不存在!\n");
		return;	
	}

	root->data = p[0];

	int i = 0;
	for(i = 1;i < size;i++)
	{
		//1、创建新节点
		TREE *node = (TREE *)malloc(sizeof(TREE));
		if(NULL == node)
		{
			printf("开辟新节点空间失败!\n");
			return;	
		}
		memset(node,0,sizeof(TREE));
		node->data = p[i];

		//2、查找新节点插入位置，将新节点放入二叉树
        TREE *tmp = root;//因为每次查找位置都是从根节点出发，所以不能让根节点指针发生偏移
		while(1)
		{
			if(node->data < tmp->data)
			{
				if(tmp->lchild == NULL)
				{
					tmp->lchild = node;
					break;
				}
				else
				{
					tmp = tmp->lchild;
				}
			}
			else//node->data >= tmp->data
			{
				if(tmp->rchild == NULL)
				{
					tmp->rchild = node;
					break;
				}
				else
				{
					tmp = tmp->rchild;
				}			
			}
		}
	}
}

void PerOrder(TREE *r) 
{
    if(r == NULL) 
	{
		return;     //空树返回
    }
	printf("%d ",r->data);      //先访问当前结点
    PerOrder(r->lchild);        //再访问该结点的左子树
    PerOrder(r->rchild);        //最后访问该结点右子树
}

void InOrder(TREE *r) 
{
    if(r == NULL) 
	{
		return;     //空树返回
    }  
  
	InOrder(r->lchild);        //先访问该结点的左子树
	printf("%d ",r->data);     //再访问当前结点
    InOrder(r->rchild);        //最后访问该结点右子树
}

void PostOrder(TREE *r) 
{
    if(r == NULL) 
	{
		return;     //空树返回
    }  
  
	PostOrder(r->lchild);        //先访问该结点的左子树
    PostOrder(r->rchild);        //再访问该结点右子树
	printf("%d ",r->data);       //最后访问当前结点
}

void NoOrder(TREE *r)
{
	int front,rear;
    TREE * Q[M];
	if(r == NULL)
	{
		return;
	}

	for(rear = 1;rear < M;rear++)
	{
		Q[rear] = NULL;
	}

	front = rear = 1;
	Q[rear] = r;
	while(Q[front] != NULL)
	{
		printf("%d ",Q[front]->data);
		if(Q[front]->lchild != NULL)
		{
			rear++;
			Q[rear] = Q[front]->lchild;
		}

		if(Q[front]->rchild != NULL)
		{
			rear++;
			Q[rear] = Q[front]->rchild;
		}
		front++;
	}
}

#include "tree.h"

int main()
{
	TREE *head = CreateRoot();
	if(NULL == head)
	{
		perror("二叉树根节点创建失败!");
		return -1;
	}
	printf("二叉树根节点创建成功!\n");	

	data_t arr[N] = {66,55,22,44,33,88,77,99,11,100};

	InsertTree(head,arr,N);

	printf("先序遍历:");
	PerOrder(head);
	printf("\n");

	printf("中序遍历:");
	InOrder(head);
	printf("\n");

	printf("后序遍历:");
	PostOrder(head);
	printf("\n");

	printf("层次遍历:");
	NoOrder(head);
	printf("\n");

	return 0;
}

Makefile： 

TARGET=tree
CC=gcc
OBJS=main.c tree.c

$(TARGET):$(OBJS)
	$(CC) $^ -o  $@  -g


clean:
	rm *~
	rm $(TARGET)

结果： 

huqin@ubuntu:/mnt/hgfs/share/code/2021/mon11/week1/tree$ ./tree
二叉树根节点创建成功!
先序遍历:66 55 22 11 44 33 88 77 99 100
中序遍历:11 22 33 44 55 66 77 88 99 100
后序遍历:11 33 44 22 55 77 100 99 88 66
层次遍历:66 55 88 22 77 99 11 44 100 33