先序遍历的非递归算法 C语言
一种二叉树非递归遍历算法的C语言实现
Ｔ ｅ ｌ ： ＋ ８ ６ — ５ ５ １ － ６ ５ ６ ９ ０ ９ ６ ３ ６ ５ ６ ９ ０ ９ ６ ４
一
种 二 叉树 非 递 归 遍历 算 法 的 Ｃ语 言实 现
龚 佳 ， 袁 赘 ， 刘 远 军
（ 邵阳学院 信息工程系 ， 湖南 邵阳 ４ ２ ２ ０ ０ ４ ）
摘要 ： 针对二叉树 的链 式存储 结构 ， 分析 了二叉树 的各种遍 历算法 ， 探 讨 了递 归算 法的递推 消除问题 ， 提 出了一种改进的 非递归遍 历算法并用Ｃ语言 予以实现。
收 稿 日期 ： ２ ０ １ ３ — １ １ — １ ５
ｍｅ ｎｔ ｅ ｄ ｉ ｎ Ｃ ｌ ａ ｎｇ ｕａ ｇｅ ． Ｋｅ ｙ ｗｏ ｒ ｄｓ ：ｂｉ ｎａ ｙ ｒ ｔ ｒ ｅ ｅ ； ｔ ｒ ａ ｖｅ ｒ ｓ ａ ｌ ａ ｌ ｇ ｏｒ ｉ ｔ ｈ ｍ； ｎｏｎ— — ｒ ｅ ｃ ｕ ｒ ｓ ｉ ｖｅ ；Ｃ ｌ ａ ｎｇ ｕａ ｇｅ
ＧＯＮＧ Ｊ ｉ ａ ， Ｙ ＵＡ Ｎ Ｙ ｕ ｎ ， Ｌ Ｉ Ｕ Ｙ ｕ ｎ － ｊ ｔ ｉ ｎ
（ Ｉ ｎ ｆ ｏ ｒ ｍａ ｔ ｉｐ ａ ｒ ｔ ｍｅ ｎ ｔ ， Ｓ ｈ ａ ｏ ｙ ａ ｎ ｇ Ｕｎ ｉ ｖ ｅ ｒ ｓ ｉ ｔ ｙ ， Ｓ ｈ ａ ｏ ｙ ａ ｎ ｇ ４ ２ ２ ０ ０ ４ ， Ｃ ｈ ｉ ｎ ａ ）
一
个结点 至少 由３ 个 域组成 ， 即数据域 、 左子结点域和右子结点域 （ 如图１ 所示 ） 。
图１
为了更好 的对树结构进行计算和处理 ， 我们 可以加上一个 双亲结点域（ 如 图２ 所示 ） 。
！ｆ ｌ ！ ！
图２
Ｌ
＿
！ Ｉ ！ 二 ！ Ｊ
Ｉ Ｄ ａ ｔ ｅ
c语言红黑树遍历序算法
c语言红黑树遍历序算法红黑树是一种自平衡的二叉查找树，它具有良好的平衡性能，能够保持在较低的高度范围内。
在C语言中，我们可以使用递归或者非递归的方式来实现红黑树的遍历。
下面我将分别介绍中序遍历、前序遍历和后序遍历的算法。
1. 中序遍历算法：中序遍历的顺序是先遍历左子树，然后访问根节点，最后遍历右子树。
在C语言中，我们可以使用递归实现中序遍历：c.void inOrderTraversal(struct Node root) {。
if (root != NULL) {。
inOrderTraversal(root->left);printf("%d ", root->data);inOrderTraversal(root->right);}。
}。
2. 前序遍历算法：前序遍历的顺序是先访问根节点，然后遍历左子树，最后遍历右子树。
同样可以使用递归实现前序遍历：c.void preOrderTraversal(struct Node root) {。
if (root != NULL) {。
printf("%d ", root->data);preOrderTraversal(root->left);preOrderTraversal(root->right);}。
}。
3. 后序遍历算法：后序遍历的顺序是先遍历左子树，然后遍历右子树，最后访问根节点。
同样可以使用递归实现后序遍历：c.void postOrderTraversal(struct Node root) {。
if (root != NULL) {。
postOrderTraversal(root->left);postOrderTraversal(root->right);printf("%d ", root->data);}。
}。
另外，以上是使用递归实现的遍历算法，也可以使用非递归的方式来实现，利用栈来辅助实现遍历。
广度优先遍历非递归算法
广度优先遍历非递归算法
广度优先遍历（BFS）是一种图的遍历算法，用来遍历图中所有的节点。
以下是广度优先遍历的非递归算法：
1. 创建一个队列，用来存放待访问的节点。
2. 将起始节点放入队列中。
3. 创建一个集合，用来存放已经访问过的节点。
4. 将起始节点加入到已访问节点的集合中。
5. 循环执行以下步骤，直到队列为空为止：
5.1. 从队列中取出一个节点。
5.2. 访问该节点。
5.3. 获取该节点的所有相邻节点。
5.4. 对于每个相邻节点，如果它没有被访问过，则将其加入到队列和已访问节点的集合中。
通过以上步骤，可以按广度优先的顺序遍历整个图。
这种非递归算法利用队列的先进先出（FIFO）特性，保证了相邻节点的访问顺序是按照它们与起始节点的距离逐渐增加的顺序进行的，从而实现了广度优先遍历。
c语言fibonacci数列非递归
c语言fibonacci数列非递归Fibonacci数列是一个经典的数学问题，它的前两项是0和1，而后续项是前两项的和。
数列的前几项是：0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...在C语言中，我们可以使用非递归的方法来生成Fibonacci数列。
非递归的方法更高效，因为它不会遇到递归调用所带来的额外开销。
下面我将详细介绍如何使用非递归方法生成Fibonacci数列，并给出相应的C语言代码。
算法思路：1. 为了生成Fibonacci数列，我们需要一个数组来存储数列的值。
由于我们不知道数列的长度，所以我们需要选择一个足够大的数组来存储数列的值。
在这里，我们选择一个包含1000个元素的整型数组来存储数列的值。
2. 数列的第一个和第二个元素是已知的，所以我们在数组中分别存储0和1。
3. 接下来，我们使用一个循环从第三个元素开始生成数列的值。
循环从3一直到1000进行遍历，以确保数组足够大，同时也为了保证我们能生成至少1000个数。
4. 在每次循环中，我们将前两个元素的和存储到第三个元素中，然后将前两个元素的值更新为当前元素和前一个元素。
5. 最后，我们通过循环遍历生成的数列，并将其打印出来。
下面是相应的C语言代码：c#include<stdio.h>int main() {int fibonacci[1000];int i;fibonacci[0] = 0;fibonacci[1] = 1;for (i = 2; i < 1000; i++) {fibonacci[i] = fibonacci[i-1] + fibonacci[i-2];}for (i = 0; i < 1000; i++) {printf("%d ", fibonacci[i]);}return 0;}在上述代码中，我们使用一个整型数组`fibonacci`来存储Fibonacci数列的值。
c语言二叉树的先序,中序,后序遍历
c语言二叉树的先序,中序,后序遍历1、先序遍历先序遍历可以想象为，一个小人从一棵二叉树根节点为起点，沿着二叉树外沿，逆时针走一圈回到根节点，路上遇到的元素顺序，就是先序遍历的结果先序遍历结果为：A B D H I E J C F K G2、中序遍历中序遍历可以看成，二叉树每个节点，垂直方向投影下来（可以理解为每个节点从最左边开始垂直掉到地上），然后从左往右数，得出的结果便是中序遍历的结果中遍历结果为：H D I B E J A F K C G3、后序遍历后序遍历就像是剪葡萄，我们要把一串葡萄剪成一颗一颗的。
还记得我上面提到先序遍历绕圈的路线么？（不记得翻上面理解）就是围着树的外围绕一圈，如果发现一剪刀就能剪下的葡萄（必须是一颗葡萄）（也就是葡萄要一个一个掉下来，不能一口气掉超过1个这样），就把它剪下来，组成的就是后序遍历了。
后序遍历中，根节点默认最后面后序遍历结果：H I D J E B K F G C A4、口诀先序遍历：先根再左再右中序遍历：先左再根再右后序遍历：先左再右再根这里的根，指的是每个分叉子树（左右子树的根节点）根节点，并不只是最开始头顶的根节点，需要灵活思考理解5、代码展示#include<stdio.h>#include<stdlib.h>typedef struct Tree{int data; // 存放数据域struct Tree *lchild; // 遍历左子树指针struct Tree *rchild; // 遍历右子树指针}Tree,*BitTree;BitTree CreateLink(){int data;int temp;BitTree T;scanf("%d",&data); // 输入数据temp=getchar(); // 吸收空格if(data == -1){ // 输入-1 代表此节点下子树不存数据，也就是不继续递归创建return NULL;}else{T = (BitTree)malloc(sizeof(Tree)); // 分配内存空间T->data = data; // 把当前输入的数据存入当前节点指针的数据域中printf("请输入%d的左子树: ",data);T->lchild = CreateLink(); // 开始递归创建左子树printf("请输入%d的右子树: ",data);T->rchild = CreateLink(); // 开始到上一级节点的右边递归创建左右子树return T; // 返回根节点}}// 先序遍历void ShowXianXu(BitTree T) // 先序遍历二叉树{if(T==NULL) //递归中遇到NULL，返回上一层节点{return;}printf("%d ",T->data);ShowXianXu(T->lchild); // 递归遍历左子树ShowXianXu(T->rchild); // 递归遍历右子树}// 中序遍历void ShowZhongXu(BitTree T) // 先序遍历二叉树{if(T==NULL) //递归中遇到NULL，返回上一层节点{return;}ShowZhongXu(T->lchild); // 递归遍历左子树printf("%d ",T->data);ShowZhongXu(T->rchild); // 递归遍历右子树}// 后序遍历void ShowHouXu(BitTree T) // 后序遍历二叉树{if(T==NULL) //递归中遇到NULL，返回上一层节点{return;}ShowHouXu(T->lchild); // 递归遍历左子树ShowHouXu(T->rchild); // 递归遍历右子树printf("%d ",T->data);}int main(){BitTree S;printf("请输入第一个节点的数据:\n");S = CreateLink(); // 接受创建二叉树完成的根节点printf("先序遍历结果: \n");ShowXianXu(S); // 先序遍历二叉树printf("\n中序遍历结果: \n");ShowZhongXu(S); // 中序遍历二叉树printf("\n后序遍历结果: \n");ShowHouXu(S); // 后序遍历二叉树return 0;}。
汉诺塔问题非递归算法c语言
汉诺塔问题非递归算法c语言汉诺塔问题是一个经典的数学问题，也是一个常见的编程练习题。
在这个问题中，有三根柱子和一些圆盘，圆盘的大小不一，从小到大依次叠放在一根柱子上。
目标是将所有的圆盘从一根柱子移动到另一根柱子，移动过程中要保证大的圆盘在小的圆盘上面。
同时，每次只能移动一个圆盘，且不能把一个大的圆盘放在一个小的圆盘上面。
在解决汉诺塔问题时，通常采用递归算法。
但是递归算法的效率并不高，因为每次递归都会产生额外的函数调用，增加了系统的开销。
因此，我们可以通过非递归的方式来解决汉诺塔问题，提高算法的效率。
以下是一个用C语言实现的汉诺塔问题的非递归算法：```c#include <stdio.h>#include <stdlib.h>typedef struct {int n;char start, end, temp;} StackNode;typedef struct {StackNode data[100];int top;} Stack;void push(Stack *s, StackNode node) {s->data[s->top++] = node;}StackNode pop(Stack *s) {return s->data[--s->top];}void hanoi(int n, char start, char end, char temp) {Stack s;s.top = 0;StackNode node;node.n = n;node.start = start;node.end = end;node.temp = temp;push(&s, node);while (s.top > 0) {node = pop(&s);if (node.n == 1) {printf("Move disk 1 from %c to %c\n", node.start, node.end); } else {StackNode node1, node2, node3;node1.n = node.n - 1;node1.start = node.temp;node1.end = node.end;node1.temp = node.start;push(&s, node1);node2.n = 1;node2.start = node.start;node2.end = node.end;node2.temp = node.temp;push(&s, node2);node3.n = node.n - 1;node3.start = node.start;node3.end = node.end;node3.temp = node.temp;push(&s, node3);}}}int main() {int n;printf("Enter the number of disks: "); scanf("%d", &n);hanoi(n, 'A', 'C', 'B');return 0;}```在这个非递归算法中，我们使用了一个栈来模拟递归的过程。
c语言判断回文(递归法,非递归法)
return 0; } } int main() { int n; printf("输入一串字符以判断是否为回文。\n"); scanf("%s",&a); n=strlen(a); if(isPalindrome(n)) printf("输入的是回文。\n"); else printf("输入的不是回文。\n"); }
编写程序判断一个字符串是否为回文，要求使用递归方法实现。
代码： #include<stdio.h> #include<string.hindrome(int i) {
int m; m=strlen(a); if(i<=1) return 1; if(a[m-i]==a[i-1]) {
编写程序判断一个字符串是否为回文，要求使用非递归方法实现。
代码： #include<stdio.h> #include<string.h> #include<stdlib.h> void main() {
char ch[100]; //存放键入的字符串 int i,j; printf("输入一串字符以判断是否为回文。\n"); scanf("%s",ch); //接受键入的字符串 i=0; j=strlen(ch)-1; while(i<j) if(ch[i]==ch[j]) {i++; j--; } else break; if(i>=j) printf("输入的是回文。\n"); else printf("输入的不是回文。\n"); }
先序遍历的非递归算法
数据结构1、先序遍历的非递归算法。
用c语言写。
void PreOrderUnrec(Bitree t){SqStack s;StackInit(s);p=t;while (p!=null || !StackEmpty(s)){while (p!=null) //遍历左子树{visite(p->data);push(s,p);p=p->lchild;}//endwhileif (!StackEmpty(s)) //通过下一次循环中的内嵌while实现右子树遍历{ p=pop(s);p=p->rchild;}//endif}//endwhile}//PreOrderUnrec/////////////////////////////////#include "stdio.h"#include "stdlib.h"#include "string.h"#define null 0struct node{char data;struct node *lchild;struct node *rchild;};//先序,中序建树struct node *create(char *pre,char *ord,int n){struct node * head;int ordsit;head=null;if(n<=0){return null;}else{head=(struct node *)malloc(sizeof(struct node)); head->data=*pre;head->lchild=head->rchild=null;ordsit=0;while(ord[ordsit]!=*pre){ordsit++;}head->lchild=create(pre+1,ord,ordsit);head->rchild=create (pre+ordsit+1,ord+ordsit+1,n-ordsit-1); return head;}}//中序递归遍历void inorder(struct node *head){if(!head)return;else{inorder(head->lchild );printf("%c",head->data );inorder(head->rchild );}}//中序非递归遍历void inorder1(struct node *head) {struct node *p;struct node *stack[20];int top=0;p=head;while(p||top!=0){while (p){stack[top++]=p;p=p->lchild ;}p=stack[--top];printf("%c ",p->data );p=p->rchild ;}}/////////////////////////////////////////////////////////////////// ////////////////////二叉树前序、中序、后序三种遍历的非递归算法1.先序遍历非递归算法void PreOrderUnrec(Bitree *t){Stack s;StackInit(s);Bitree *p=t;while (p!=NULL || !StackEmpty(s)){while (p!=NULL) //遍历左子树{visite(p->data);push(s,p);p=p->lchild;}if (!StackEmpty(s)) //通过下一次循环中的内嵌while实现右子树遍历{p=pop(s);p=p->rchild;}//endif}//endwhile}2.中序遍历非递归算法void InOrderUnrec(Bitree *t){Stack s;StackInit(s);Bitree *p=t;while (p!=NULL || !StackEmpty(s)){while (p!=NULL) //遍历左子树{push(s,p);p=p->lchild;}if (!StackEmpty(s)){p=pop(s);visite(p->data); //访问根结点p=p->rchild; //通过下一次循环实现右子树遍历}//endif }//endwhile}3.后序遍历非递归算法typedef enum{L,R} tagtype;typedef struct{Bitree ptr;tagtype tag;}stacknode;typedef struct{stacknode Elem[maxsize];int top;}SqStack;void PostOrderUnrec(Bitree t) {SqStack s;stacknode x;StackInit(s);p=t;do{while (p!=null) //遍历左子树{x.ptr = p;x.tag = L; //标记为左子树push(s,x);p=p->lchild;}while (!StackEmpty(s) && s.Elem[s.top].tag==R){x = pop(s);p = x.ptr;visite(p->data); //tag为R,表示右子树访问完毕,故访问根结点} if (!StackEmpty(s)){s.Elem[s.top].tag =R; //遍历右子树p=s.Elem[s.top].ptr->rchild;}}while (!StackEmpty(s));}//PostOrderUnrec二。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
}
if(* BT==NULL) * BT=p;
else
{
if(k==1) s[top]->left=p;
else s[top]->right=p;
}
}
else {printf("二叉树广义表字符串有错!\n");exit(1);}
}
i++;
}
}
void Preorder(struct BTreeNode * BT)
p=p->left;
}
if(top!=-1)
{
p=s[top];
top--;
p=p->right;
}
}
}
void main()
{
struct BTreeNode * p;
char * a="A(B(C),D(E(F,G),H(,I)))";
InitBTree(&p);
CreatBTree(&p,a);
{
* BT=NULL;
}
void CreatBTree(struct BTreeNode * * BT,char * a)
{
struct BTreeNode * p;
struct BTreeNode * s[MS];
int top=-1;
int k;
int i=0;
* BT=NULL;
while(a[i])
exit(1);
}
top--;break;
case ',' : k=2;break;
default :
if((a[i]>='a'&&a[i]<='z')||(a[i]>='A'&&a[i]<='Z'))
{
p=malloc(sizeof(struct BTreeNode));
p->data=a[i];p->left=p->right=NULL;
{
structBTreeNode * s[10];
int top=-1;
structBTreeNode * p=BT;
printf("先序遍历结点的访问序列为:\n");
while(top!=-1||p!=NULL)
{
while(p!=NULL)
{
top++;
s[top]=p;
printf("%c",p->data);
先序遍历的非递归算法
#include<stdio.h>
#include<stdlib.h>
#define MS 10
struct BTreeruct BTreeNode * left;
struct BTreeNode * right;
};
void InitBTree(struct BTreeNode * * BT)
{
switch(a[i])
{
case ' ':break;
case '(':
if(top==MS-1)
{
printf("栈空间太小，需增加MS的值!\n");
exit(1);
}
top++;s[top]=p;k=1;
break;
case ')':
if(top==-1)
{
printf("二叉树广义表字符串有错!\n");