二叉树

递归定义：树(Tree)是n(n>=0)个结点的有限集T，T为空时称为空树，否则它满足如下两个条件：

 1）有且仅有一个特定的称为根(Root)的结点；

 2）其余的结点可分为m(m>=0)个互不相交的子集T1,T2,T3…Tm，其中每个子集又是一棵树，并称其为子树(Subtree)。

树的基本术语：

根           —树中唯一没有前驱的结点。

度           —一个结点的子树的数目，称为结点的度。树中结点的度的最大值，称为树的度。

叶           —度为0的结点，也称为终端结点。

分枝结点—度大于0的结点称为分支结点或非终端结点（分为单分支结点、双分支结点等等）。

二叉树   —每个结点至多只有两棵子树

性质1：         在二叉树的第i层上至多有2i-1个结点(i>=1)

性质2：         深度为k的二叉树至多有2k－1个结点（k>=1)

性质3：         对任何一棵二叉树，如果其终端结点数为n0，度为2的结点数为n2，则n0＝n2＋1

性质4：         具有n个结点的完全二叉树的深度为ëlog2nû＋1

满二叉树：    一棵深度为k且有2^k-1个结点的二叉树

完全二叉树：如果深度为k、由n个结点的二叉树中个结点能够与深度为k的顺序编号的满二叉树从1到n标号的结点相对应

先序遍历：先遍历根节点，再遍历左子树，最后遍历右子树

中序遍历：先遍历左子树，再遍历根节点，最后遍历右子树

后序遍历：先遍历左子树，再遍历右子树，最后遍历根节点

//binaryTree.h
#ifndef _BINARY_TREE_H_
#define _BINARY_TREE_H_
#include<stdio.h>
#include<stdlib.h>
#include<memory.h>

#define MAX_SIZE 100

typedef struct BiTNode
{
  char data;
  struct BiTNode *lChild;
  struct BiTNode *rChild;
}Node,*pBiTNode,*BiTree;


typedef struct stack
{
	pBiTNode stack_Arr[MAX_SIZE];
	int top;
}STACK;


int preOrderCreateBitTree(pBiTNode *pRoot); 
pBiTNode inOrderCreateBitTree(pBiTNode *pRoot); 
int postOrderCreateBitTree(pBiTNode *pRoot);
pBiTNode preOrderTraverse(pBiTNode root);
pBiTNode inOrderTraverse(pBiTNode root);
pBiTNode postOrderTraverse(pBiTNode root);
pBiTNode Traverse(pBiTNode root);

void initStack(STACK *p);
int push(STACK *p,pBiTNode node);
int pop(STACK *p);
pBiTNode stackTop(STACK *);
int isEmpty(STACK *);
int isFull(STACK *);

#endif

#include"binaryTree.h"

void initStack(STACK *p)
{
	p->top=-1;
}
int isEmpty(STACK *p)
{
  if(p->top==-1)
	  return 1;
  else
	  return 0;
}
int isFull(STACK *p)
{
	if(p->top == MAX_SIZE-1)
		return 1;
	else
		return 0;
}

int push(STACK *p,pBiTNode node)
{
  if(isFull(p)==1)
	  return -1;
  p->top++;
  p->stack_Arr[p->top]=node;
  return 0;
}

int pop(STACK *p)
{
  if(isEmpty(p)==1)
	  return -1;
  p->stack_Arr[p->top]=NULL;
  p->top--;
  return 0;
}

pBiTNode stackTop(STACK *p)
{
  if(isEmpty(p)==1)
	  return NULL;
  return p->stack_Arr[p->top];
}

//binaryTree.c
#include "binaryTree.h"

int preOrderCreateBitTree(pBiTNode *pRoot)
{
	
	char c;
	printf("if you want stop create node input 'q':\n");
	fflush(stdin);
	c=getchar();
	if(c=='q')
		return 0;
	
	//1.先序创建根节点并赋值
	*pRoot=(pBiTNode)malloc(sizeof(Node));
	if(NULL == pRoot)
	{
		printf("root node malloc failed!\n");
		exit(-1);
	}
	memset(*pRoot,0,sizeof(Node));
	(*pRoot)->data=c;
	//2.先序创建左子树
	preOrderCreateBitTree(&(*pRoot)->lChild);
	//3.先序创建右子树
    preOrderCreateBitTree(&(*pRoot)->rChild);
	return 0;
}

pBiTNode preOrderTraverse(pBiTNode root)
{
	if(root==NULL)
	{
		printf("This is A NULL Tree!\n");
		return NULL;
	}
	printf("%c\n",root->data);  
	preOrderTraverse(root->lChild);	
	preOrderTraverse(root->rChild);
	return root;
}

pBiTNode inOrderTraverse(pBiTNode root)
{
	if(root)
	{
		inOrderTraverse(root->lChild);
		printf("%c\n",root->data);    
		inOrderTraverse(root->rChild);
	}
	else
	{
        printf("This is A NULL Tree!\n");
	}
	return root;
}

pBiTNode postOrderTraverse(pBiTNode root)
{
	if(root)
	{
		postOrderTraverse(root->lChild);	
		postOrderTraverse(root->rChild);
		printf("%c\n",root->data);    
	}
	else
	{
        printf("This is A NULL Tree!\n");
	}
	return root;
}

pBiTNode Traverse(pBiTNode root)
{
	pBiTNode  pTemp=NULL;
	STACK *sta=(STACK *)malloc(sizeof(STACK));
	if(sta==NULL||root==NULL)
		return NULL;
	initStack(sta);
	push(sta,root);

	while(!isEmpty(sta))//栈不为空
	{
      pTemp=stackTop(sta);
	  pop(sta);
	  printf("%-3c",pTemp->data);
      if(pTemp->rChild!=NULL)
	  {
		  push(sta,pTemp->rChild);
	  }
	  if(pTemp->lChild!=NULL)
	  {
         push(sta,pTemp->lChild);
	  }
	}
	return root;
}

//main.c
#include "binaryTree.h"

void main()
{
	pBiTNode root=NULL;

	int res=preOrderCreateBitTree(&root);
    if(res)
	{
		printf("create tree failed!\n");
		exit(-1);
	}
	Traverse(root);
	//postOrderCreateBitTree(&root);
	//preOrderTraverse(root);
	//inOrderTraver(root);
	//postOrderTraver(root);
	system("pause");
}

源码下载 点击打开链接