数据结构——二叉树总结

二叉树的逻辑结构

一、二叉树的定义

二叉树是n（n≥0）个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树的二叉树组成。
二叉树的特点：注意：二叉树和树是两种不同的树结构。
⑴ 每个结点最多有两棵子树；所以不存在度大于2的结点
⑵ 二叉树是有序的，不能任意颠倒。如果某结点只有一颗子树，一定指明它是左子树还是右子树。
特殊的二叉树
一、斜树
1.所有结点都只有左子树的二叉树称为左斜树。
2.所有结点都只有右子树的二叉树称为右斜树。
3.左斜树和右斜树统称为斜树。
斜树的特点：
1.每一层只有一个结点。
2.斜树的结点个数与其深度相同。
二、满二叉树
在一棵二叉树中，如果所有分支结点都存在左子树和右子树，并且所有叶子都在同一层上。
满二叉树的特点：
1.叶子只能出现在最下一层。
2.只有度为0和度为2的结点。
3.在同样深度的二叉树中结点个数最多
4.在同样深度的二叉树中叶子结点个数最多
三、完全二叉树
对一棵具有n个结点的二叉树按层序编号，如果编号为i（1≤i≤n）的结点与同样深度的满二叉树中编号为i的结点在二叉树中的位置完全相同。
在满二叉树中，从最后一个结点开始，连续删去若干结点，即是一棵完全二叉树。
完全二叉树的特点：
1.叶子结点只能出现在最下两层，且最下层的叶子结点都集中在二叉树的左部；
2.完全二叉树中如果有度为1的结点，只可能有一个，且该结点只有左孩子。
3.深度为k的完全二叉树在k-1层上一定是满二叉树。

二、二叉树的基本性质

性质1 二叉树的第i层上最多有2*(i-1)（2的i-1次方）个结点（i≥1）。
性质2 一棵深度为k的二叉树中，最多有2*k-1（2的k次方）个结点，最少有k个结点。
性质3 在一棵二叉树中，如果叶子结点数为n0，度为2的结点数为n2，则有: n0＝n2＋1。
性质4 具有n个结点的完全二叉树的深度为 log2n（以2为底n的对数向下取整）+1。
性质5 对一棵具有n个结点的完全二叉树中从1开始按层序编号，则对于任意的序号为i（1≤i≤n）的结点（简称为结点i），有：
(1)如果i＞1，则结点i的双亲结点的序号为 i/2(向下取整)；否则结点i是根结点，无双亲结点。
(2)如果2i≤n，则结点i的左孩子的序号为2i；如果2i＞n，则结点i无左孩子。
(3)如果2i＋1≤n，则结点i的右孩子的序号为2i＋1；如果2i＋1＞n，则结点 i无右孩子。

对一棵具有n个结点的完全二叉树中从1开始按层序编号，则
1.结点i的双亲结点为 i/2；
2.结点i的左孩子为2i；
3.结点i的右孩子为2i＋1。

三、二叉树的遍历操作

一、前序遍历
若二叉树为空，则空操作返回；否则：
(1)访问根结点；
(2)前序遍历根结点的左子树；
(3)前序遍历根结点的右子树。
前序遍历序列：A B D G C E F
二、中序遍历
若二叉树为空，则空操作返回；否则：
(1)中序遍历根结点的左子树；
(2)访问根结点；
(3)中序遍历根结点的右子树。
中序遍历序列：D G B A E C F
三、后序遍历
若二叉树为空，则空操作返回；否则：
(1)后序遍历根结点的左子树；
(2)后序遍历根结点的右子树。
(3)访问根结点；
后序遍历序列：G D B E F C A
四、层序遍历
二叉树的层次遍历是指从二叉树的第一层（即根结点）开始，从上至下逐层遍历，在同一层中，则按从左到右的顺序对结点逐个访问。
层序遍历序列：A B C D E F G

前序遍历和中序遍历能确定唯一一颗二叉树。
后序遍历和中序遍历能确定唯一一颗二叉树。
从前序和后序找根结点从中序找左右子树。

如前序ABCDEFGH中序CDBAFEHG
根结点A 左子树CDB 右子树FEHG
左子树根结点B 左子树的左子树CD 左子树的右子树无
右子树根结点E 右子树的左子树F 右子树的右子树HG
依次类推确定一颗二叉树
后序和中序同样，后序从最后找根结点

二叉树的存储结构

一、顺序存储结构

用一维数组存储二叉树中的结点，并且结点的存储位置（下标）应能体现结点之间的逻辑关系——父子关系。

#include<iostream>
#include<memory.h>
using namespace std;
//递归实现
void Preorder(int root, char data[]){//前序遍历
	if(data[root]!='\0'){
		cout<<data[root] ;
		Preorder(2*root,data);//访问左子树
		Preorder(2*root+1,data);//访问右子树
	}
	return;
}

void InOrder(int root, char data[]){//中序遍历
	if(data[root]!='\0'){
		InOrder(2*root,data);//访问左子树
		cout<<data[root];
		InOrder(2*root+1,data);//访问右子树
	}
	return;
}

void PostOrder(int root, char data[]){//后序遍历
	if(data[root]!='\0'){
		 PostOrder(2*root,data);//访问左子树
		 PostOrder(2*root+1,data);//访问右子树
		cout<<data[root];
	}
	return;
}
//创建二叉树
void create(char preorder[],char inorder[],int start_p, int end_p,int start_i,int end_i, char data[],int root){
	if(start_p>end_p)
		return ;
	else{
		int k;
		for(int i=start_i;i<=end_i;i++){
			if(inorder[i]==preorder[start_p]){
				k=i;
				break;
			}
		}
		data[root]=preorder[start_p];
		create(preorder,inorder,start_p+1,start_p+k-start_i,start_i,k-1,data, 2*root);
		create(preorder,inorder,start_p+k-start_i+1,end_p,k+1,end_i,data,2*root+1);
	}
	return ;
}
int main(){   
    char * data;
	int total=1;
	char preorder[100],inorder[100];
	cin>>preorder>>inorder;
	int length=0;
	while(preorder[length]!='\0')
		length++;
	data=new char[int(pow(2,length+1))];
	memset(data,'\0',pow(2,length+1));
	create(preorder,inorder,0,length-1,0,length-1,data,1);
	PostOrder(1,data);
	return 0;
}

二、二叉链表

基本思想：
令二叉树的每个结点对应一个链表结点，链表结点除了存放与二叉树结点有关的数据信息外，还要设置指示左右孩子的指针。
data：数据域，存放该结点的数据信息；
lchild：左指针域，存放指向左孩子的指针；
rchild：右指针域，存放指向右孩子的指针。

#include<iostream>
template <class T>
struct BiNode
{
    T data;
    BiNode<T> *lchild, *rchild;
};

template <class T>
class BiTree
{
public:
	BiTree(); 
    ~BiTree( );            
    void PreOrder(){PreOrder(root);} 
    void InOrder() {InOrder(root);} 
    void PostOrder() {PostOrder(root);} 
    void LevelOrder(){LeverOrder(root)};
private:
	BiNode<T> *root; 
    BiNode<T> * Creat( ); 
    void Release(BiNode<T> *root);
    void PreOrder(BiNode<T> *root); 
    void InOrder(BiNode<T> *root); 
    void PostOrder(BiNode<T> *root); 
    void LevelOrder(BiNode<T> *root);
 };
 //递归实现
template<class T>
void   BiTree::PreOrder(BiNode<T> *root)//前序遍历
{
	if (root==NULL)  return;     
    else{
    	cout<<root->data;         
        PreOrder(root->lchild);    
        PreOrder(root->rchild);	
    }
}

template <class T>
void BiTree::InOrder (BiNode<T> *root)//中序遍历
{
         if (root==NULL) return;     
         else {
               InOrder(root->lchild); 
               cout<<root->data; 
               InOrder(root->rchild);
         }
}
template <class T>
void BiTree::PostOrder(BiNode<T> *root)//后序遍历
{ 
    if (root==NULL) return; 
    else {
         PostOrder(root->lchild); 
         PostOrder(root->rchild); 
         cout<<root->data;          
    }
}

template <class T>
BiTree ::BiTree(){ 
      root=creat()；
}
/*
为了建立一棵二叉树，
将二叉树中每个结点的空指针引出一个虚结点，
其值为一特定值如“#”，
以标识其为空，
把这样处理后的二叉树称为原二叉树的扩展二叉树。
1.按扩展前序遍历序列输入结点的值
2.如果输入结点值为“#”,则建立一棵空的子树
3.否则，根结点申请空间，将输入值写入数据域中，
4.以相同方法的创建根结点的左子树
5.以相同的方法创建根结点的右子树
递归方法
*/
template <class T>
BiNode<T> * BiTree ::Creat(){
	BiNode<T> *root; char ch;
    cin>>ch;
    if (ch=='#') root=NULL; 
    else {
        root=new BiNode<T>; 
        root->data=ch;
        root->lchild=creat(); 
        root->rchild= creat(); 
    }
    return root
}

template<class T>
void BiTree<T>::Release(BiNode<T>* root){
if (root != NULL){                  
      Release(root->lchild);//释放左子树
      Release(root->rchild);//释放右子树
      delete root;
   }  
}

template<class T>
BiTree<T>::~BiTree(void)
{
	Release(root);
}
int mian()
{
	BiTree<char>T();
	T.PreOrder();
	``````
	return 0;
}