数据结构个人笔记 第16课 二叉树的遍历

最新推荐文章于 2024-09-05 18:25:10 发布
最新推荐文章于 2024-09-05 18:25:10 发布
阅读量596 收藏 1
点赞数 1
分类专栏： 数据结构笔记 文章标签： 数据结构 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mcyuuji/article/details/122267770
版权

数据结构个人笔记 第16课 二叉树的遍历

二叉树的遍历

二叉树先序遍历

二叉树先序遍历的实现思想是：

  1. 访问根结点
  2. 访问当前节点的左子树
  3. 若当前节点无左子树，则访问当前节点的右子树

二叉树
由以上思想提出的遍历顺序为：

1,2,4,5,3,6,7

递归实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TElemType int

typedef struct BiTNode{
	TElemType data;
	struct BiTNode *lchild ,*rchild;
}BiTNode,*BiTree; 

void CreateBiTree(BiTree *T){
	*T = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->data = 1;
	(*T)->lchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T) -> rchild = (BiTNode*)malloc(sizeof(BiTNode));
	
	(*T)->lchild->data = 2;
	(*T)->lchild->lchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->lchild->rchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->lchild->rchild->data = 5;
	(*T)->lchild->rchild->lchild = NULL;
	(*T)->lchild->rchild->rchild = NULL;
	(*T)->rchild->data = 3;
	(*T)->rchild->lchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->rchild->lchild->data = 6;
	(*T)->rchild->lchild->lchild = NULL;
	(*T)->rchild->lchild->rchild = NULL;
	(*T)->rchild->rchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->rchild->rchild->data = 7;
	(*T)->rchild->rchild->lchild = NULL;
	(*T)->rchild->rchild->rchild = NULL;
	(*T)->lchild->lchild->data = 4;
	(*T)->lchild->lchild->lchild = NULL;
	(*T)->lchild->lchild->rchild = NULL;
}

void displayElem(BiTNode* elem){
	printf("%d ",elem->data);
}

void PreOrderTraverse(BiTree T){
	if(T){
		displayElem(T);
		PreOrderTraverse(T->lchild);
		PreOrderTraverse(T->rchild);
	}
	return;
}

int main(){
	BiTree Tree;
	CreateBiTree(&Tree);
	printf("先序遍历:\n");
	PreOrderTraverse(Tree);
}

运行结果：
在这里插入图片描述

非递归实现

而递归的底层实现依靠的是栈存储结构，因此，二叉树的先序遍历既可以直接采用递归思想实现，也可以使用栈的存储结构模拟递归的思想实现

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define TElemType int
int top = -1;//top变量时刻表示栈顶元素所在位置
typedef struct BiTNode{
	TElemType data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree; 

void CreateBiTree(BiTree *T){
	*T = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->data = 1;
	(*T)->lchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T) -> rchild = (BiTNode*)malloc(sizeof(BiTNode));
	
	(*T)->lchild->data = 2;
	(*T)->lchild->lchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->lchild->rchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->lchild->rchild->data = 5;
	(*T)->lchild->rchild->lchild = NULL;
	(*T)->lchild->rchild->rchild = NULL;
	(*T)->rchild->data = 3;
	(*T)->rchild->lchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->rchild->lchild->data = 6;
	(*T)->rchild->lchild->lchild = NULL;
	(*T)->rchild->lchild->rchild = NULL;
	(*T)->rchild->rchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->rchild->rchild->data = 7;
	(*T)->rchild->rchild->lchild = NULL;
	(*T)->rchild->rchild->rchild = NULL;
	(*T)->lchild->lchild->data = 4;
	(*T)->lchild->lchild->lchild = NULL;
	(*T)->lchild->lchild->rchild = NULL;
}

void push(BiTNode** a,BiTNode* elem){
	a[++top] = elem;
}

void pop(){
	if(top == -1){
		return;
	}
	top --;
}

void displayElem(BiTNode* elem){
	printf("%d ",elem->data);
}

BiTNode* getTop(BiTNode **a){
	return a[top];
}

void PreOrderTraverse(BiTree Tree){
	BiTNode* a[20];
	BiTNode *p;
	push(a,Tree);
	while(top != -1){
		p = getTop(a);
		pop();
		while(p){
			displayElem(p);
			if(p->rchild){
				push(a,p->rchild);
			}
			p = p->lchild; 
		}
	}
}

int main(){
	BiTree Tree;
	CreateBiTree(&Tree);
	printf("非递归先序遍历:\n");
	PreOrderTraverse(Tree);
}

结构如同上面递归实现

二叉树中序遍历

二叉树中序遍历的实现思想是：

  1. 访问当前节点的左子树
  2. 访问根结点
  3. 访问当前节点的右子树

二叉树
这样得到的序列为：

4,2,5,1,6,3,7

递归实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TElemType int

typedef struct BiTNode{
	TElemType data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree; 

void CreateBiTree(BiTree *T){
	*T = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->data = 1;
	(*T)->lchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T) -> rchild = (BiTNode*)malloc(sizeof(BiTNode));
	
	(*T)->lchild->data = 2;
	(*T)->lchild->lchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->lchild->rchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->lchild->rchild->data = 5;
	(*T)->lchild->rchild->lchild = NULL;
	(*T)->lchild->rchild->rchild = NULL;
	(*T)->rchild->data = 3;
	(*T)->rchild->lchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->rchild->lchild->data = 6;
	(*T)->rchild->lchild->lchild = NULL;
	(*T)->rchild->lchild->rchild = NULL;
	(*T)->rchild->rchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->rchild->rchild->data = 7;
	(*T)->rchild->rchild->lchild = NULL;
	(*T)->rchild->rchild->rchild = NULL;
	(*T)->lchild->lchild->data = 4;
	(*T)->lchild->lchild->lchild = NULL;
	(*T)->lchild->lchild->rchild = NULL;
}

void displayElem(BiTNode * elem){
	printf("%d ",elem -> data);
}

void INOrderTraverse(BiTree T){
	if(T){
		INOrderTraverse(T->lchild);
		displayElem(T);
		INOrderTraverse(T->rchild);
	}
	return;
}

int main(){
	BiTree Tree;
	CreateBiTree(&Tree);
	printf("中序遍历算法:\n");
	INOrderTraverse(Tree);
}

结果展示
在这里插入图片描述

非递归实现

中序遍历的非递归方式实现思想是：从根结点开始，遍历左孩子同时压栈，当遍历结束，说明当前遍历的结点没有左孩子，从栈中取出来调用操作函数，然后访问该结点的左孩子，继续以上重复性的操作

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TElemType int
int top = -1;
typedef struct BiTNode{
	TElemType data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

void CreateBiTree(BiTree *T){
	*T = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->data = 1;
	(*T)->lchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T) -> rchild = (BiTNode*)malloc(sizeof(BiTNode));
	
	(*T)->lchild->data = 2;
	(*T)->lchild->lchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->lchild->rchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->lchild->rchild->data = 5;
	(*T)->lchild->rchild->lchild = NULL;
	(*T)->lchild->rchild->rchild = NULL;
	(*T)->rchild->data = 3;
	(*T)->rchild->lchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->rchild->lchild->data = 6;
	(*T)->rchild->lchild->lchild = NULL;
	(*T)->rchild->lchild->rchild = NULL;
	(*T)->rchild->rchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->rchild->rchild->data = 7;
	(*T)->rchild->rchild->lchild = NULL;
	(*T)->rchild->rchild->rchild = NULL;
	(*T)->lchild->lchild->data = 4;
	(*T)->lchild->lchild->lchild = NULL;
	(*T)->lchild->lchild->rchild = NULL;
}

void push(BiTNode** a,BiTNode* elem){
	a[++top] = elem;
}

void pop(){
	if(top == -1){
		return;
	}
	top--;
}

void displayElem(BiTNode* elem){
	printf("%d ",elem->data);
}

BiTNode* getTop(BiTNode** a){
	return a[top];
} 

void InOrderTraverse1(BiTree Tree){
	BiTNode* a[20];
	BiTNode * p;
	push(a,Tree);
	while(top != -1){
		while((p = getTop(a)) && p){
			push(a,p->lchild); 
		}
		pop();
		if(top != -1){
			p = getTop(a);
			pop();
			displayElem(p);
			push(a,p->rchild);
		}
	}
}

void InOrderTraverse2(BiTree Tree){
	BiTNode* a[20];
	BiTNode * p;
	p = Tree;
	while(p || top != -1){
		if(p){
			push(a,p);
			p = p->lchild;
		}else{
			p = getTop(a);
			pop();
			displayElem(p);
			p = p->rchild;
		}
	}
}

int main(){
	BiTree Tree;
	CreateBiTree(&Tree);
	printf("中序遍历算法1:\n");
	InOrderTraverse1(Tree);
	printf("\n中序遍历算法2:\n");
	InOrderTraverse2(Tree);
}

二叉树后序遍历

二叉树后序遍历的实现思想是：从根结点触发，依次遍历各节点的左右子树，直到当前节点左右子树遍历完成后，才访问该节点元素

二叉树
遍历的结果：

4,5,2,6,7,3,1

递归实现

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define TElemType int 

typedef struct BiTNode{
	TElemType data;
	struct BiTNode *lchild, *rchild;
}BiTNode,*BiTree;

void CreateBiTree(BiTree *T){
	*T = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->data = 1;
	(*T)->lchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T) -> rchild = (BiTNode*)malloc(sizeof(BiTNode));
	
	(*T)->lchild->data = 2;
	(*T)->lchild->lchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->lchild->rchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->lchild->rchild->data = 5;
	(*T)->lchild->rchild->lchild = NULL;
	(*T)->lchild->rchild->rchild = NULL;
	(*T)->rchild->data = 3;
	(*T)->rchild->lchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->rchild->lchild->data = 6;
	(*T)->rchild->lchild->lchild = NULL;
	(*T)->rchild->lchild->rchild = NULL;
	(*T)->rchild->rchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->rchild->rchild->data = 7;
	(*T)->rchild->rchild->lchild = NULL;
	(*T)->rchild->rchild->rchild = NULL;
	(*T)->lchild->lchild->data = 4;
	(*T)->lchild->lchild->lchild = NULL;
	(*T)->lchild->lchild->rchild = NULL;
}

void displayElem(BiTNode* elem){
	printf("%d ",elem->data);
}

void PostOrderTraverse(BiTree T){
	if(T){
		PostOrderTraverse(T->lchild);
		PostOrderTraverse(T->rchild);
		displayElem(T);
	} 
	return;
}

int main(){
	BiTree Tree;
	CreateBiTree(&Tree);
	printf("后序遍历:\n");
	PostOrderTraverse(Tree);
}

结果展示：
在这里插入图片描述

非递归实现

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define TElemType int 
int top = -1;
typedef struct BiTNode{
	TElemType data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

void CreateBiTree(BiTree *T){
	*T = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->data = 1;
	(*T)->lchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T) -> rchild = (BiTNode*)malloc(sizeof(BiTNode));
	
	(*T)->lchild->data = 2;
	(*T)->lchild->lchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->lchild->rchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->lchild->rchild->data = 5;
	(*T)->lchild->rchild->lchild = NULL;
	(*T)->lchild->rchild->rchild = NULL;
	(*T)->rchild->data = 3;
	(*T)->rchild->lchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->rchild->lchild->data = 6;
	(*T)->rchild->lchild->lchild = NULL;
	(*T)->rchild->lchild->rchild = NULL;
	(*T)->rchild->rchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->rchild->rchild->data = 7;
	(*T)->rchild->rchild->lchild = NULL;
	(*T)->rchild->rchild->rchild = NULL;
	(*T)->lchild->lchild->data = 4;
	(*T)->lchild->lchild->lchild = NULL;
	(*T)->lchild->lchild->rchild = NULL;
}

void pop(){
	if(top == -1){
		return;
	}
	top --;
}

void displayElem(BiTNode* elem){
	printf("%d ",elem->data);
}

typedef struct SNode{
	BiTree p;
	int tag;
}SNode;

void postpush(SNode *a,SNode sdata){
	a[++top] = sdata;
}

void PostOrderTraverse(BiTree Tree){
	SNode a[20];
	BiTNode * p;
	int tag;
	SNode sdata;
	p = Tree;
	while(p || top!=-1){
		while(p){
			sdata.p = p;
			sdata.tag = 0;
			postpush(a,sdata);
			p = p->lchild;
		}
		sdata = a[top];
		pop();
		p = sdata.p;
		tag = sdata.tag;
		if(tag == 0){
			sdata.p = p;
			sdata.tag = 1;
			postpush(a,sdata);
			p = p->rchild;
		}else{
			displayElem(p);
			p = NULL;
		}
		
	}
}

int main(){
	BiTree Tree;
	CreateBiTree(&Tree);
	printf("后序遍历:\n");
	PostOrderTraverse(Tree);
}

二叉树的层次遍历

按照二叉树中的层次从左到右依次遍历每层中的结点。具体的实现思路是：通过使用队列的数据结构，从树的根结点开始，依次将其左孩子和右孩子入队。而后每次队列中一个结点出列，都将其左孩子和右孩子入队，直到树中所有节点都出队，出队结点的先后顺序就是层次遍历的最终结果

在这里插入图片描述

运行结果:

1,2,3,4,5,6,7

实现代码

#include<stdio.h>
#include<stdlib.h>
#define TElemType int 

int front = 0,rear = 0; 

typedef struct BiTNode{
	TElemType data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

void CreateBiTree(BiTree *T){
	*T = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->data = 1;
	(*T)->lchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T) -> rchild = (BiTNode*)malloc(sizeof(BiTNode));
	
	(*T)->lchild->data = 2;
	(*T)->lchild->lchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->lchild->rchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->lchild->rchild->data = 5;
	(*T)->lchild->rchild->lchild = NULL;
	(*T)->lchild->rchild->rchild = NULL;
	(*T)->rchild->data = 3;
	(*T)->rchild->lchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->rchild->lchild->data = 6;
	(*T)->rchild->lchild->lchild = NULL;
	(*T)->rchild->lchild->rchild = NULL;
	(*T)->rchild->rchild = (BiTNode*)malloc(sizeof(BiTNode));
	(*T)->rchild->rchild->data = 7;
	(*T)->rchild->rchild->lchild = NULL;
	(*T)->rchild->rchild->rchild = NULL;
	(*T)->lchild->lchild->data = 4;
	(*T)->lchild->lchild->lchild = NULL;
	(*T)->lchild->lchild->rchild = NULL;
}

void EnQueue(BiTree *a,BiTree node){
	a[rear++]=node;
}

BiTNode* DeQueue(BiTNode** a){
	return a[front++];
}

void displayNode(BiTree node){
	printf("%d ",node->data);
}

int main(){
	BiTree tree;
	CreateBiTree(&tree);
	BiTNode * p;
	BiTree a[20];
	EnQueue(a,tree);
	while(front < rear){
		p = DeQueue(a);
		displayNode(p);
		if(p->lchild != NULL){
			EnQueue(a,p->lchild);
		}
		if(p->rchild != NULL){
			EnQueue(a,p->rchild);
		}
	}
	return 0;
}

线索二叉树

在这里插入图片描述
上图所示的二叉链表，存在多个空指针域。空指针域的个数为n+1
可以在这n+1个空指针域中保存结点的前驱和后继指针，这样在下次遍历时，可以大大提高速度
在这里插入图片描述
将所有空指针域中的rchild指向它的后继
在这里插入图片描述
将所有空指针域中的lchild指向它的前驱

线索二叉树（保留遍历时结点在任一串行的前驱和后继的信息）：若结点有左子树，则其lchild域指示其左孩子，否则令lchild域指示其前驱；若结点有右子树，则其rchild域指示其右孩子，否则令rchild指示其后继

还需在结点结构中增加两个标志域LTag和RTag。LTag=0时，lchild域指示结点的左孩子，LTag=1时，lchild域指示结点的前驱；RTag=0时，rchild域指示节点的右孩子，RTag=1时，rchild域指示结点的后继

以这种结点结构构成的二叉链表作为二叉树的存储结构，叫做线索链表，其中指向节点前驱和后继的指针叫做线索，加上线索的二叉树称为线索二叉树。对二叉树以某种次序遍历使其变为线索二叉树的过程称为线索化。若对二叉树进行中序遍历，则所得的线索二叉树称为中序线索二叉树，线索链表称为中序线索链表。

代码实现

#include <stdio.h>
#include <stdlib.h>
 
typedef int ElemType;
 
/*
线索存储标志位
Link(0)：表示指向左右孩子的指针
Thread(1):表示指向前驱后继的线索
*/
typedef enum {Link, Thread} PointerTag;
 
typedef struct BiThrNode{
    ElemType data;
    struct BiThrNode *lchild, *rchild;
    PointerTag ltag;
    PointerTag rtag;
}BiThrNode, *BiThrTree;
 
//全局变量，始终指向刚刚访问过的节点
 BiThrTree pre;
 
//创建一棵二叉树，约定用户遵照前序遍历方式输入数据
void createBiThrTree(BiThrTree *T){
	*T = (BiThrNode*)malloc(sizeof(BiThrNode));
	(*T)->data = 1;
	(*T)->lchild = (BiThrNode*)malloc(sizeof(BiThrNode));
	(*T) -> rchild = (BiThrNode*)malloc(sizeof(BiThrNode));
	(*T)->ltag = Link;
	(*T)->rtag = Link;
	
	(*T)->lchild->data = 2;
	(*T)->lchild->lchild = (BiThrNode*)malloc(sizeof(BiThrNode));
	(*T)->lchild->rchild = (BiThrNode*)malloc(sizeof(BiThrNode));
	(*T)->lchild->rtag = Link;
	(*T)->lchild->ltag = Link;
	
	(*T)->lchild->rchild->data = 5;
	(*T)->lchild->rchild->lchild = NULL;
	(*T)->lchild->rchild->rchild = NULL;
	(*T)->lchild->rchild->ltag = Link;
	(*T)->lchild->rchild->rtag = Link;
	
	(*T)->rchild->data = 3;
	(*T)->rchild->lchild = (BiThrNode*)malloc(sizeof(BiThrNode));
	(*T)->rchild->ltag = Link;
	(*T)->rchild->rtag = Link;
	
	(*T)->rchild->lchild->data = 6;
	(*T)->rchild->lchild->lchild = NULL;
	(*T)->rchild->lchild->rchild = NULL;
	(*T)->rchild->lchild->ltag = Link;
	(*T)->rchild->lchild->rtag = Link;
	
	(*T)->rchild->rchild = (BiThrNode*)malloc(sizeof(BiThrNode));
	(*T)->rchild->rchild->data = 7;
	(*T)->rchild->rchild->lchild = NULL;
	(*T)->rchild->rchild->rchild = NULL;
	(*T)->rchild->rchild->ltag = Link;
	(*T)->rchild->rchild->rtag = Link;
	
	(*T)->lchild->lchild->data = 4;
	(*T)->lchild->lchild->lchild = NULL;
	(*T)->lchild->lchild->rchild = NULL;
	(*T)->lchild->lchild->ltag = Link;
	(*T)->lchild->lchild->rtag = Link;
}
 
//中序遍历线索化
void inThreading(BiThrTree T){
    if(T){
        inThreading(T->lchild);//递归左孩子线索华
        //节点处理
        if(!T->lchild){//处理前驱，什么时候能知道前驱，就是当前节点的时候，
//已经知道前一个是pre了，所以直接tag=thread，lchild=pre
            T->ltag = Thread;
            T->lchild = pre;
        }
        if(pre!=NULL && !pre->rchild){//处理后继，什么时候处理后继，只有访问到下一个的时候，
//才能知道下一个是谁，因为当访问下一个的时候，下一个是T，让pre的rchild指向T就好
            pre->rtag = Thread;
            pre->rchild = T;
        }
        pre = T;
 
        inThreading(T->rchild);//递归右孩子线索华
    }
}
 
//中序遍历线索二叉树---非递归
void InOrderThreading(BiThrTree T){
    BiThrTree p = T;
    while(p != NULL){
        //当ltag == Thread时，循环到中序序列第一个节点
        while(p->ltag == Link){
            p = p->lchild;
        }
 
        printf("%d ", p->data);
        while(p->rtag == Thread && p->rchild != NULL){
            p = p ->rchild;
            printf("%d ", p->data);
        }
        p = p->rchild;
    }
 
}
 
int main(){
    BiThrTree T = NULL;
    createBiThrTree(&T);
    inThreading(T);
    pre->rtag = Thread;
    InOrderThreading(T);
    return 0;
 
}

双向线索二叉树

双线线索链表的作用就是可以让线索二叉树从第一个节点和最后一个两个方向实现遍历

在线索二叉树的基础上，额外添加一个结点。此结点的作用类似于链表中的头指针，数据域不起作用，只利用两个指针域（由于都是指针，标志域都为0）

左指针域指向二叉树的树根，确保可以正方向对二叉树进行遍历；同时，右指针指向线索二叉树形成的线性序列中的最后一个节点
在这里插入图片描述

代码实现

#include <stdio.h>
#include <stdlib.h>
#define TElemType char//宏定义，结点中数据域的类型
//枚举，Link为0，Thread为1
typedef enum {
    Link,
    Thread
}PointerTag;
//结点结构构造
typedef struct BiThrNode{
    TElemType data;//数据域
    struct BiThrNode* lchild,*rchild;//左孩子，右孩子指针域
    PointerTag Ltag,Rtag;//标志域，枚举类型
}BiThrNode,*BiThrTree;

BiThrTree pre=NULL;

//采用前序初始化二叉树
//中序和后序只需改变赋值语句的位置即可
void CreateTree(BiThrTree * tree){
    char data;
    scanf("%c",&data);
    if (data!='#'){
        if (!((*tree)=(BiThrNode*)malloc(sizeof(BiThrNode)))){
            printf("申请结点空间失败");
            return;
        }else{
            (*tree)->data=data;//采用前序遍历方式初始化二叉树
            CreateTree(&((*tree)->lchild));//初始化左子树
            CreateTree(&((*tree)->rchild));//初始化右子树
        }
    }else{
        *tree=NULL;
    }
}
//中序对二叉树进行线索化
void InThreading(BiThrTree p){
    //如果当前结点存在
    if (p) {
        InThreading(p->lchild);//递归当前结点的左子树，进行线索化
        //如果当前结点没有左孩子，左标志位设为1，左指针域指向上一结点 pre
        if (!p->lchild) {
            p->Ltag=Thread;
            p->lchild=pre;
        }
        //如果 pre 没有右孩子，右标志位设为 1，右指针域指向当前结点。
        if (pre&&!pre->rchild) {
            pre->Rtag=Thread;
            pre->rchild=p;
        }
        pre=p;//pre指向当前结点
        InThreading(p->rchild);//递归右子树进行线索化
    }
}
//建立双向线索链表
void InOrderThread_Head(BiThrTree *h, BiThrTree t)
{
    //初始化头结点
    (*h) = (BiThrTree)malloc(sizeof(BiThrNode));
    if((*h) == NULL){
        printf("申请内存失败");
        return ;
    }
    (*h)->rchild = *h;
    (*h)->Rtag = Link;
    //如果树本身是空树
    if(!t){
        (*h)->lchild = *h;
        (*h)->Ltag = Link;
    }
    else{
        pre = *h;//pre指向头结点
        (*h)->lchild = t;//头结点左孩子设为树根结点
        (*h)->Ltag = Link;
        InThreading(t);//线索化二叉树，pre结点作为全局变量，线索化结束后，pre结点指向中序序列中最后一个结点
        pre->rchild = *h;
        pre->Rtag = Thread;
        (*h)->rchild = pre;
    }
}
//中序正向遍历双向线索二叉树
void InOrderThraverse_Thr(BiThrTree h)
{
    BiThrTree p;
    p = h->lchild;           //p指向根结点
    while(p != h)
    {
        while(p->Ltag == Link)   //当ltag = 0时循环到中序序列的第一个结点
        {
            p = p->lchild;
        }
        printf("%c ", p->data);  //显示结点数据，可以更改为其他对结点的操作
        while(p->Rtag == Thread && p->rchild != h)
        {
            p = p->rchild;
            printf("%c ", p->data);
        }
       
        p = p->rchild;           //p进入其右子树
    }
}
int main() {
    BiThrTree t;
    BiThrTree h;
    printf("输入前序二叉树:\n");
    CreateTree(&t);
    InOrderThread_Head(&h, t);
    printf("输出中序序列:\n");
    InOrderThraverse_Thr(h);
    return 0;
}

运行结果：
输入

124###35##6##

得到

4 2 1 5 3 6

mcyuuji
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树的遍历及其例题（数据结构学习笔记）
省洗发水钱买书
12-15 4921
文章目录先序、中序、后序遍历递归算法1、先序遍历过程先序遍历算法代码2、中序遍历过程中序遍历算法代码3、后序遍历过程后序遍历算法代码层次遍历算法算法设计思路算法代码算法世界复杂度为 O(n)算法例题例题7-11算法思路解题标程例题7-12算法思路解题标程例题7-13算法思路解题标程例题7-14算法思路算法设计例题7-15算法思路解题标程例题7-16算法思路解题标程例题7-17算法思路队列类型声明解题标程结果图示 二叉树的遍历方式主要有四种：先序遍历、中序遍历、后序遍历和层次遍历。 这里我们用递归算法来讨论
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 42万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
数据结构C语言严蔚敏版(第二版)超详细笔记附带课后习题
chongyang_的博客
11-07 27万+
根据此书所做随笔笔记。 一、绪论 1.1、数据机构的研究内容 用计算机解决实际问题时，步骤：首先分析实际问题，从中抽象出一个适当的数学模型，然后设计一个解决此数学模型的算法，最后编程，调试，测试。 寻求数据模型的实质是分析问题，从中提取出计算机处理的对象，并找出这些对象之间的关系，然后用数学的语言加以描述。 关键：分析问题中所用到的数据是如何组织的，研究数据之间存在什么样的关系。 由于数据必须在计算机中处理，因此不能局限于数据本身的数学问题的研究，还必须考虑数据的物理结构，即数据在计算机中的存储结构。 1.
【学习笔记】数据结构 第三章 树和二叉树
qq_61951986的博客
07-20 602
1.指树的深度2.树的大小(集合节点个数)
万字长文详解数据结构：树 | 第6章 | Java版大话数据结构 | 二叉树 | 哈夫曼树 | 二叉树遍历 | 构造二叉树 | LeetCode练习 | Java
神马都会亿点点的毛毛张
06-29 813
线性结构是1️⃣对1️⃣的关系，如果处理1️⃣对多的情况，则需要使用树形结构🌲树形结构包括：二叉树、AVLAVLAVL树、B树、红黑树等，而二叉树是学其它树的基础，学好了二叉树才能在后续更难的树时得心应手🫱在介绍二叉树之前同时还需要整体的介绍一下树这个数据结构**定义：**🌳树是nn≥0n（n≥0）nn≥0个结点的有限集。当n0n = 0n0时，称为空树。在任意一棵非空树中应满足：有且仅有一个特定的称为根(Root)的结点；当n1n>1n1。
866数据结构笔记 - 第五章 树和二叉树
qq_45331246的博客
10-20 2868
866数据结构、湖南大学考研、树和二叉树
数据结构学习笔记——图的遍历算法（深度优先搜索和广度优先搜索）
小宇y的博客
08-18 3万+
若通过邻接表表示图，则每个顶点都入队一次，即所需时间为O(|V|)，搜索顶点的邻接顶点所需时间为O(|E|)，其时间复杂度为O(|V|+|E|)。若通过邻接表表示图，则查找所有顶点的邻接顶点所需时间为O(|E|)，访问顶点所需时间为O(|V|)，即总时间复杂度为O(|V|+|E|)。4、查看V7单链表，其邻接顶点为2，即V3，它已经被访问过，于是回到V3单链表，搜索下一个未被访问的邻接顶点；11、查看V8单链表，其邻接顶点为4，即V5，已经被访问过，于是回到V5单链表，搜索下一个未被访问的邻接顶点；....
数据结构笔记(全)
señoritaw的博客
04-25 3872
线性表：是具有相同数据类型的 n 个数据元素的有限序列。(Eg:所有的整数按递增次序排列，不是顺序表，因为所有的整数是无限的)其中n为表长，当n=0时线性表是一个空表。若用L表示一个线性表，则是线性表中的第i个元素，称为线性表中的位序是表头元素;是表尾元素。除第一个元素外，每个元素有且仅有一个直接前驱;除最后一个元素外，每个元素有且仅有一个直接后继2.1.2 线性表的基本操作InitList(&L)：初始化表。构造一个空的线性表 L，分配内存空间。
数据结构选择题——树和二叉树
weixin_74727063的博客
12-19 1797
19、对二叉树的结点从1开始进行连续编号，要求每个结点的编号大于其左、右孩子的编号，同一结点的左右孩子中，其左孩子的编号小于其右孩子的编号，可采用（）次序的遍历实现编号。每个结点有一个lchild，一个rchild，n个结点，共有2n个指针，在2n个指针中有n-1个指向自己的孩子结点（该树的度），因此线索数有2n-（n-1）=n+1。m叉树中的节点可以有0到m个子节点。反例：只有一个结点的数也可以是一颗m叉树。28、设树T的度为4，其中度为1，2，3和4的结点个数分别为4，2，1，1则T中的叶子数为（）。
【数据结构-二维前缀和】【列维护优化】力扣3212. 统计 X 和 Y 频数相等的子矩阵数量
sjsjs11的博客
09-02 632
我觉得列优化的核心思路是，由于在计算前缀和中，之前的列字符数都会被用到，也就是说在遍历不同行的时候，列的字符数是在前一行的列的字符数加上目前行的字符数得来的。所以在每一行遍历的时候，置s1和s2为0，然后逐渐累加，可以看作这个前缀和矩阵，随着列的遍历，一条条竖下来的元素铺成一个前缀和矩阵，最后进行统计X和Y相等的频数。输入： grid = [[“X”,“Y”,“.”],[“Y”,“.”,“.”]]输入： grid = [[“X”,“X”],[“X”,“Y”]]‘X’ 和 ‘Y’ 的频数相等。
C语言-数据结构 并查集
BamBoo_Bean的博客
09-05 148
C语言-数据结构 并查集
C++笔记16•数据结构:关联式容器map和set•
qq_64446190的博客
09-02 834
数据结构:关联式容器map和set
经典数据结构-栈计算逆波兰表达式
一个好学的低级程序猿
09-05 128
栈计算逆波兰表达式
数据结构---五大排序---哈希表---二分查找法
m0_65301172的博客
09-02 505
int data;}Data_t;
桶排序【算法 14】
delepaste的博客
08-31 772
桶排序是一种适用于特定数据分布的高效排序算法，特别适合均匀分布的数据集合。在大多数情况下，它可以达到线性时间复杂度，因此在处理某些数值排序问题时非常实用。然而，桶排序对输入数据的分布有较高要求，因此在使用时需考虑数据特性。
数据结构：（LeetCode144）二叉树的前序遍历
2303_81073778的博客
09-03 321
递归算法很简单，你可以通过迭代算法完成吗？
【数据结构】归并排序
最新发布
Demon___1的博客
09-05 216
主要讲解了归并算法的基础思路和实现
数据结构--栈
weixin_62008675的博客
09-05 768
一些，顺序栈是通过指针指向假设的栈顶，其他元素其实依然存在，但链栈的栈顶之前的元素会被垃圾回收，因此链栈的实现综合时间和空间来看，更优秀一些。对比链栈和顺序栈的实现，可以发现入栈和出战方法的时间复杂度都是O(1)，效率上没有区别，但是顺序栈占用的空间会相对更多。顺序栈底层是数组，最大空间容量受到限制，因此必须初始化一个数组的容量，也就是栈的容量，链栈则无需此操作。常见的栈实现方式有数组和链表两种，其中数组实现的栈又称为顺序栈，链表实现的栈称为链式栈。（Bottom）：固定的，不允许进行插入和删除的另一端。
数据结构实验课：二叉树遍历与Gray码构造
"本次数据结构上机课的内容涵盖了期末考查说明、实验课随堂练习评分规则以及三个具体的编程任务：二叉树的遍历、Gray码构造和数字拆分。考查形式为选择题和编程题，总成绩由考查分数和平时成绩构成。编程题不允许...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值