数据结构-树与二叉树

树

树的定义:

树是一种非线性的数据结构,由一个结点引出多个分支,其逻辑关系为一对多

树的术语:

结点的度:

结点的分支数

树的度:

所有结点的度的最大值

叶子结点:

没有分支的结点

孩子结点:

双亲结点(父结点):

兄弟结点:

同一个双亲结点的孩子之间互为兄弟结点

子孙结点:

以某结点为根的子树中的所有结点都是子孙结点

祖先结点:

从根结点到某结点路径上的所有结点都为某结点的祖先结点

堂兄弟结点:

互为兄弟的双亲结点的孩子结点互为堂兄弟结点

树的高度或深度:

树的层数

结点的高度:

从下到上结点的层数

结点的深度:

从上到下结点的层数

树的存储结构:

双亲存储结构:

结构体定义:

typedef struct
{
     
	char data;
	int *PIdx;
}TNode;
TNode tree[maxSize];

链式存储结构:

(1)孩子存储结构
结构体定义:

typedef struct
{
     
	char data;
	Branch *first;
}TNode;
TNode tree[maxSize];

typedef struct Branch
{
     
	int cIdx;
	Branch *next;
}Branch;

(2)树的孩子兄弟存储结构

结构体定义:

typedef struct BTNode
{
     
	char data;
	BTNode *child;
	BTNode *siblings;
}BTNode;

树的遍历算法:

广度优先遍历:

从上至下,从左至右进行层次性遍历

广度优先遍历代码:

void level(TNode *t,TNode tree[])
{
     
	int front,rear;
	TNode *que[maxSize];
	front=rear=0;
	TNode *p;
	if(t!=NULL)
	{
     
		rear=(rear+1)%maxSize;
		que[rear]=t;
		while(front!=rear)
		{
     
			front=(front+1)%maxSize;
			p=que[front];
			visit(p);
			Branch *q=p->first;
			while(q!=NULL)
			{
     
				rear=(rear+1)%maxSize;
				que[rear]=&tree[q->cIdx];
				q=q->next;
			}
		}
	}
}

深度优先遍历:

先序遍历:第一次访问结点的顺序集
后序遍历:第二或第三次访问结点的顺序集

深度优先遍历代码:

void preOrder(TNode *p,TNode tree[])
{
     
	if(p!=NULL)
	{
     
		//先序
		Branch *q=p->first;
		while(q!=NULL)
		{
     
			preOrder(&tree[q->cIdx],tree);
			q=q->next;	
		}
		//后序
	}
}

二叉树

二叉树的定义:

两个限制条件:
1.每个结点最多只能有两棵子树
2.左右子树顺序不能颠倒

二叉树的性质:

二叉树性质的推导:

设叶子结点数为:N0,单分支结点数为N1，双分支结点数为N2
1.总结点数为N0+N1+N2
2.总分支数为N1+N2*2
3.总结点数=总分支数＋1
联立1.2.3.得:N0=N2+1
即叶子结点数=双分支结点数+1

二叉树性质的应用:

例如:若二叉树总结点数为N,则树中空指针数量为多少?
解法:
1.任意画一棵二叉树
2.为叶子结点添加空指针,并把这些空指针看成一个个新的叶子结点,此时二叉树就变成了满二叉树
3.在满二叉树里,叶子结点数=双分支结点数+1,而双分支结点数=原来二叉树的总结点数
结论:
空指针数=二叉树总结点数+1即树中空指针数量为N+1

满二叉树:

满二叉树的定义:

当所有分支结点的度都为2时为满二叉树，它是一种特殊的完全二叉树

满二叉树的规律:

树的高度(h)		结点的个数(n)
		1			1
		2			3
		3			7
		h-1			2^(h-1)-1
		h			2^h-1

完全二叉树:

完全二叉树的定义:

当满二叉树从右至左、从下至上删除结点时,能够得到新的完全二叉树
注:只能遵循从右至左、从下至上的结点删除顺序,否则得到的不是完全二叉树

完全二叉树的规律:

树的高度(h)		结点的个数(N)
		1			1
		2			1<N<=3
		3			3<N<=7
		h-1			2^(h-2)-1<N<=2^(h-1)-1
		h			2^(h-1)-1<N<=2^h-1

完全二叉树高度的两种推导方式(由满二叉树和完全二叉树的规律推导)

1.向下取整:

2^(h-1)-1<N<=2^h-1
2^(h-1)<=N<2^h
h-1<=log2 N<h
h-1=[log2 N]
即h=[log2 N]+1

2.向上取整:

2^(h-1)-1<N<=2^h-1
2^(h-1)<N+1<=2^h
h-1<log2 (N+1)<=h
h=[log2 (N+1)]

二叉树的存储结构:

顺序存储结构:

结构体定义:

typedef struct
{
     
	char data;
	int Idx;
}BTNode;
BTNode Btree[maxSize];

链式存储结构:

结构体定义:

typedef struct BTNode
{
     
	char data;
	BTNode *lchild;
	BTNode *rchild;
}BTNode;

二叉树的遍历算法:

广度优先遍历:

从上至下,从左至右进行层次性遍历

广度优先遍历代码:

void level(BTNode *bt)
{
     
	if(bt!=NULL)
	{
     
		int front,rear;
		BTNode *que[maxSize];
		front=rear=0;
		BTNode *p;
		rear=(rear+1)%maxSize;
		que[rear]=bt;
		while(front!=rear)
		{
     
			front=(front+1)%maxSize;
			p=que[front];
			visit(p);
			if(p->lchild!=NULL)
			{
     
				rear=(rear+1)%maxSize;
				que[rear]=p->lchild;
			}
			if(p->rchild!=NULL)
			{
     
				rear=(rear+1)%maxSize;
				que[rear]=p->rchild;
			}
		}
	}
}

深度优先遍历:

先序遍历:第一次访问结点的顺序集
中序遍历:第二次访问结点的顺序集
后序遍历:第三次访问结点的顺序集

深度优先遍历(递归代码):

void r(BTNode *p)
{
     
	if(p!=NULL)
	{
     
		//前序
		r(p->lchild);
		//中序
		visit(p);
		r(p->rchild);
		//后序
	}
}

深度优先遍历(非递归代码):

preorderNonrecursion(BTNode * bt)
{
     
	if(bt!=NULL)
	{
     
		BTNode *stack[maxSize];
		int top=-1;
		BTNode *p=NULL;
		stack[++top]=bt;
		while(top!=-1)
		{
     
			p=stack[top--];
			visit(p);
			if(p->rchild!=NULL) stack[++top]=p->rchild;
			if(p->lchild!=NULL) stack[++top]=p->lchild;	
		}
	}
}

线索二叉树

逻辑结构:

利用树中的空指针作为当前结点前驱或后继的线索,使得二叉树线索化

存储结构:

结构体定义:

typedef struct TBTNode
{
     
	int data;
	int lTag;
	int rTag;
	TBTNode *lchild;
	TBTNode *rchild;
}TBTNode;

前序线索化代码:

void preThread(TBTNode *P,TBTNode *&pre)
{
     
	if(p!=NULL)
	{
     
		if(p->lchild==NULL)
		{
     
			p->lchild=pre;
			p->lTag=1;
		}
		if(pre!=NULL&&pre->rChild==NULL)
		{
     
			p->rchild=p;
			p->rTag=1;
		}
		pre=p;
		if(p->lTag==0)inThread(p->lchild,pre);
		if(p->rTag==0)inThread(p->rChild,pre);
	}
}

中序线索化代码:

void inThread(TBTNode *P,TBTNode *&pre)
{
     
	if(p!=NULL)
	{
     
		inThread(p->lchild,pre);
		if(p->lchild==NULL)
		{
     
			p->lchild=pre;
			p->lTag=1;
		}
		if(pre!=NULL&&pre->rChild==NULL)
		{
     
			p->rchild=p;
			p->rTag=1;
		}
		pre=p;
		inThread(p->rChild,pre);
	}
}

后序线索化代码:

void postThread(TBTNode *P,TBTNode *&pre)
{
     
	if(p!=NULL)
	{
     
		inThread(p->lchild,pre);
		inThread(p->rChild,pre);
		if(p->lchild==NULL)
		{
     
			p->lchild=pre;
			p->lTag=1;
		}
		if(pre!=NULL&&pre->rChild==NULL)
		{
     
			p->rchild=p;
			p->rTag=1;
		}
		pre=p;
	}
}

哈夫曼树

编码问题:

例如:对S=AAABBACCCDEEA用哈夫曼树设计编码规则,使得编码后的字符串缩短

 A		B		C		D		E
000	   001	   010	   011	   100
不按哈夫曼树进行编码得到的字符串:
T(S)=000000000001001000010010010011100100000	

解法:
1.对每个字符建立一个结点,结点下面标出字符出现的个数,挑选两个值最小的结点,值相加并赋值给两个结点合成的新结点并入集合,重复操作:

A		C		B		E		D
5		3		2		2		1

							3
A		C		B		E		D
5		3		2			

					5
							3
A		C		B		E		D
5		3					

			8
					5
							3
A		C		B		E		D
						

	null
			8
   					5
							3
A		C		B		E		D					

2.将1得到的结点连接起来,也就成为了一棵二叉树，给左分支标记0,给右分支标记1,得到编码后的字符串

 A		B		C		D		E
 0	   110	    10	   1111	   1110
 按哈夫曼树进行编码得到的字符串:
 HFM(S)=00011011001010101111111011100	

3.很明显,按哈夫曼树进行编码我们能够得到一个比较短的字符串,
并且某字符出现次数越多,该字符离树的根结点距离就越近,字符对应的二进制码也就越小
此外:
刚才编码的过程是围绕哈夫曼树进行的,因此解码的过程同样也需要围绕哈夫曼树进行.

从左往右扫描二进制串
1.从根结点出发,扫描到'0'为A   
2.从根结点出发,扫描'110'为B
3.从根结点出发,扫描'10'为C
4.从根结点出发,扫描'1111'为D
5.从根结点出发,扫描'1110'为E

一些定义:

树的路径长度:

从根到每个结点的路径长度之和

带权路径长度:

结点具有权值,从该结点到根结点之间的路径长度乘以结点的权值(如上述讲到的某字符结点的次数)

哈夫曼树的特点:

1.权值越大的结点,距离根结点越近
2.树中只有度为0或2的结点,这类树又叫做正则二叉树,满二叉树也是其中特殊的一种
3.树的带权路径长度最短

哈夫曼n叉树:

编码规则:

对每个字符建立一个结点,结点下面标出字符出现的个数(若字符串不够长,补足权值为0的字符结点),挑选n个值最小的结点,值相加并赋值给n个结点合成的新结点并入集合,重复操作: