精华内容
下载资源
问答
  • 中序遍历二叉树[C语言] 给定一个二叉树,返回它的中序 遍历。 示例: 输入: [1,null,2,3] 1 \ 2 / 3 输出: [1,3,2] 进阶: 递归算法很简单,你可以通过迭代算法完成吗? /** * Definition for a binary tree ...

    LeetCode探索:  中序遍历二叉树[C语言]

    给定一个二叉树,返回它的中序 遍历。

    示例:

    输入: [1,null,2,3]
       1
        \
         2
        /
       3
    
    输出: [1,3,2]
    

    进阶: 递归算法很简单,你可以通过迭代算法完成吗?

    /**
     * Definition for a binary tree node.
     * struct TreeNode {
     *     int val;
     *     struct TreeNode *left;
     *     struct TreeNode *right;
     * };
     */
    
    int recurCount(struct TreeNode* root) {
        if(root==NULL) return 0;
        
        return recurCount(root->left) + recurCount(root->right) + 1;    
    }
    
    void inorder(struct TreeNode* root, int* res, int* returnSize){
        
        if(root==NULL) return;
        
        inorder(root->left, res, returnSize);
        
        res[*returnSize] = root->val;
        (*returnSize)++;
        inorder(root->right, res, returnSize);
        
        return;
    }
    
    /**
     * Note: The returned array must be malloced, assume caller calls free().
     */
    int* inorderTraversal(struct TreeNode* root, int* returnSize){
        
        *returnSize = 0;
        
        if(root==NULL) return NULL;
        
        int bufSize = sizeof(int)*recurCount(root);
        
        int* res = (int*)malloc(bufSize);
        memset(res, 0, bufSize);
        
        inorder(root, res, returnSize);
        
        return res; 
        
    }
    
    
    展开全文
  • 中序遍历递归算法C语言版)

    千次阅读 2015-11-30 21:39:34
    #include #include ...//前序遍历:ABD#E##FG###C## typedef struct tree/*二叉树*/ { char data;  struct tree *lchild,*rchild; }bintree; typedef bintree *tree; tree createTree()/*前序遍历建树*
    #include <stdio.h>
    #include <stdlib.h>
    #define M 100
    //前序遍历:ABD#E##FG###C##
    typedef struct tree/*二叉树*/
    {   char data;
        struct tree *lchild,*rchild;
    }bintree;
    typedef bintree *tree;
    tree createTree()/*前序遍历建树*/
    {
        tree t;
        char c=getchar();
        if(c=='#') return NULL;
        else
        {   t=(tree)malloc(sizeof(bintree));
            t->data=c;
            t->lchild=createTree();
            t->rchild=createTree();
        }
        return t;
    }
    /*非递归中序遍历:思路:边遍历边输出,先输出左子树的最左边一个节点,并放入栈,*/
    void intree(tree t)
    {   tree stack[M];int top=0;/*定义、初始化栈*/
        while(top||t)
        {   if(t!=NULL)
            {   stack[top++]=t;
                t=t->lchild;
            }else if(top!=0)
            {   t=stack[--top];
                printf("%c",t->data);
                t=t->rchild;
            }
        }
    }
    /*中序遍历求首点*/
    tree findFir(tree t)
    {
        if(t==NULL) return t;
        tree p=t;
        while(p->lchild!=NULL) p=p->lchild;
        return p;
    }
    /*中序遍历求尾点*/
    tree findEnd(tree t)
    {
        if(t==NULL) return t;
        tree q=t;
        while(q->rchild!=NULL) q=q->rchild;
        return q;
    }
    int main()
    {   tree t,t1;
        t=createTree();
        printf("\n中序遍历:\n");
        intree(t);
        printf("\n\n");
        t1=findFir(t);
        printf("中序遍历的首点:%c\n\n",t1->data);
        t=findEnd(t);
        printf("中序遍历的尾点:%c",t->data);
        return 0;
    }
    展开全文
  • void inOrderNo(BiTNode * T)//非递归进行中序遍历,借助于栈 {  BiTNode * temp=T;  Stack *s;  InitStack(s);  while(temp!=NULL||!isEmptyStack(s))  {  if(temp!=NULL)  {  if(push(s,...

    #include "stdio.h"
    #include "string.h"
    #include "malloc.h"
    #define NULL 0
    #define MAXSIZE 30
    typedef struct BiTNode      //定义二叉树数据结构
    {
        char data;
        struct BiTNode *lchild,*rchild;
    } BiTNode;

    typedef struct Queue      //定义顺序结构队列数据结构(层序遍历需要借助队列)
    {
        struct BiTNode * data[MAXSIZE];
        int front,rear;
    } Queue;

    typedef struct Stack      //定义顺序结构栈数据结构(非递归遍历二叉树需要借助栈)
    {
        struct BiTNode * data[MAXSIZE];
        int top;
    } Stack;

    bool isEmpty(Queue *);//判队列是否空
    bool InitStack(Stack *& s)//初始化栈
    {
        if(!(s=(Stack *)malloc(sizeof(Stack))))
        {
            return false;
        }
        else
        {
            s->top=-1;
        }
    }
    bool isFullStack(Stack *s)//判栈是否满
    {
        if((s->top)==(MAXSIZE-1))
        {
            return true;
        }
        else
            return false;
    }
    bool isEmptyStack(Stack *s)//判栈是否空
    {
        if((s->top)==-1)
        {
            return true;
        }
        else
            return false;
    }
    bool push(Stack *s,BiTNode *&bitnode)//入栈
    {
        if(!isFullStack(s))
        {
            s->top++;
            s->data[s->top]=bitnode;
            return true;
        }
        else
            return false;
    }
    bool pop(Stack *s,BiTNode *& bitnode)//入栈
    {
        if(s->top==-1)
        {
            return false;
        }
        else
        {
            bitnode=s->data[s->top];
            (s->top)--;
            return true;
        }
    }
    bool InitQueue(Queue *& q)//初始化队列
    {
        if(!(q=(Queue *)malloc(sizeof(Queue))))
        {
            return false;
        }
        else
        {
            q->front=0;
            q->rear=0;
            return true;
        }
    }
    void enQueue(Queue *q,BiTNode * data)//入队
    {
        if(q->front==(q->rear+1))
        {
            printf("Queue is full\n");
        }
        else
        {
            q->data[q->rear]=data;
            q->rear=((q->rear)+1)%MAXSIZE;
        }
    }
    void deQueue(Queue *q,BiTNode *& data)//出队
    {
        if(!isEmpty(q))
        {
            data=q->data[q->front];
            q->front=(q->front+1)%MAXSIZE;
        }
    }
    bool isEmpty(Queue *q)//判队空
    {
        if(q->front==q->rear)
        {
            return true;
        }
        else
            return false;
    }

    void preCreate(BiTNode *& T)   //先序遍历建立二叉树
    {
        char ch;
        ch=getchar();
        if(ch=='#')
            T=NULL;
        else
        {
            if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))
                printf("Error!");
            T->data=ch;
            preCreate(T->lchild);
            preCreate(T->rchild);
        }
    }

    void inOrderNo(BiTNode * T)//非递归进行中序遍历,借助于栈

    {
        BiTNode * temp=T;
        Stack *s;
        InitStack(s);
        while(temp!=NULL||!isEmptyStack(s))
        {
            if(temp!=NULL)
            {
                if(push(s,temp))
                    temp=temp->lchild;
                else
                    printf("压栈失败\n");
            }
            else
            {
                if(pop(s,temp))
                {
                    printf("%c",temp->data);
                    temp=temp->rchild;
                }
                else
                    printf("弹栈失败\n");
            }
        }


    }
    void levelOrder(BiTNode * T)//层序遍历,借助于队列
    {
        BiTNode * node=T;
        Queue * queue=NULL;
        InitQueue(queue);
        enQueue(queue,T);
        while(!isEmpty(queue))
        {
            deQueue(queue,T);
            printf("%c",T->data);
            if(T->lchild!=NULL)
                enQueue(queue,T->lchild);
            if(T->rchild!=NULL)
                enQueue(queue,T->rchild);


        }

    }

    int main()
    {
        BiTNode * bitree=NULL;
        preCreate(bitree);//先序遍历建立二叉树

        printf("\n中序遍历:(非递归)");

        inOrderNo(bitree);

        printf("\n层序遍历:");
        levelOrder(bitree);


        return 0;
    }

    展开全文
  • 事实上,一个中序遍历算法中入栈的过程中,如果你把每个入栈的结点保存起来,你会发现这些结点就是先序遍历的结果,同样,出栈就是中序遍历,如下图 核心算法 先序遍历的第一个结点一定是根结点,也是后序遍历...

    事实上,一个中序遍历的算法中入栈的过程中,如果你把每个入栈的结点保存起来,你会发现这些结点就是先序遍历的结果,同样,出栈就是中序遍历,如下图
    在这里插入图片描述

    • 核心算法
      在这里插入图片描述
      先序遍历的第一个结点一定是根结点,也是后序遍历的最后一个结点,找到它在中序中的位置 i ,那么 i 的左边就是左子树,右边是右子树,递归的求解左右两边
    • 代码
    #include <stdio.h>
    #include <stdlib.h>
    #define SIZE 6
    //
    int pre[6]={1,2,3,4,5,6};//先序遍历数组 
    int in[6]={3,2,4,1,6,5};//中序遍历 数组 
    int post[6]={0};//后序遍历数组 
    void CreatePost(int first,int mid,int last,int n)
    {
    	printf("------%d-------\n",first);
    	if(n==0){
    		return;	
    	}
    	if(n==1)
    	{
    		post[last]=pre[first];
    		return;
    	}
    	int root=pre[first];
    	post[last+n-1]=root;
    	int i;
    	for(i=0;i<6;i++)
    	{
    		if(root==in[i+mid])
    			break;
    	}
    	int L=i;
    	int R=n-L-1;
    	CreatePost(first+1,mid,last,L);
    	CreatePost(first+L+1,mid+L+1,last+L,R);
    	
    }
    int main(int argc, char** argv) {
    	CreatePost(0,0,0,6);
    	
    	for(int i=0;i<6;i++)
    		printf("%d ",post[i]);
    	return 0;
    }
    
    
    展开全文
  • 二叉树中序遍历的实现思想是: 访问当前节点的左子树; 访问根节点; 访问当前节点的右子树; 图 1 二叉树 以图 1 为例,采用中序遍历的思想遍历该二叉树的过程为: 访问该二叉树的根节点,找到 1; 遍历节点 1...
  • 过程初始指针指向根节点。1. 若此节点不为空,此节点入栈。2. 指针指向此节点的左孩子。3. 若此节点为空,指针指向...图示算法实现C语言实现核心代码void InOrderTraverse(BiTree T) { BiTree p = T;//二叉树遍历
  • 二叉树中序遍历(非递归)算法实现--C语言

    千次阅读 多人点赞 2018-12-14 10:50:25
    中序遍历的非递归算法有两种,但是个人觉得只要掌握一种就可以了,只要自己的逻辑清晰,会哪一种又有什么关系呢~ 首先给出今天的二叉树的示例图: 代码如下: // InOrderBiTreeTraverse.cpp : Defines the entry ...
  • 题目描述: 给定一个二叉树,返回...接着就是考虑结点应该做的事情利用递归实现中序遍历。 代码: void inorder(struct TreeNode* root,int* returnSize,int *a)//中序遍历二叉树 { if(!root) return; inorder(root
  • /* 二叉树的中序遍历递归算法 */ /* 初始条件: 二叉树T存在 */ /* 操作结果: 中序递归遍历T */ void InOrderTraverse(BiTree T) { if(T==NULL) return; InOrderTraverse(T->lchild); /* 中序遍历左子树 */ ...
  • 广义表创建二叉树 关于用广义表的形式表示二叉树的形式如下 ①广义表中的一个字母代表一个结点的数据信息。...下面先用自然语言描述算法如下。 依次从广义表中取得-个元素,并对取得的元素做如下相应的处理...
  • 给定一个二叉树,返回它的中序遍历。 示例: 输入: [1,null,2,3] 1 \ 2 / 3 输出: [1,3,2] 进阶:递归算法很简单,你可以通过迭代算法完成吗? 方法一:采用递归算法,按照左根右的顺序遍历二叉树 /** * ...
  • 94. 二叉树的中序遍历1. 题目描述2. 说一下得到访问节点顺序的思路3.代码如下 1. 题目描述 给定一个二叉树,返回它的中序 遍历。 示例: 输入: [1,null,2,3] 1 2 / 3 输出: [1,3,2] 进阶: 递归算法很简单...
  • p)/* 获取栈顶元素,并遍历其左子树 */ Push(&stack, p->lchild); Pop(&stack, p);/* 空指针出栈 */ if(!StackEmpty(&stack)){ Pop(&stack, p); Visit(p->data); ...
  • 题目描述: 给定一个二叉树,返回它的中序 遍历。...进阶: 递归算法很简单,你可以通过迭代算法完成吗? 来源:力扣(LeetCode) 链接:https://leetcode-cn.com/problems/binary-tree-inorder-traversal 著作权归...
  • //递归创建右子树 } } void InOrderTraverse(BiTree T)//中序遍历二叉树T的非递归算法 { LinkStack S; InitStack(S);//创建一个栈,并初始化 BiTree p = T; BiTree q = (BiTNode*)malloc(sizeof(BiTNode));//...
  • 二叉树的非递归遍历(前序中序后序非递归C语言

    万次阅读 多人点赞 2018-10-24 14:11:00
    经过两天的搜索,看到网上很多种解法,很多解法都是用C++来写的算法,一直找不到用C语言写的算法,所以就总结了一下,用C写出了一个遍历二叉树的三种非递归算法。 前序遍历 前序遍历按照“根结点-左孩子-右孩子”...
  • 然后分别用中序遍历的两种非递归算法遍历这棵二叉树。最后释放二叉树的每个结点的存储空间。提示:释放二叉树结点时要先释放左子树,然后释放右子树,最后释放根结点。这与后序遍历的顺序一致,所以应付当在后序遍历...
  • 94. 二叉树的前、中序遍历(非递归实现)1. 题目描述2.总结3.代码如下 1. 题目描述 给定一个二叉树,返回它的中序 遍历。 示例: 输入: [1,null,2,3] 1 2 / 3 输出: [1,3,2] 进阶: 递归算法很简单,你可以通过迭代...
  • 1. 前序遍历和中序遍历递归算法思路 前序和中序非递归遍历的C代码 2. 后序遍历非递归算法思路 后序非递归遍历的C代码 1. 前序遍历和中序遍历递归算法思路 遍历过程:(如图所示) 图1 前...
  • 树的遍历是考验程序员的基本本领,采用非递归遍历效率会更高!
  • 实现教材中算法6.4描述的二叉树创建算法,在此基础上实现二叉树的先序、后序递归遍历算法、两种非递归中序遍历、层序遍历、求二叉树的深度。注意:在非递归算法中用到栈和队列时,不要调用系统的栈和队列,需要自己...
  • 二叉树的中序遍历(binary tree inorder traversal)C语言1.description2.solution2.1 递归2.2 迭代 1.description https://leetcode-cn.com/problems/binary-tree-inorder-traversal/ 给定一个二叉树,返回它的中序...
  • 文章目录所有题目源代码:[Git地址](https://github.com/ch98road/leetcode)题目方案:递归,...进阶: 递归算法很简单,你可以通过迭代算法完成吗? 方案:递归,迭代实现见Java版 懒 /** * Definition for a bi
  • 文章目录一、算法思路二、函数实现(c语言)1.树节点定义2.函数声明3.函数实现 一、算法思路 前提条件:所构建二叉树中的每一项均不相等,给出所有节点的个数 1、后序遍历中的最后一项为当前子树的根节点 2、通过...
  • 问题描述:已知二叉树t,分别采用顺序存储结构、二叉链表存储结构实现求二叉树的深度,并对二叉树分别进行中序遍历。 要求: 1、二叉树分别采用顺序或二叉链表存储。 2、 树中的数据类型约定为整型 3、 按先序...
  • 1. 前序遍历和中序遍历递归算法思路 前序和中序非递归遍历的C代码 2. 后序遍历非递归算法思路 后序非递归遍历的C代码 1. 前序遍历和中序遍历递归算法思路 遍历过程:(如图所示) 图1 前序遍历和中序...
  • 中序遍历:1,沿着根结点,向左依次入栈,直到左孩子为空 2,栈顶元素出栈并访问,若有孩子为空,继续执行。 3,若右孩子不为空,则将有孩子转执行1。 先序遍历:与中序遍历是一样的,只是把访问操作放到入栈之前 ...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 123
精华内容 49
关键字:

中序遍历递归算法c语言

c语言 订阅