二叉树的先序遍历 ——（创建、插入、遍历（迭代、循环））系列操作

最新推荐文章于 2021-05-01 19:24:52 发布
最新推荐文章于 2021-05-01 19:24:52 发布
阅读量766 收藏
点赞数
分类专栏： C语言 数据结构 文章标签： 二叉树 先序遍历 迭代 C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yxp189/article/details/90306354
版权

【问题描述】

写出二叉树先序遍历的递归与非递归算法。

【实验要求】

用户以先序遍历的方式键入二叉树各结点的数据域值（字符型），程序建立二叉树，然后分别用递归和非递归算法对二叉树进行遍历。每访问一个结点即打印该结点的数据域值。

例如，要建立如下二叉树，用户需依次键入’A’, ’B’, ’D’, ’ ’, ’ ’, ’ ’, ’C’, ’ ’, ’ ’这几个字符。（请参考下文的生成二叉树的算法。）

README

Author:YXP
e-mail:yxp189@protonmail.com
如有问题，请我联系~
转载请标明出处~

源代码	main.c
输入文件	Test.txt （"A","B","D"," ","C"," "," "）
输出结果	result.txt

注意：

1. 同目录下，设置Test.txt文件，作为输入。

内容为：（具体按照题目要求调整）

输入文件-----Test.txt

ABD C

2.  本次代码中非递归遍历使用的方法-----针对题目给出的特定输入设计循环遍历。

    （以后将更新，使用栈的方法解决。）

    （有关栈的参考：双向栈的实现（数组））

实现代码：

基于层级数结构的框架实现，层级树结构的参考代码：实现任意层数、层长度 树结构（层次结构）----参考代码

                                                             相似应用例子：基数排序 （树结构/层级结构）

                                                                                      洗牌程序 （洗牌/箱子排序）

mian.c文件


#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
/*	
author:YXP
e-mail:yxp189@protonmail.com
如有问题，欢迎和我联系~
转载请标明出处~
*/
 
int NOW_LEVEL = 0;	//当前层级
int LEVEL = 2;		//搭建结构的层数；从0开始 
int TIME = 0;		//生成程序的迭代次数 
int PRINT_TIME = 0;	//打印的调用次数 
int counter = 0;	//层数计数器 
int NODE = 0;		//最底层分类数
 
struct _level {			//层级结构定义
	int level_th;				//第几层 
	int lenth;					//当前层的宽度 
	struct _level* last_level;	//上一层的地址 
	struct _level** next_level;	//下一层的链接 
	struct _node* head;			//储存节点头 
	struct _node* tail;			//储存末尾节点 
};
 
struct _node {			//数据节点定义 
	int CH_store;			//存储的字符
	int order;				//当前在节点在序列中的第几位
	int *traits;			//当前节点在层级中的位置
	struct _node* next;		//下一个节点
};
 
int Build_tree(struct _level** TOP, int *level_th, int level_num);	//生成层次结构 
void Initalize_level(struct _level** HEAD, int *level_th, int now_level_th);	//初始化层 
int Insert(struct _level** TOP,struct _node* Node,int* level_th);	//插入 
void Print_content(FILE *fp_w,struct _level** TOP,int *position_arr);			//打印指定位置元素 
void Print_All(FILE **fp_w,struct _level** TOP,int* level_th, int now_level_th);//打印出最底层元素的分布情况
void Print_All_Stack (FILE **fp_w,struct _level** TOP,int* level_th, int now_level_th);
int Find_ch_place(int CH,int** positin,int *level_th);			//找到字符（10x10）的插入位置 
int Create_struct_node(struct _node** Node,int CH,int *level_th,int order);//创建数据节点 
 
 
int main(int argc, char *argv[]) {
	clock_t start, finish;
	int level_th[3] = {1,2,2};	/*第一层一个点，第二层2个，第三层2个*/ //指定每一层的长度 
	struct _level* TOP = NULL;
	Build_tree(&TOP, level_th, LEVEL);//建立层级结构 
	
	
	printf ("@BUILDING...\n"); 
	
	int card;
	
	struct _node* Node;
	char* r_filename = "Test.txt";				//二读取文件中的内容“Test.txt”
	FILE* fp_r =fopen(r_filename, "r");	
	char* w_filename = "result.txt";			//二叉树的结果，输出到文件“result.txt”
	FILE* fp_w =fopen(w_filename, "w");	
	
	int i,num = 7;//总共的节点数目7 个 
	for (i=0;i<num;i++){
		fscanf(fp_r,"%c",&card);
		Create_struct_node(&Node,card,level_th,i);	//创建数据节点 
		Insert(&TOP,Node,Node->traits);	//在层级结构中插入数据节点
	}	
	printf ("@BUILDING END!\n");
	
	fprintf(fp_w," >>递归遍历\n");	
	Print_All(&fp_w,&TOP,level_th,NOW_LEVEL);//递归遍历 
	printf ("@Result_file has been sent to you folder! Pleae check it!\n");	
	
	fprintf(fp_w," >>非递归遍历\n");	
	Print_All_Stack (&fp_w,&TOP,level_th,1);// 非递归遍历 

	system("pause"); 
	return 0;
}
 
 
 
int Find_ch_place(int CH,int** positin,int *level_th)//对字符，找到应插入的位置
{
	int temp = CH;
	*positin = (int*)malloc((LEVEL+1)*sizeof(int));
	int i,gap = 10;
	//for (i=0;i<(LEVEL+1);i++){
		switch (CH){
			case 0:
				(*positin)[0] = 0;(*positin)[1] = -1;(*positin)[2] = -1;
				break;
			case 1:
				(*positin)[0] = 0;(*positin)[1] = 0;(*positin)[2] = -1;
				break;
			case 2:
				(*positin)[0] = 0;(*positin)[1] = 0;(*positin)[2] = 0;
				break;
			case 3:
				(*positin)[0] = 0;(*positin)[1] = 0;(*positin)[2] = 1;
				break;
			case 4:
				(*positin)[0] = 0;(*positin)[1] = 1;(*positin)[2] = -1;
				break;
			case 5:
				(*positin)[0] = 0;(*positin)[1] = 1;(*positin)[2] = 0;
				break;
			case 6:
				(*positin)[0] = 0;(*positin)[1] = 1;(*positin)[2] = 1;
				break;
			default :
				printf ("Find_ch_place overlod! Please Check!@\n");
				system("pause");
				break;	
		}
	//}
	return 0;
}
 
 
int Create_struct_node(struct _node** Node,int CH,int *level_th,int order)//创建数据节点
{
	*Node = (struct _node*)malloc(sizeof(struct _node));
	(*Node)->CH_store = CH;
	(*Node)->order = 0;
	(*Node)->next = NULL;
	Find_ch_place(order,&((*Node)->traits),level_th);
}
 
 
void Print_content(FILE *fp_w,struct _level** TOP,int *position_arr)//打印层级结构指定位置的元素
{
	struct _level** temp1 = NULL,**temp2 = TOP;
	int i,position;
	for(i=0;i<LEVEL;i++){
		temp1 = temp2;
		position = position_arr[i];
		if (fp_w != NULL){
			fprintf (fp_w,"%d-\n",position);
		}
		temp2 = (*temp1)[position].next_level;
	}
	position = position_arr[i];
	fprintf (fp_w,"%d-",position);
	
	struct _node* CH_store = (*temp2)[position].tail;
	if (CH_store != NULL){
		if (fp_w==NULL){
			printf ("Node = %c\n",CH_store->CH_store);
		}else{
			fprintf (fp_w,"Node = %c\t NUM = %d\n",CH_store->CH_store,CH_store->order+1);
		}
	}else{
		if (fp_w==NULL){
			printf ("%s\n","NULL");
		}else{
			fprintf (fp_w,"%s\n","NULL");
		}
	}
	
	
}
 
 
void Print_All(FILE **fp_w,struct _level** TOP,int* level_th, int now_level_th)//打印出总体的排序情况，并且输入到文件里。
{
	PRINT_TIME ++;
	int i = 0;
	for (i=0;i<level_th[now_level_th];i++)
	{
		int k;
		if(i == 0){
			fprintf (*fp_w,"\n");
		}
		for (k=0;k<now_level_th;k++){
			fprintf (*fp_w,"\t");
		}
		fprintf (*fp_w,"Lev= %d - Pos= %d -",now_level_th,i);
		if (now_level_th<LEVEL) {
				NOW_LEVEL++;
					if ((*TOP)[i].tail != NULL){
						fprintf (*fp_w,"Node= %c\tNUM= %d\n",((*TOP)[i].tail)->CH_store, ((*TOP)[i].tail)->order+1);
					}else{
						fprintf (*fp_w,"NULL\n");
					}
					Print_All(fp_w,&((*TOP)[i].next_level[0]), level_th, now_level_th+1);
				NOW_LEVEL--;
		}
		else {
			if(now_level_th == LEVEL){
				NODE ++;
				if ((*TOP)[i].tail != NULL){
					fprintf (*fp_w,"Node= %c\tNUM= %d\n",((*TOP)[i].tail)->CH_store, ((*TOP)[i].tail)->order+1);
				}else{
					fprintf (*fp_w,"NULL\n");
				}
			} 
		}
	}	
	return; 
}

 
 
void Print_All_Stack (FILE **fp_w,struct _level** TOP,int* level_th, int now_level_th)
{
	int now_level = 0,position = 0;
	int i,j,k;
	struct _level** temp1 = NULL,**temp2 = NULL;
	for (i=0;i<level_th[0];i++){
		if ((*TOP)[i].tail != NULL){
			fprintf (*fp_w,"%c",((*TOP)[i].tail)->CH_store);
		}else{
			fprintf (*fp_w,"Null ");
		}
		temp1 = (*TOP)[i].next_level;
		for (j=0;j<level_th[1];j++){
			if ((*temp1)[j].tail != NULL){
				fprintf (*fp_w,"\"%c\",",((*temp1)[j].tail)->CH_store);
			}else{
			fprintf (*fp_w,"Null ");
			}
			temp2 = (*temp1)[j].next_level;
			for (k=0;k<level_th[2];k++){
				if (((*temp2)[k].tail) != NULL){
					fprintf (*fp_w,"\"%c\",",((*temp2)[k].tail)->CH_store);
				}else{
					fprintf (*fp_w,"Null ");
				}
			}
		}
	}
}
 
int Insert(struct _level** TOP,struct _node* Node,int* level_th)//在层级结构中的指定位置插入元素
{
	int now_level = 0,position = 0;
	struct _level** temp1 = NULL,**temp2 = TOP;
	for (now_level=0;now_level<LEVEL;now_level++){
		temp1 = temp2;
		if (Node->traits[now_level+1] == -1){
			goto NOW_INSERT;
		}
		position = Node->traits[now_level];
		temp2 = (*temp1)[position].next_level;
	}
	NOW_INSERT:;
	position = Node->traits[now_level];
	if ((*temp2)[position].tail == NULL){
		Node->order = 0;
		(*temp2)[position].head = Node;
		(*temp2)[position].tail = Node;
	}else{
		Node->order = (*temp2)[position].tail->order + 1;
		(*temp2)[position].tail->next= Node;
		(*temp2)[position].tail = Node;
	}
	return 0;
}
 
 
int Build_tree(struct _level** TOP, int *level_th, int level_num)//搭建层级结构（树）
{
	Initalize_level(TOP, level_th, NOW_LEVEL);
	return 0;
}
 
 
void Initalize_level(struct _level** HEAD, int *level_th, int now_level_th)//初始化层级结构的每一层
{	
	TIME ++;
	int i = 0;
	(*HEAD) = (struct _level*)malloc(level_th[now_level_th]*sizeof(struct _level));
	for (i=0;i<level_th[now_level_th];i++)
	{
		(*HEAD)[i].level_th = now_level_th;
		(*HEAD)[i].lenth = level_th[now_level_th];
		if (now_level_th == 0) {
			(*HEAD)[i].last_level = NULL;
		}
		else {
			(*HEAD)[i].last_level = *HEAD;
		}
			(*HEAD)[i].head = NULL;
			(*HEAD)[i].tail = NULL;
		if (now_level_th<LEVEL) {
			(*HEAD)[i].next_level = (struct _level**)malloc(level_th[now_level_th+1] * sizeof(struct _level*));
				NOW_LEVEL++;
				Initalize_level(&((*HEAD)[i].next_level[0]), level_th, now_level_th+1);
				NOW_LEVEL--;
		}
		else {
			(*HEAD)[i].next_level = NULL;
		}
	}	 	
}

输出结果-----result.txt

 >>递归遍历

Lev= 0 - Pos= 0 -Node= A	NUM= 1

	Lev= 1 - Pos= 0 -Node= B	NUM= 1

		Lev= 2 - Pos= 0 -Node= D	NUM= 1
		Lev= 2 - Pos= 1 -Node=  	NUM= 1
	Lev= 1 - Pos= 1 -Node= C	NUM= 1

		Lev= 2 - Pos= 0 -Node=  	NUM= 1
		Lev= 2 - Pos= 1 -Node=  	NUM= 1
 >>非递归遍历
A"B","D"," ","C"," "," ",

 

yxp189
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——二叉排序树的创建、插入、查找（循环和递归）
Prescu的博客
07-10 870
#include <stdio.h> #include <stdlib.h> typedef struct BSTNode{ int data; struct BSTNode *lchild,*rchild; }BSTNode,*BiTree; BSTNode *BST_Search1(BiTree T,int key){ //查找值为key的结点(while循环) while(T!=NULL&&key!=T->data){ if(key<
【算法】二叉树的数据插入算法超细详解
qq_38326829的博客
12-18 5148
二叉树 二叉树插入数值 算法 详解 JAVA 递归 迭代
二叉树遍历、插入、删除等常见操作
热门推荐
Sunshine的专栏
12-03 1万+
1.二叉查找树的创建 2.二叉查找树清空 3.二叉查找树查询 4.查找最大值、最小值 5.二叉查找树插入操作 6.二叉查找树的删除操作 7.分别使用非递归和递归方式（部分用多种方式）实现树的先序遍历、中序遍历和后序遍历
二叉排序树
coderge's CSDN Blog.
07-20 1309
定义： 二叉排序树是一棵二叉树，或者为空，或者满足以下条件： 1)若左子树不空，则左子树中所有结点的值小于根结点的值； 2)若右子树不空，则右子树中所有结点的值不小于根结点的值； 3)左右子树都为二叉排序树。 由定义可推出二叉排序树的特点：按照左、中、右的次序遍历，所得到的中序序列是非降序列。 二叉排序树的查找： 如何在二叉排序树中查找给定关键字的结点？ 以在下图所示树中分别查找45、55、66为例来说明。 由此可得到查找的判定过程。 ...
二叉查找树的循环插入以及使用循环和递归的两种先序遍历方式
weixin_42254919的博客
08-19 652
二叉查找树的循环插入以及使用循环和递归的两种先序遍历方式 这是我第一次写博客，作为一个半路出家的预备程序员，在学习的同时，希望可以记录下来，以便自己以后回顾的时候能有所了解。（希望大家不要吐槽我的排版）。话不多说，上干货。 使用一个内部类来当做树的节点 循环插入元素 先序遍历的递归实现 先序遍历的循环实现 成员变量 public class BinTree&amp;lt;T&amp;gt; {...
Project2_二叉树_先序遍历_后序遍历_中序遍历_
10-04
在实际编程中，二叉树遍历的应用广泛，例如在编译器设计中解析语法树、在文件系统中查找文件、在数据库中进行查询优化等。因此，理解和掌握二叉树的遍历方法对于提升编程能力及解决实际问题具有重要意义。通过...
二叉树的先序遍历
07-08
先序遍历是二叉树遍历的一种基本方法，其顺序为：访问根节点 -> 左子树 -> 右子树。在描述中提到的实现方式是通过递归完成，这是最常见的先序遍历实现策略。递归算法的基本思想是将问题分解为更小的子问题，直至子...
二叉树遍历问题，总结递归和迭代解法
11-29
} }总结二叉树的遍历是数据结构中的基础操作，理解递归和迭代解法对于解决更复杂的二叉树问题至关重要。递归方法简洁明了，易于理解，但可能会导致较大的函数调用开销。而迭代方法通常效率更高，但实现起来可能更...
C语言实现二叉树遍历的迭代算法
09-04
二叉树遍历是指按照特定顺序访问树中的每一个节点，常见的遍历方法有三种：先序遍历、中序遍历和后序遍历。在本篇文章中，我们将探讨如何使用C语言实现这些遍历方法的迭代算法。 1. 先序遍历（Preorder Traversal）...
二叉树遍历问题先序遍历、中序遍历和后序遍历等等最新详情介绍.docx
最新发布
07-24
### 二叉树遍历详解 #### 一、概述 二叉树遍历是指按特定顺序访问二叉树中的每一个节点。二叉树作为一种重要的数据结构，在计算机科学中有着广泛的应用，例如在编译器中表示语法树、构建索引等场景。二叉树遍历...
先序递归建立二叉树
11-22
用先序递归过程建立二叉树 (存储结构：二叉链表) 输入数据按先序遍历所得序列输入，当某结点左子树或右子树为空时，输入‘*’号
二叉树三种遍历，先序和中序建立二叉树，后序和中序建立二叉树，二叉搜索树查找，删除，插入
11-20
大连理工大学数据结构上机 二叉树三种遍历，先序和中序建立二叉树，后序和中序建立二叉树，二叉搜索树查找，删除，插入
二叉树先序遍历（递归与非递归）及C语言实现
数据结构和算法教程（C语言版）
03-18 6317
二叉树先序遍历的实现思想是： 访问根节点； 访问当前节点的左子树； 若当前节点无左子树，则访问当前节点的右子树； 图1 二叉树 以图 1 为例，采用先序遍历的思想遍历该二叉树的过程为： 访问该二叉树的根节点，找到 1； 访...
二叉排序树的创建、插入和遍历（代码）
沐雨金鳞
11-08 896
/* 二叉排序树的创建、插入、遍历 样例输入 5 1 6 5 9 8 样例输出 1 6 5 9 8 1 5 6 8 9 5 8 9 6 1 */ #include<stdio.h> #include<string> using namespace std; //数据结构 struct Node { Node *lchild; Node *rchild; int c; } Tr
二叉树的基本操作实现（包括先序、中序、后序遍历，以及层序遍历）
晊恦的博客
12-09 4650
代码要求 按先序序列构造一棵二叉链表表示的二叉树T； 对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出结点的遍历序列； 输入要求 从键盘接受输入（先序），以二叉链表作为存储结构，建立二叉树（以先序来建立）。 1、首先，定义二叉树 #include<iostream> using namespace std; #define MAXSIZE 100 typedef str...
根据先序遍历输入，构建二叉树(不同于层次遍历)
NoahBBQ的博客
05-01 1531
文章目录前言一、思想基于递归遍历二、构建二叉树1.先判断遍历顺序2.根据遍历类型写代码总结 前言 由于之前王老师讲了怎么通过递归的方式利用 遍历序列的输入顺序构建 二叉树 一、思想基于递归遍历 例如 先序遍历 1 2 4 0 0 5 6 0 0 7 0 0 3 0 0 -1 (0表示当前结点为空，-1表示输入结束) 二、构建二叉树 1.先判断遍历顺序 如上面写的 先序序列 2.根据遍历类型写代码 代码如下（示例）： #include<bits/stdc++.h> using names
二叉树 - 通过不断的插入生成一棵二叉搜索树（C语言）
biaogexf
03-31 4212
二叉搜索树：其各个节点的关键字码必须是唯一的；若某结点左子树非空，则左子树上的所有节点的值均小于该结点的关键字码，而其右子树上的所有节点的值均大于该结点的关键字码。所以，按照中序周游整个二叉树的可以得到一个由小到大的有序排列。通过不断读取数组中的数据而插入生成的二叉搜索树的代码如下：/* 二叉搜索树 - 通过不断插入建立一棵二叉搜索树 */ #include "stdafx.h" #includ...
java按照先序遍历的顺序输入一串数字创造一棵树（不用递归）
takusang的博客
03-03 718
这题的初衷并不是造树，但我的同学托给我这差事，就答应了，然而网上都是先创建节点和左右孩子的实体类，利用递归进行造树，而我想另辟蹊径，代码如下（代码中的nodeWaitList可以用栈代替，毕竟和递归相似，它也是压栈的过程，主要我同学不会使用栈，就还是用了ArrayList）： public class tree { //储存所有输入的值的数组列表 static ArrayList...
矩阵运算库 C语言 (Matrix_hub)
yxp189的博客
02-12 1万+
Matrix_hub ======================================= 矩阵运算库--C语言 --------------------------------------- ##The lib of Matrix operation for C language. (矩阵运算库--C语言) Author: Amoiensis Email: Amoiensis@o...
二叉树先序遍历算法详解
先序遍历是一种遍历或访问二叉树所有节点的方法，是数据结构中处理树形结构的重要操作。在这个过程中，节点按照特定顺序进行访问：首先访问根节点，然后递归地先序遍历左子树，最后先序遍历右子树。这种遍历方式适用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值