精华内容
下载资源
问答
  • c c++ c语言遍历文件夹 c语言读文件 c语言写文件 高效算法
  • C语言二叉树三种遍历算法及其广义表表示 VS2012编写 基于先序遍历的构造算法:输入是二叉树的先序序列,但必须在其中加入虚结点以示空指针的位置。假设虚结点输入时用’.’字符表示。 分别利用先序遍历、中序遍历、...
  • 常用c语言算法,包括数论算法,图论算法、排序算法、高精度计算、树的遍历算法等等
  • 深度优先遍历 #include"./Graph.cpp" int visited[MAXV]; void DFS(MGraph g,int v) { int w; printf("%3d",v);//输出被访问顶点的编号 visited[v]=1;//置已访问标记 for(w=0;w<g.n;w++)//找定点V的所有...

    深度优先遍历

    #include"./Graph.cpp"
    int visited[MAXV];
    void DFS(MGraph g,int v)
    {
    	int w;	
    	printf("%3d",v);//输出被访问顶点的编号 
    	visited[v]=1;//置已访问标记 
    	for(w=0;w<g.n;w++)//找定点V的所有相邻点 
    		if(g.edges[v][w]!=0&&g.edges[v][w]!=INF&&visited[w]==0)
    			DFS(g,w);//找顶点V味访问的相邻定点W 
    }
    int main()
    {
    	MGraph g;
    	int A[][MAXV]={
    					{INF,4,6,6,INF,INF,INF},
    					{4,INF,1,INF,7,INF,INF},
    					{6,1,INF,2,6,4,INF},
    					{6,INF,2,INF,INF,1,6},
    					{INF,7,6,INF,INF,1,6},
    					{INF,INF,4,5,1,INF,8},
    					{INF,INF,INF,INF,6,8,INF}
    					};
    	int n=7,e=12;
    	CreateMat(g,A,n,e);//创建邻接矩阵 
    	printf("图的邻接矩阵");
    	DispMat(g);//输出邻接矩阵 
    	printf("深度优先遍历\n");
    	DFS(g,0);//调用深度优先遍历 
    } 
    
    
    展开全文
  • 二叉树的非递归前、中、后序遍历算法详解及代码实现(C语言) 1. 前序遍历和中序遍历非递归算法思路 前序和中序非递归遍历的C代码 2. 后序遍历非递归算法思路 后序非递归遍历的C代码 1. 前序遍历和中序遍历非...

    转载请注明出处:https://blog.csdn.net/Benja_K/article/details/88389039

    二叉树的非递归前、中、后序遍历算法详解及代码实现(C语言)

    1. 前序遍历和中序遍历非递归算法思路

    前序和中序非递归遍历的C代码

    2. 后序遍历非递归算法思路

    后序非递归遍历的C代码


    1. 前序遍历和中序遍历非递归算法思路

    遍历过程:(如图所示)

    图1 前序遍历和中序遍历流程图

     

    从当前节点开始遍历:(当入栈时访问节点内容,则为前序遍历;出栈时访问,则为中序遍历)

    1. 若当前节点存在,就存入栈中,并访问左子树;

    2. 直到当前节点不存在,就出栈,并通过栈顶节点访问右子树;

    3. 不断重复12,直到当前节点不存在且栈空。

     

    Tips:我们很容易发现,在理解并写好该非递归遍历代码后,只需要在入栈、出栈的时候,分别进行节点访问输出,即可分别得到前序、中序的非递归遍历代码!!!

     

    便于理解的伪代码:

    void preOrder(TreeNode *T){
        p = T
        while(p不空||栈不空){
            if(p不空){      //两种情况:1.栈不空;2.栈空
                p入栈;
                (前序遍历,访问)
                入p左子节点;
            }else{            //一种情况:当前节点为空,但栈不空
                p=出栈;
                (中序遍历,访问)
                入p右子节点;
            }
        }
    }

    前序和中序非递归遍历的C代码

    二叉树节点结构体:

    typedef struct TreeNode{
        int data;
        struct TreeNode *lChild;
        struct TreeNode *rChild;
    }TreeNode;

    前序遍历非递归:

    void preOrder(TreeNode *T){
        TreeNode *stack[15];
        int top = -1;
        TreeNode *p = T;
        while(p!=NULL||top!=-1){
            if(p!=NULL){
                stack[++ top] = p;
                printf("%d\t",p->data); //入栈时,访问输出
                p = p->lChild;
            }else{
                p = stack[top --];
                p = p->rChild;
            }
        }
    }

    中序遍历非递归:

    void inOrder(TreeNode *T){
        TreeNode *stack[15];
        int top = -1;
        TreeNode *p = T;
        while(p!=NULL||top!=-1){
            if(p!=NULL){
                stack[++ top] = p;
                p = p->lChild;
            }else{
                p = stack[top --];
                printf("%d\t",p->data);  //出栈时,访问输出
                p = p->rChild;
            }
        }
    }

    2. 后序遍历非递归算法思路

    后序遍历整体与前中序遍历过程相似。但要注意,这时对于父节点的访问输出,需要在其右子树遍历完成的前提下进行。所以不能像前中序遍历一样,在遍历完左子树后,就直接出栈。我们需要利用这个未出栈的栈顶元素去获取右子树,在遍历完右子树后,就可以出栈,并对此节点进行访问输出。

    这里我们需要使用一个标记,以区分是从左子树取栈还是从右子树出栈:(如图所示)

    图2 后序遍历流程图

     

    从当前节点开始遍历:

    1. 若当前节点存在,就存入栈中,并且置节点flag为1(第一次访问),然后访问其左子树;

    2. 直到当前节点不存在,需要回退,这里有两种情况:

           1)当栈顶节点flag为1时,则表明是从左子树回退,这时需置栈顶节点flag为2(第二次访问),然后通过栈顶节点访问其右子树(取栈顶节点用,但不出栈)

           2)当栈顶节点flag为2时,则表明是从右子树回退,这时需出栈,并取出栈节点做访问输出。(需要注意的是,输出完毕需要置当前节点为空,以便继续回退。具体可参考代码中的p = NULL)

    3. 不断重复12,直到当前节点不存在且栈空。

     

    Tips:我们很容易发现,当理解并写好后序遍历非递归代码后,只需要在入栈、取栈、出栈的时候,分别进行节点访问输出,即可分别得到前序、中序、后序的非递归遍历代码,是不是非常简单!!!

     

    后序非递归遍历的C代码

    节点结构体:

    typedef struct TreeNode{
        int data;
        struct TreeNode *lChild;
        struct TreeNode *rChild;
    }TreeNode;

    后序遍历非递归:

    void postOrder(TreeNode *T){
        TreeNode *stack[15];
        int top = -1;
        int flagStack[15];   //记录每个节点访问次数栈
        TreeNode *p = T;
        while(p!=NULL||top!=-1){
            if(p!=NULL){     //第一次访问,flag置1,入栈
                stack[++ top] = p;
                flagStack[top] = 1;   
                p = p->lChild;
            }else{//(p == NULL)
                if(flagStack[top] == 1){  //第二次访问,flag置2,取栈顶元素但不出栈
                    p = stack[top];
                    flagStack[top] = 2;
                    p = p->rChild;
                }else{         //第三次访问,出栈
                    p = stack[top --];
                    printf("%d\t",p->data);    //出栈时,访问输出
                    p = NULL;      //p置空,以便继续退栈
                }
            }
        }
    }

     

    展开全文
  • 数据结构C语言版二叉树多种遍历算法(前序、中序、后序并且分别有递归和非递归两种,层次遍历)实现.
  • 主要介绍了C语言数据结构之二叉树的非递归后序遍历算法的相关资料,希望通过本文能帮助到大家,让大家实现这样的功能,需要的朋友可以参考下
  • 二叉树的定义就是用的递归的方式,所以实现遍历算法也可以用递归 二叉树的前序遍历算法代码: /* 二叉树的前序遍历递归算法 */ /* 初始条件: 二叉树T存在 */ /* 操作结果: 前序递归遍历T */ void PreOrderTraverse...

    我的首发平台是公众号【CodeAllen】,学习交流QQ群:736386324

    二叉树的定义就是用的递归的方式,所以实现遍历算法也可以用递归

    二叉树的前序遍历算法代码:

    /* 二叉树的前序遍历递归算法 */
    /* 初始条件: 二叉树T存在 */
    /* 操作结果: 前序递归遍历T */
    void PreOrderTraverse(BiTree T)
    { 
        if(T==NULL)
            return;
        printf("%c",T->data);       /* 显示结点数据,可以更改为其它对结点操作 */
        PreOrderTraverse(T->lchild);/* 再先序遍历左子树 */
        PreOrderTraverse(T->rchild);/* 最后先序遍历右子树 */
    }
    

    二叉树先序遍历的实现思想是:
    访问根节点;
    访问当前节点的左子树;
    若当前节点无左子树,则访问当前节点的右子树;
    在这里插入图片描述
    上图为例,采用先序遍历的思想遍历该二叉树的过程为:

    1. 访问该二叉树的根节点,找到 1;
    2. 访问节点 1 的左子树,找到节点 2;
    3. 访问节点 2 的左子树,找到节点 4;
    4. 由于访问节点 4 左子树失败,且也没有右子树,因此以节点 4 为根节点的子树遍历完成。但节点 2 还没有遍历其右子树,因此现在开始遍历,即访问节点 5;
    5. 由于节点 5 无左右子树,因此节点 5 遍历完成,并且由此以节点 2 为根节点的子树也遍历完成。现在回到节点 1 ,并开始遍历该节点的右子树,即访问节点 3;
    6. 访问节点 3 左子树,找到节点 6;
    7. 由于节点 6 无左右子树,因此节点 6 遍历完成,回到节点 3 并遍历其右子树,找到节点 7;
    8. 节点 7 无左右子树,因此以节点 3 为根节点的子树遍历完成,同时回归节点 1。由于节点 1 的左右子树全部遍历完成,因此整个二叉树遍历完成;

    二叉树采用先序遍历得到的序列为: 1 2 4 5 3 6 7

    递归实现

    二叉树先序遍历采用的是递归的思想,可以用C语言实现

    #include <stdio.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);
    }
    

    在这里插入图片描述

    非递归实现

    非递归的底层实现依靠的是栈存储结构,因此,二叉树的先序遍历既可以直接采用递归思想实现,也可以使用栈的存储结构模拟递归的思想实现,其 C 语言实现代码为:

    #include <stdio.h>
    #include <string.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);
    }
    

    在这里插入图片描述

    展开全文
  • 二叉树非递归后序遍历算法(C语言) 二叉树后序遍历的规律:左右根 后序非递归遍历中,访问根(子根)结点有两种情况 ①:遍历完左子树,需要遍历右子树,需要从栈中访问最顶上的根(子根)结点从而得到右子树的指针。...

    二叉树非递归后序遍历算法(C语言)

    二叉树后序遍历的规律:左右根
    后序非递归遍历中,访问根(子根)结点有两种情况
    ①:遍历完左子树,需要遍历右子树,需要从栈中访问最顶上的根(子根)结点从而得到右子树的指针。
    ②遍历完右子树,需要访问根(子根)结点。
    基于这个特性,我们需要区分,到底这个根结点,是访问完了左子树还是右子树,所以需要添加一个变量帮助辨认。

    void Postorder(BiTree T){
    	Stack S;  //用于记录根和字根结点
    	InitStack(S);//初始化栈
    	BiNode *p=T;//临时变量记录记录当前访问的结点
    	BiNode *r = NULL; //临时变量,记录上一个访问到的结点,因为从右边访问根结点必定是右子树已经遍历完了,此时上一个访问的结点必定是右子树的根结点
    	while(p||!IsEmpty(S){
    		if (p!=NULL){
    			push(S,p);
    			p = p->lchild;
    		}else{
    			GetTop(S,p);//只读取根结点,不对栈内结点进行操作
    			//没有对右子树进行操作过
    			if(p->rchild!=NULL&&p->rchild!=r){
    				p=p->rchild;
    				push(S,p);
    				p=p->lchild;
    			}else{
    				pop(S,p);
    				visit(p);//对p进行访问,可以进行打印等操作
    				r=p;//记录当前访问的是p结点
    				p==NULL;//把p置空,进入下一次循环,直到栈内无元素,且p为空时遍历完成
    			}//else
    		}//else
    	}//while
    }
    

    代码讲解:https://www.bilibili.com/video/BV1it4y1X7xd/

    展开全文
  • 二叉树先序遍历算法--C语言

    千次阅读 多人点赞 2018-12-13 17:27:34
    第一次在CSDN上写博客,今天开启自己的编程之路。以前总觉得上课嘛,把老师讲的东西学会,考试能过就好了。...今天看了二叉树的先序遍历,便尝试着写了二叉树的先序遍历算法(非递归)。以下代码为已经编译运行...
  • 树的层次遍历与树的的深度遍历,都是用非递归的方法实现的
  • 深度优先遍历算法(Depth-first-search),重点关注的是图的连通性(connectivity),即从图中给定的一点都能访问到哪些点。不仅如此,在遍历这些点的过程中,通过记录访问次序,可以实现其他功能,比如测试该图是否有...
  • 通过键盘输入图的顶点,以及每一条边的两个顶点,从而建立无向图。实现无向图的深度优先遍历算法。要求以用户给定的结点为起始点,显示深度优先遍历次序。
  • /* 二叉树的后序遍历递归算法 */ /* 初始条件: 二叉树T存在 */ /* 操作结果: 后序递归遍历T */ void PostOrderTraverse(BiTree T) { if(T==NULL) return; PostOrderTraverse(T->lchild); /* 先后序遍历左子树 ...
  • /* 二叉树的中序遍历递归算法 */ /* 初始条件: 二叉树T存在 */ /* 操作结果: 中序递归遍历T */ void InOrderTraverse(BiTree T) { if(T==NULL) return; InOrderTraverse(T->lchild); /* 中序遍历左子树 */ ...
  • 0.树结构体定义 typedef struct BTNode { int data; struct BTNode *lchild; struct BTNode *...1.先序遍历 void preorder(BTNode *p) { if(p) { visit(p); preorder(p->lchild); preorder(p->...
  • 二叉树的算法,递归分析很重要!
  • C语言非递归实现二叉树的三种遍历算法:前序、中序、后续目录遍历的基本概念-必读遍历示意图-必看先序遍历中序遍历后序遍历 目录 遍历的基本概念-必读 二叉树由三个元素组成,分别是根节点D,左子树L,右子树R。理论...
  • 二叉树遍历算法总结

    2019-10-04 01:51:16
    二叉树遍历算法总结 本文依据《数据结构与算法》(C语言版)(第三版) 整理。 A. 二叉树的遍历 ...
  • 0. 建立二叉树(方法0) 1. 建立二叉树(方法1) 2. 统计叶子结点个数 3. 求二叉树的树深
  • 1.复制二叉树 思想: 如果是空树,递归结束 否则,申请新节点空间,复制根节点 递归复制左子树 递归复制右子树 int Copy(BiTree T,BiTree &NewT){ if(T==NULL){ NewT=NULL;... Ne...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,462
精华内容 584
关键字:

c语言遍历算法

c语言 订阅