第五章 树与二叉树 学习总结

最新推荐文章于 2023-11-11 22:58:47 发布
最新推荐文章于 2023-11-11 22:58:47 发布
阅读量716 收藏 8
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dat_stick/article/details/103252433
版权
一、树的逻辑结构
树的定义：

树：n（n≥0）个结点的有限集合。
当n＝0时，称为空树；
任意一棵非空树满足以下条件：
⑴ 有且仅有一个特定的称为根的结点；
⑵ 当n＞1时，除根结点之外的其余结点被分成m（m>0）个互不相交的有限集合T1,T2,… ,Tm，其中每个集合又是一棵树，并称为这个根结点的子树

树的定义可采用递归方法或非递归方法

树的基本术语：

①结点的度：结点所拥有的子树的个数。
②树的度：树中各结点度的最大值。
③叶子结点：度为0的结点，也称为终端结点。
④分支结点：度不为0的结点，也称为非终端结点。
⑤孩子、双亲：树中某结点子树的根结点称为这个结点的孩子结点，这个结点称为它孩子结点的双亲结点；
⑥兄弟：具有同一个双亲的孩子结点互称为兄弟。
⑦路径：如果树的结点序列n1, n2, …, nk有如下关系：结点ni是ni+1的双亲（1<=i<k），则把n1, n2, …, nk称为一条由n1至nk的路径；路径上经过的边的个数称为路径长度。
⑧祖先、子孙：在树中，如果有一条路径从结点x到结点y，那么x就称为y的祖先，而y称为x的子孙。
⑨结点所在层数：根结点的层数为1；对其余任何结点，若某结点在第k层，则其孩子结点在第k+1层。
⑩树的深度：树中所有结点的最大层数，也称高度。

树的功能的实现：

树的遍历：从根结点出发，按照某种次序访问树中所有结点，使得每个结点被访问一次且仅被访问一次。
可划分为：前序遍历、后续遍历、层序遍历。

前序遍历：
若树为空，不进行遍历；否则
⑴ 访问根结点；
⑵ 按照从左到右的顺序前序遍历根结点的每一棵子树。

后续遍历
若树为空，则遍历结束；否则
⑴ 按照从左到右的顺序后序遍历根结点的每一棵子树；
⑵ 访问根结点。

层序遍历
从树的第一层（即根结点）开始，自上而下逐层遍历，在同一层中，按从左到右的顺序对结点逐个访问。

二、树的存储结构
双亲表示法

基本思想：
用一维数组来存储树的各个结点（一般按层序存储），
数组中的一个元素对应树中的一个结点，
每个结点记录两类信息：结点的数据信息以及该结点的双亲在数组中的下标。

dataparent

data：存储树中结点的数据信息
parent：存储该结点的双亲在数组中的下标

双亲表示法中结点数据类型的定义：

template <class T>
struct PNode{
     T data;          //数据域
     int parent;   //指针域，双亲在数组中的下标
} ;

可定义根节点的parent为“-1”，并依次定义接下来的数组。
还可增添“firstchild”或“rightsib”从而可以更方便的查找孩子节点、兄弟节点的位置及数据。

孩子表示法-多重链表表示法（节点中的指针域表示孩子）

实现：链表中的每个结点包括一个数据域和多个指针域，每个指针域指向该结点的一个孩子结点。

方案一：指针域的个数等于树的度

datachild1child2…childd

data：数据域，存放该结点的数据信息；
child1~childd：指针域，指向该结点的孩子。
缺点：浪费空间
方案二：指针域的个数等于该结点的度

datadegreechild1child2child3…childd

data：数据域，存放该结点的数据信息；
degree：度域，存放该结点的度；
child1~childd：指针域，指向该结点的孩子。
缺点：结点结构不一致

孩子表示法-孩子链表表示法（每个节点创建一个单链表）

把每个结点的孩子排列起来，看成是一个线性表，且以单链表存储，则n个结点共有 n 个孩子链表。
这 n 个单链表共有 n 个头指针，这 n 个头指针又组成了一个线性表。
为了便于进行查找采用顺序存储存储每个链表的头指针。
最后，将存放 n 个头指针的数组和存放n个结点的数组结合起来，构成孩子链表的表头数组。
孩子链表表示法的实现：
孩子节点

struct CTNode
{   
     int child;
     CTNode *next;
};

表头节点

template <class T>
struct CBNode
{     
    T data;
    CTNode *firstchild;  
};
孩子兄弟表示法
firstchilddatarightsib

data：数据域，存储该结点的数据信息；
firstchild：指针域，指向该结点第一个孩子；
rightsib：指针域，指向该结点的右兄弟结点。

template   <class T>
struct TNode{
     T data;
     TNode <T> *firstchild, *rightsib;
};
树的存储结构小结

顺序存储（本质上是静态指针）:
双亲表示法
双亲、孩子表示法
链式存储：
多重链表示法
孩子链表表示法
孩子兄弟表示法

二叉树的逻辑结构

定义：二叉树是n（n≥0）个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树的二叉树组成。
二叉树的特点：
⑴ 每个结点最多有两棵子树；
⑵ 二叉树是有序的，其次序不能任意颠倒。
二叉树的基本性质
1、二叉树的第i层上最多有2i-1个结点（i≥1）。
2、一棵深度为k的二叉树中，最多有2k-1个结点，最少有k个结点。
3、在一棵二叉树中，如果叶子结点数为n0，度为2的结点数为n2，则有: n0＝n2＋1。
4 、具有n个结点的完全二叉树的深度为 log2n +1。
5 、对一棵具有n个结点的完全二叉树中从1开始按层序编号，则对于任意的序号为i（1≤i≤n）的结点（简称为结点i），有：
（1）如果i＞1，
则结点i的双亲结点的序号为 i/2；如果i＝1，
则结点i是根结点，无双亲结点。
(2)如果2i≤n，
则结点i的左孩子的序号为2i；
如果2i＞n，则结点i无左孩子。
(3)如果2i＋1≤n，
则结点i的右孩子的序号为2i＋1；如果2i＋1＞n，则结点 i无右孩子。

二叉树的遍历操作

前序遍历
中序遍历
后序遍历
层序遍历

前序（根）遍历
若二叉树为空，则空操作返回；否则：
①访问根结点；
②前序遍历根结点的左子树；
③前序遍历根结点的右子树
中序（根）遍历
若二叉树为空，则空操作返回；否则：
①中序遍历根结点的左子树；
②访问根结点；
③中序遍历根结点的右子树。
后序（根）遍历
若二叉树为空，则空操作返回；否则：
①后序遍历根结点的左子树；
②后序遍历根结点的右子树。
③访问根结点；
层序遍历
二叉树的层次遍历是指从二叉树的第一层（即根结点）开始，从上至下逐层遍历，在同一层中，则按从左到右的顺序对结点逐个访问。

二叉树的存储结构及实现

1、按照完全二叉树编号
2、以编号为下标
3、空的地方赋空
前序存储：

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;
}
二叉链表

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

lchilddatarchild

data：数据域，存放该结点的数据信息；
lchild：左指针域，存放指向左孩子的指针；
rchild：右指针域，存放指向右孩子的指针。
实现：

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);

具体算法实现：
前序遍历：
1、前序遍历——递归算法

template<class T>
void BiTree::PreOrder(BiNode<T> *root) 
{
        if (root ==NULL)  return;     
        else {
            cout<<root->data;         
            PreOrder(root->lchild);    
            PreOrder(root->rchild);    
        }
 }

2、前序遍历——非递归算法
思想：
遇到一个结点，就访问该结点，并把此结点推入栈中，然后遍历它的左子树；
遍历完它的左子树后，从栈顶托出这个结点，并按照它的右链接指示的地址再去遍历该结点的右子树结构。
伪代码：
1.栈s初始化（空栈）；
2.循环直到root为空且栈s为空
　2.1 当root不空时循环
　　2.1.1 输出root->data;
　2.1.2 将指针root的值保存到栈中；
　2.1.3 继续遍历root的左子树（root=root->lchild）
　2.2 如果栈s不空，则
　　2.2.1 将栈顶元素弹出至root（root=s.pop()）；
　　2.2.2 准备遍历root的右子树(root=root->rchild)；
　　
代码实现：

template <class T>
void BiTree::PreOrder(BiNode<T> *root) {
  SeqStack<BiNode<T> *>  s;
     while (root!=NULL | | !s.empty()) {
         while (root!= NULL)  {
             cout<<root->data;
             s.push（root）;
             root=root->lchild;  
         }
         if (!s.empty()) { 
             root=s.pop();
             root=root->rchild;  
         }
     }
}

3、前序遍历建立二叉树
思想：为了建立一棵二叉树，将二叉树中每个结点的空指针引出一个虚结点，其值为一特定值如“#”，以标识其为空，把这样处理后的二叉树称为原二叉树的扩展二叉树。
代码实现：

template <class T>
BiTree ::BiTree(){ 
      root=creat()；
}

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
}

中序遍历
1、中序遍历——递归算法
template
void BiTree::InOrder (BiNode *root)
{
if (root==NULL) return;
else {
InOrder(root->lchild);
cout<data;
InOrder(root->rchild);
}
}
2、中序遍历——非递归算法

template <class T>
void BiTree::InOrderwithoutD (BiNode<T> *root)
	 {
     	stack<BiNode<T>*> aStack;
     	while(!aStack.empty()||root) {
     	while(root)
     	{
           aStack.push(root);
           root=root->lchild;
        }
          if(!aStack.empty()){
		      root=aStack.top();				
		      aStack.pop(); 
              cout<<root->data;
              root=root->rchild; 
	   }
  }

后序遍历
1、后序遍历——递归算法

template <class T>
void BiTree::PostOrder(BiNode<T> *root)
{ 
    if (root==NULL) return; 
    else {
         PostOrder(root->lchild); 
         PostOrder(root->rchild); 
         cout<<root->data;          
    }
}

2、后序遍历——非递归算法
算法分析
1.定义一个栈；从根节点出发开始遍历，p=root，如果，root==NULL, 不进行遍历；
2.无条件进行下面的工作
①如果指针不空，指针打上left标记，并将指针进栈，执行②;否则，执行③
②p=p->lchild,重复①
③栈顶元素出栈P
④查看P的标志，如果标志为right,进行下面的工作，否则，执行⑤
1访问当前节点P。
2如果栈空 ，算法结束；
3否则，栈顶元素出栈，转④。
⑤修改P的标志，让P重新入栈，p=P->rchild,执行②

栈中的元素类型定义StackElement

enum Tags{Left,Right};	//特征标识定义
	template <class T>
	class StackElement		//栈元素的定义
	{
	public:
	BiTreeNode<T>* pointer;     //指向二叉树结点的指针
	Tags tag; //特征标识申明
	};

实现：

#include <stack>
Using namespace std;
template<class T>
void BiTree<T>::PostOrderWithoutRecusion(BiTreeNode<T>* root){
	StackElement<T> element;
	stack<StackElement<T > > aStack;//栈申明
	BiTreeNode<T>* pointer;
	if(root==NULL)
		return;//空树即返回
	else    pointer=root;				
	while(true){
	  while(pointer!=NULL){//进入左子树
		element.pointer=pointer;
		element.tag=Left; //沿左子树方向向下周游
		aStack.push(element);
		pointer=pointer->lchild; 	
		}
   		element=aStack.pop();
            pointer=element.pointer; 
            while(element.tag==Right){
        cout<<pointer->data;
        if(aStack.empty())  return;
	    else{
	       element=aStack.pop();
		     pointer=element.pointer;
	  	 }//end else
        } //endwhile
    element.tag=Right; 
    aStack.push(element);
    pointer=pointer->rchild(); 
     }//end while

层序遍历
思想：
1.队列Q初始化；
2.如果二叉树非空，将根指针入队；
3.循环直到队列Q为空
3.1 q=队列Q的队头元素出队；
3.2 访问结点q的数据域；
3.3 若结点q存在左孩子，则将左孩子指针入队；
3.4 若结点q存在右孩子，则将右孩子指针入队；

#include <queue>
using namespace std;
template<class T>
void BiTree<T>::LevelOrder(BinaryTreeNode<T>* root){
	queue<BiTreeNode<T>*> aQueue;
	if(root)
		aQueue.push(root);
	while(!aQueue.empty())
	{
		root=aQueue.front(); //取队列首结点
	 	aQueue.pop();
                     cout<<pointer->data;//访问当前结点
		if(root->lchild)	//左子树进队列
			aQueue.push(root->lchild);
		if(root->rchild) //右子树进队列
			aQueue.push(root->rchild); 	
	}//end while
}

二叉树的析构

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);
}

二叉树的结点个数

void Count(BiNode *root){
    if (root) {
         Count(root->lchild);
         number+ +;  //number为数据成员
         Count(root->rchild);
   }
}

树中节点的数目

template<class T>
int BiTree<T>::count(BiNode<T>* root){
	int number=0;

	if (root==NULL)
		number=0;
	else
		number=count(root->lchild)+count(root->rchild)+1;
	return number;
}

统计叶子节点的数目

template<typename T> 
void BiTree<T>:: countleaf(BiTreeNode<T> * root){
	if (root) {
		if (root->lchild==NULL && root->rchild==NULL)
			leafcount=leafcount+1;
		else
		{
			countleaf(root->lchild);
			countleaf(root->rchild);
		}
	}
	return;
}

统计叶子节点的数目

template<class T>
int BiTree<T>::leafcount(BiNode<T>* root){
	int number=0;

	if (root==NULL)
		number=0;
	else if(root->lchild==NULL && root->rchild==NULL)
		number=1;
	else
	    number=leafcount(root->lchild)+leafcount(root->rchild);
	return number;
}

计算树的高度

template<typename T> 
 int BiTree<T>::cal_height(BiTreeNode<T> * root){
	int lheight=0,rheight=0;
	if (root==0)  	 return 0;
	lheight=cal_height(root->lchild);
	rheight=cal_height(root->rchild);
	if (lheight>rheight)	return lheight+1;
	else 		return rheight+1;
}
最优二叉树-哈夫曼树及哈夫曼编码

相关概念
叶子结点的权值：对叶子结点赋予的一个有意义的数值量。
二叉树的带权路径长度：设二叉树具有n个带权值的叶子结点，从根结点到各个叶子结点的路径长度与相应叶子结点权值的乘积之和。 记为：
WPL=w1l1+w2l2+w3l3+…+wn+ln
wk:从根结点到第k个叶子的路径长度
lk:第k个叶子的权值
哈夫曼树：给定一组具有确定权值的叶子结点，带权路径长度最小的二叉树。
哈夫曼树的特点：
1.权值越大的叶子结点越靠近根结点，而权值越小的叶子结点越远离根结点。
2.只有度为0（叶子结点）和度为2（分支结点）的结点，不存在度为1的结点。
哈夫曼算法基本思想：
⑴ 初始化：由给定的n个权值{w1，w2，…，wn}构造n棵只有一个根结点的二叉树，从而得到一个二叉树集合F＝{T1，T2，…，Tn}；
⑵ 选取与合并：在F中选取根结点的权值最小的两棵二叉树分别作为左、右子树构造一棵新的二叉树，这棵新二叉树的根结点的权值为其左、右子树根结点的权值之和；
⑶ 删除与加入：在F中删除作为左、右子树的两棵二叉树，并将新建立的二叉树加入到F中；
⑷ 重复⑵、⑶两步，当集合F中只剩下一棵二叉树时，这棵二叉树便是哈夫曼树。
哈夫曼算法的存储结构
设置一个数组huffTree[2n-1]保存哈夫曼树中各点的信息，数组元素的结点结构 。

weightlchildrchildparent

weight：权值域，保存该结点的权值；
lchild：指针域，结点的左孩子结点在数组中的下标；
rchild：指针域，结点的右孩子结点在数组中的下标；
parent：指针域，该结点的双亲结点在数组中的下标。

struct element
{     int weight;
      int lchild, rchild, parent;
};

伪代码：

  1. 数组huffTree初始化，所有元素结点的双亲、左
    右孩子都置为-1；
  2. 数组huffTree的前n个元素的权值置给定值w[n]；
  3. 进行n-1次合并
    3.1 在二叉树集合中选取两个权值最小的根结点，
    其下标分别为i1, i2；
    3.2 将二叉树i1、i2合并为一棵新的二叉树k(初值为n；依次递增)；
void HuffmanTree(element huffTree[ ], int w[ ], int n ) {
    for (i=0; i<2*n-1; i++) {
       huffTree [i].parent= -1;
       huffTree [i].lchild= -1;
       huffTree [i].rchild= -1;   
    }
    for (i=0; i<n; i++) 
       huffTree [i].weight=w[i];
    for (k=n; k<2*n-1; k++) {
        Select(huffTree, &i1, &i2); 
        huffTree[k].weight=huffTree[i1].weight+huffTree[i2].weight;
        huffTree[i1].parent=k;     
        huffTree[i2].parent=k; 
        huffTree[k].lchild=i1;    
        huffTree[k].rchild=i2;
    }
}

哈夫曼树应用——哈夫曼编码
编码：给每一个对象标记一个二进制位串来表示一组对象。
例：ASCII，指令系统
等长编码：表示一组对象的二进制位串的长度相等。
不等长编码：表示一组对象的二进制位串的长度不相等。

前缀编码：一组编码中任一编码都不是其它任何一个编码的前缀 。
前缀编码保证了在解码时不会有多种可能。

线索链表

线索：将二叉链表中的空指针域指向前驱结点和后继结点的指针被称为线索；
线索化：使二叉链表中结点的空链域存放其前驱或后继信息的过程称为线索化；
线索二叉树：加上线索的二叉树称为线索二叉树。

结点结构：

ltaglchilddatarchildrtag

ltag=0：lchild指向该结点的左孩子
ltag=1：lchild指向该结点的前驱结点
rtag=0：rchild指向该结点的右孩子
rtag=1：rchild指向该结点的后继结点

enum flag {Child, Thread}; 
template  <class T>
struct ThrNode
{
     T data;
     ThrNode<T>  *lchild, *rchild;
     flag ltag, rtag;
};

二叉树的遍历方式有4种，故有4种意义下的前驱和后继，相应的有4种线索二叉树：
⑴ 前序线索二叉树
⑵ 中序线索二叉树
⑶ 后序线索二叉树
⑷ 层序线索二叉树
线索化规则
书上也是奇奇怪怪的，其实很简单，就按照某一遍历规则，记录当前节点（Cur)，上一次访问的节点（Pre）
①如果当前节点Cur->lchild=NULL（左孩子节点空），则Cur->lchild=Pre；Cur->Ltag=1（左指针域指向前驱节点（前一个节点Pre），修改Ltag为线索模式。
②如果前一节点Pre->rchild=NULL（前节点的右孩子节点空），则Pre->rchild=Cur;Pre->Rtag=1（前节点的右指针域指向后继节点（也就是当前节点），修改Rtag为线索模式）

dat_stick
关注
考研系列-数据结构第五章：树与二叉树（下）
Nelson_hehe的博客
06-19 608
本文是408考研付费专栏系列-数据数据结构树与二叉树章节（下半部分），本文章详细地总结了树、森林的概念及结构，树与森林之间的结构转换方式、遍历方法及对应关系，还对哈夫曼树和哈夫曼编码进行了总结，最后对新考点并查集进行学习和汇总，并对优化方式进行整理。 本章内容很多，需要考虑算法思路和代码实现，对于常见的递归遍历算法要牢记，前期可以先熟悉思路，后期多练一些经典的算法题，提高代码能力。
二叉树的构建和遍历总结
Eucalypt的博客
07-01 629
包括前序遍历、中序遍历、后序遍历、层次遍历 根据前序和中序构建二叉树、根据中序和后序构建二叉树、根据中序和层次构建二叉树。
《二叉树》学习心得
weixin_34130269的博客
05-03 2785
树的介绍 1. 树的定义 树是一种数据结构，它是由n（n&gt;=1）个有限节点组成一个具有层次关系的集合。 把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：(01) 每个节点有零个或多个子节点；(02) 没有父节点的节点称为根节点；(03) 每一个非根节点有且只有一个父节点；(04) 除了根节点外，每个子节点可以分为多个不相交的子树。   2. 树...
树与二叉树学习小结
是小光a~
05-08 818
树与二叉树学习小结 对于数据结构的内容，这里不再对栈与队列进行说明。我们先来说一下树与二叉树的内容（概念性的东西有点多）： 树的有关概念： 一棵树是由n（n>0）个元素组成的有限集合，其中： （1）每个元素称为结点(node)； （2）有一个特定的结点，称为根结点或树根（root）； （3）除根结点外，其余结点能分成m（m>=0）个互不相交的有限集合T0,T1,T2,……Tm-1。其中...
树和二叉树学习总结（一）
a765528534的博客
11-15 386
树的基本概念 一、树的定义 树：n（n≥0）个结点的有限集合。当n＝0时，称为空树；任意一棵非空树满足以下条件：⑴ 有且仅有一个特定的称为根的结点；⑵ 当n＞1时，除根结点之外的其余结点被分成m（m>0）个互不相交的有限集合T1,T2,… ,Tm，其中每个集合又是一棵树，并称为这个根结点的子树。 二、树的基本术语 结点的度：结点所拥有的子树的个数。 树的度：树中各结点度的最大值。 ...
树与二叉树的学习总结
zhaoyun_zzz的专栏
03-15 8725
文章目录一般树二叉树一般二叉树满二叉树完全二叉树二叉排序树二叉树的遍历红黑树B树B+树 经过Python的学习，顺便系统的学习了与树相关的数据结构与算法，因此就记录一下吧，留待以后回忆参考。 一般树 二叉树 一般二叉树 满二叉树 完全二叉树 二叉排序树 二叉树的遍历 红黑树 B树 B+树 ...
第六章 树和二叉树 .ppt
12-05
总结本章，学习树和二叉树的知识，能帮助我们更好地理解数据结构，设计和实现高效的算法，解决实际问题，如文件系统、编译器、图形用户界面等。通过深入学习和练习，掌握这些基本概念和操作，将对编程能力的提升...
数据结构：第六章 树和二叉树.ppt
09-17
第六章主要讲解了两个关键的概念：树和二叉树。 1. **树的类型定义**： - 树是由数据对象 D 和数据关系 R 定义的。D 是数据元素的集合，如果为空，则为空树。否则，有一个称为根的数据元素，其余结点分为若干子树...
【精品课件】数据结构与算法 数据结构与C语言 data structure课程 第5章 树和二叉树（共95页）.ppt
11-05
数据结构与算法是计算机科学的基础...总结起来，本课程涵盖了树和二叉树的基本概念、性质、存储结构、遍历方法以及它们在实际问题中的应用，对于学习者来说，掌握这些知识将有助于提升在算法设计和问题解决方面的能力。
【数据结构】第5章_二叉树、树和森林的定义与应用.zip
10-12
总结来说，二叉树是数据结构中的重要组成部分，其递归和非递归操作的理解和应用是提升编程技能的关键。通过深入学习和实践，你可以有效地运用二叉树解决各种实际问题，特别是在数据存储、搜索和排序等领域。
学习总结-树与二叉树一
sunshine-smile的博客
02-24 499
I、树的基本概念    树是一种简单的非线性结构。    树的图形中都可用直连连接的两端结点，上端结点是前件，下端结点为后件。2、树结构的有关术语:①根结点: 最上的根结点，没有前件。而每一个结点只有一个前件，其他的结点(除根结点) 叫父结点;②叶结点: 没有后件的结点;③子结点: 每一个结点可以有多个后件:④结点的度: 结点有后件的个数;⑤树的度: 结点中最大的结点度;⑥树的深度: 总共有儿层;...
关于树和二叉树的基本概念总结
jingsuxuyilq的专栏
03-09 5621
1.什么是（自由）树？ 树首先是无向图的一种，并且此无向图要满足下面两个特性： 1）连通，即任何两对顶点之间都有路径相连。 2）无回路，简单地说就是没有成环。 2.什么是森林？ 当满足树特性2）而不满足1）时称为森林。可以简单地理解为，什么不满足连通性，所以森林中可含有多个（自由）树。 3.树的特性 假设G = (V, E)是一个无向图，则下面的定义中等价的： 1）G是（自由）
树与二叉树总结
像风一样自由
02-14 1547
1.树 2.二叉树 3.二叉树的节点类及二叉树类 4.二叉树的遍历 5.线索二叉树 6.树和森林 7.树的应用
数据结构 树、二叉树（前半） 学习心得代码
最新发布
FellAveal的博客
11-11 335
树，伟大的递归。
树与二叉树章节学习心得
huanzon的专栏
12-29 1428
数据结构与算法——二叉树的学习总结与基本实现
l118
02-16 848
引言 在数据结构与算法的学习中，我们都无法绕开树与二叉树的学习。 之前我们介绍过数组的数据结构，并且也学习了一些基本的查找算法，但是如果我们想要在有序数组中插入一个数据项，就必须要找到数据项的位置，然后将所有插入位置后的数据项全部向后移动一位，来给新的数据项腾出空间，这样一来，其实非常耗费时间。然后我们介绍了另外一种数据结构——链表。链表的插入删除效率较高，我们只需要改变一些引用值就可以了。但是查...
树和二叉树的实验2
LJing_T的博客
11-08 579
一、实验目的  1、   熟练理解树和二叉树的相关概念，掌握的存储结构和相关操作实现；  2、   掌握树的顺序结构的实现；  3、   学会运用树的知识解决实际问题  二、 实验内容 1、自己确定一个二叉树（树结点类型、数目和结构自定）利用链式存储结构方法存储。实现树的构造，并完成： 1）用前序遍历、中序遍历、后序遍历输出结点数据；  2）以合理的格式，输出各个结点和双亲、孩子结点
数据结构—树学习小结
_C9的博客
10-04 317
树是一种描述一种有层次的数据结构，并非以前我们习惯的线性结构，它是一种非线性的数据结构，它可以实现很多问题的抽像形式。关于树的最基本的术语如度，孩子节点这样的我就不再赘述了，稍稍看看课本就能明白，没有什么好说的。 下面说一下树的存储结构 第一种形式就是双亲表示法，因为树的特殊结构使得每个结点都有且仅有一个双亲节点，所以现在用一个一维数组存储树的每个结点，每个结点包括结点的数据信息和该结点双亲在数组中的下标，特点就是找双亲容易找孩子难 第二种方式就是孩子表示法，这是基于链表的存储方式，把每个结点的孩子排
二叉树的学习
m0_63783532的博客
11-11 1408
2.n = n1 + 2n2 + 1（树的结点数 = 总度数 + 1，其中度为0的结点数有n0个，度数和为0×n0；1.n = n0 + n1 + n2（树的结点数 = 度为0的结点数 + 度为1的结点数 + 度为2的结点数）分析：第一层有1个结点；总共有1+2+2^2......+2^(h-1)=(1-2^h)/(1-2)=2^h-1。又推出若完全二叉树有2k个（偶数）个结点，则必有n1=1，n0=k，n2=k-1。若完全二叉树有2k-1个（奇数）个结点，则必有n1=0，n0=k，n2=k-1。
数据结构：第六章 树与二叉树详解
"第六章 树和二叉树章节涵盖了关于树形数据结构的基础知识，适合初学者，有助于后续数据结构的学习。主要内容包括树的类型定义、基本术语、二叉树的定义、存储结构、遍历方法、线索二叉树、树和森林的表示以及遍历，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值