精华内容
下载资源
问答
  • 数据结构 树 层次遍历二叉树 C语言

    千次阅读 多人点赞 2017-08-27 17:18:55
    //层次遍历二叉树并输出结点的算法 #include #include typedef struct NNode { char data; struct NNode *LChild; struct NNode *RChild; } BiTNode,*BiTree; //定义二叉树结点和结点指针 typedef BiTree ...
    //层次遍历二叉树并输出结点的算法
    #include <stdio.h>
    #include <stdlib.h>
    typedef struct NNode
    {
    	char data;
    	struct NNode *LChild;
    	struct NNode *RChild;
    } BiTNode,*BiTree;   //定义二叉树结点和结点指针
    
    typedef BiTree QueueElementType;
    typedef struct Node
    {
        QueueElementType data;
        struct Node  *next;
    } LinkQueueNode;  //定义队列结点
    typedef struct
    {
        LinkQueueNode *front; //队列头结点指针
        LinkQueueNode *rear;  //队列尾结点指针
    } LinkQueue;  //定义队列
    
    int InitQueue(LinkQueue *Q )  //初始化队列
    {
        Q->front=(LinkQueueNode * )malloc(sizeof(LinkQueueNode));
        if(Q->front != NULL)
        {
            Q->rear=Q->front;
            Q->front->next=NULL;
            return 1;
        }
        else return 0;//溢出
    }
    
    int EnterQueue(LinkQueue *Q,QueueElementType x) //元素x入链队列 尾插法
    {
        LinkQueueNode * newnode;
        newnode=(LinkQueueNode *) malloc(sizeof(LinkQueueNode));
        if(newnode != NULL)
        {
    
            newnode->data=x;
            newnode->next=NULL;
            Q->rear->next=newnode;
            Q->rear=newnode;
            return 1;
        }
        else return 0;
    }
    
    int DeleteQueue(LinkQueue *Q,QueueElementType *x ) //链队列出队 从开始的头开始取
    {
        LinkQueueNode *p;
        if(Q->front==Q->rear)
            return 0;
        p=Q->front->next;
        Q->front->next=p->next;
        if(Q->rear==p )
             Q->rear=Q->front;  //如果去掉结点p后,队列为空 不要忘记将队列置空
        *x=p->data;
        free(p);
        return 1;
    }
    
    int IsEmpty(LinkQueue *Q) //队列为空返回1  不为空返回0
    {
        if(Q->front==Q->rear ) return 1;
        else return 0;
    }
    
    
    void CreateBiTree(BiTree *bt)  //用先序遍历创建二叉树
    {
    	char ch;
    	ch=getchar();
    	if(ch=='.') (*bt)=NULL;
    	else
    	{
    		*bt=(BiTree)malloc(sizeof(BiTNode));
    		(*bt)->data=ch;
    		CreateBiTree(&((*bt)->LChild));
    		CreateBiTree(&((*bt)->RChild));
    	}
    }
    
    void PreOrder(BiTree root) //先序遍历二叉树
    {
    	if(root!=NULL)
    	{
    		printf("%c",root->data);
    		PreOrder(root->LChild);
    		PreOrder(root->RChild);
    	}
    
    }
    
    int LayerOrder(BiTree bt)   //层次遍历二叉树 成功遍历返回1 失败返回0
    {
        LinkQueue Q;
        BiTree p;
        InitQueue(&Q);
        if(bt==NULL) return 0;
        EnterQueue(&Q,bt);
        while(!IsEmpty(&Q))
        {
            if(DeleteQueue(&Q,&p));
                printf("%c ",p->data);
            if(p->LChild) EnterQueue(&Q,p->LChild);
            if(p->RChild) EnterQueue(&Q,p->RChild);
        }
        return 1;
    }
    
    int main()
    {
        BiTree bt;
    	printf("用先序遍历创建二叉树 请输入树的内容  形式如AB..CD...的格式\n") ;
    	CreateBiTree(&bt);
    
        PreOrder(bt);
        printf("\n");
        if(LayerOrder(bt)) printf("层次遍历成功\n");
        else printf("层次遍历失败\n");
    
        return 0;
    }
    

    展开全文
  • C语言层次遍历二叉树算法

    千次阅读 2021-05-21 08:51:30
    下面是编程之家 jb51.cc 通过网络收集整理的代码片段。编程之家小编现在分享给大家,也给大家做个参考。#define MaxSize 1000typedef char ElemType;typedef struct node{ElemType ...//创建二叉树void CreateBTNo...

    下面是编程之家 jb51.cc 通过网络收集整理的代码片段。

    编程之家小编现在分享给大家,也给大家做个参考。

    #define MaxSize 1000

    typedef char ElemType;

    typedef struct node

    {

    ElemType data;

    struct node *lchild;

    struct node *rchild;

    } BTNode;

    //创建二叉树

    void CreateBTNode(BTNode *&b,char *str)

    {

    BTNode *St[MaxSize],*p=NULL;

    int top=-1,k,j=0;

    char ch;

    b=NULL;

    ch=str[j];

    while(ch!='\0')

    {

    switch(ch)

    {

    case '(':top++;St[top]=p;k=1;break;

    case ')':top--;break;

    case ',':k=2;break;

    default:p=(BTNode *)malloc(sizeof(BTNode));

    p->data=ch;p->lchild=p->rchild=NULL;

    if(b==NULL) b=p;

    else

    {

    switch(k)

    {

    case 1:St[top]->lchild=p;break;

    case 2:St[top]->rchild=p;break;

    }

    }

    }

    j++;

    ch=str[j];

    }

    }

    //层次遍历算法

    void LevelOrder(BTNode *b)

    {

    BTNode *p;

    BTNode *qu[MaxSize];

    int front,rear;

    front=rear=-1;

    rear++;

    qu[rear]=b;

    while(front != rear)

    {

    front=(front+1)%MaxSize;

    p=qu[front];

    printf("%c ",p->data);

    if(p->lchild!=NULL)

    {

    rear=(rear+1)%MaxSize;

    qu[rear]=p->lchild;

    }

    if(p->rchild!=NULL)

    {

    rear=(rear+1)%MaxSize;

    qu[rear]=p->rchild;

    }

    }

    }

    //主函数

    int main()

    {

    BTNode *b,*h;

    char s[MaxSize] = "A(B(D(,G)),C(E,F))";

    CreateBTNode(b,s);

    printf("层次遍历算法的访问次序为:");

    LevelOrder(b);

    printf("\n请输入二叉树括号表示法字符串:\n");

    return 0;

    }

    以上是编程之家(jb51.cc)为你收集整理的全部代码内容,希望文章能够帮你解决所遇到的程序开发问题。

    如果觉得编程之家网站内容还不错,欢迎将编程之家网站推荐给程序员好友。

    总结

    以上是编程之家为你收集整理的C语言按层次遍历二叉树算法全部内容,希望文章能够帮你解决C语言按层次遍历二叉树算法所遇到的程序开发问题。

    如果觉得编程之家网站内容还不错,欢迎将编程之家网站推荐给程序员好友。

    本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。

    小编个人微信号 jb51ccc

    喜欢与人分享编程技术与工作经验,欢迎加入编程之家官方交流群!

    展开全文
  • C语言层次遍历二叉树

    2011-07-04 22:04:55
    C语言详细介绍二叉树,及其遍历方法。值得学习
  • 二叉树层次遍历C语言实现)

    万次阅读 多人点赞 2019-05-10 21:53:21
    非递归实现二叉树层次遍历: 想了大半个小时终于写出来了,通过自己思考出来的还是有很大成就感。学数据结构就是通过自己思考和参考而学得更深。 思路:层次遍历就是一层一层遍历,这棵二叉树层次遍历序列...

    非递归实现二叉树的层次遍历:

    想了大半个小时终于写出来了,通过自己思考出来的还是有很大成就感。学数据结构就是通过自己思考和参考而学得更深。

     

     

    思路:层次遍历就是一层一层遍历,这棵二叉树的层次遍历序列为5 2 11 3 6 4 8,先上到下,先左到右。实现层次遍历用队列比较方便,因为是先进先出(FIFO)。首先把5入队,然后再输出队首元素,并且把队首元素的左结点和右结点入队(如果有的话),以此类推,输出的序列就是层次遍历啦~~~

     

    /* 完整代码 */
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    #define MaxSize 100
    
    struct tree {
        int data;
        struct tree* left;
        struct tree* right;
    };
    
    typedef struct queue{
        struct tree* numQ[MaxSize];
        int front;
        int rear;
    }Queue;
    
    Queue Q;
    
    void initilize() { //初始化队列
        Q.front = 0;
        Q.rear = 0;
    }
    
    void Push(struct tree* root) { //入队
        Q.numQ[++Q.rear] = root;
    }
    
    struct tree* Pop() { //出队
        return Q.numQ[++Q.front];
    }
    
    int empty() { //判断对列是否为空
        return Q.rear == Q.front;
    }
    
    struct tree* creatTree (struct tree* root) {
        int value;
        scanf("%d", &value);
        if (value == -1)
            return NULL;
        root = (struct tree*)malloc(sizeof(struct tree));
        root->data = value;
        printf("请输入%d的左子树:", root->data);
        root->left = creatTree(root->left);
        printf("请输入%d的右子树:", root->data);
        root->right = creatTree(root->right);
        return root;
    }
    
    void LevelOrderTraversal (struct tree* root) { //二叉树的层次遍历
        struct tree* temp;
        Push(root);
        while (!empty()) {
            temp = Pop();
            printf("%d ", temp->data);  //输出队首结点
            if (temp->left)     //把Pop掉的结点的左子结点加入队列
                Push(temp->left);
            if (temp->right)    把Pop掉的结点的右子结点加入队列
                Push(temp->right);
        }
    }
    
    int main() {
        printf("请输入头节点:");
        struct tree* root = creatTree(root);
        
        initilize();  //初始化队列
        
        LevelOrderTraversal(root);
        putchar('\n');
        
        return 0;
    }

     

    展开全文
  • 这是用c语言编写的二叉树层次遍历程序,使用非递归的方法实现。欢迎使用。
  • 层次遍历二叉树

    2021-05-06 14:52:23
    编写一个按层次遍历二叉树的算法。树的结构以广义表的形式给出。如A(B,)表示一颗有22个节点的树。其中根的data值为A,其左孩子为叶子节点,data值为B,右孩子为空。 输入格式 输入有一行,为广义表形式给出的树形...

    编写一个按层次遍历二叉树的算法。树的结构以广义表的形式给出。如A(B,)表示一颗有 22 个节点的树。其中根的data值为A,其左孩子为叶子节点,data值为B,右孩子为空。

    输入格式

    输入有一行,为广义表形式给出的树形结构。

    输出结构

    输出也是一行,为该二叉树按层次遍历的结果序列,每个元素之间用空格隔开,行末不需要多余的空格。

    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    #include <string.h>
    
    #define ERROR 0
    #define OK 1
    
    typedef struct Node{
    	char data;
    	struct Node *lchild, *rchild;
    }Node;
    
    Node *init_node(char val){
    	Node *p = (Node *)malloc(sizeof(Node));
    	p->data = val;
    	p->lchild = p->rchild = NULL;
    	return p;
    }
    
    
    void clear_node(Node *node){
    	if (node == NULL) return;
    	clear_node(node->lchild);
    	clear_node(node->rchild);
    	free(node);
    }
    
    //广义表输入转二叉树
    //遇左括号将元素p入栈,左括号后元素q为栈顶元素左孩子,逗号后元素为栈顶右孩子
    //右括号出栈
    typedef struct Stack{
    	Node **data;//????
    	int top, size;
    } Stack;
    
    Stack *init_stack(int n){
    	Stack *s = (Stack *)malloc(sizeof(Stack));
    	s->data = (Node **)malloc(sizeof(Node *)* n);//记录节点地址
    	s->size  = n;
    	s->top = -1;
    	return s;
    }
    
    void clear_stack(Stack *s){
    	if (s == NULL) return ;
    	free(s->data);
    	free(s);
    	return;
    }
    
    Node *top(Stack *s){
    	return s->data[s->top];
    }
    
    int empty(Stack *s){
    	return s->top == -1;
    }
    
    int push(Stack *s, Node *val){
    	if (s == NULL) return 0;
    	if (s->top == s->size - 1) return 0;//栈满
    	//expand
    	s->data[++(s->top)] = val;
    	return 1;
    }
    
    int pop(Stack *s){
    	if (s == NULL) return 0;
    	if (empty(s)) return 0;
    	s->top--;
    	return 1;
    }
    
    //广义表建树
    Node *table_build(const char *str){
    	Stack *s = init_stack(strlen(str));
    	Node *temp = NULL, *p = NULL;//p为根节点
    	int flag = 0;
    	while(str[0]){
    		switch (str[0]){
    		case '(':
    			 push(s, temp);
    			 flag = 0;
    			 break;
    		case ',':
    			flag = 1;
    			break;
    		case ')':
    			p = top(s);//??
    			pop(s);
    			break;
    		default:
    			//遇字母,设为栈顶的孩子
    			temp = init_node(str[0]);
    			if(!empty(s) && flag == 0){
    				top(s)->lchild = temp;
    			}
    			else if(!empty(s) && flag == 1){
    				top(s)->rchild = temp;
    			}
    			break;
    		}
    		str++;
    	}
    	clear_stack(s);
    	if (temp && !p) p = temp;//只有一个根,此时p为空
    	return p;
    }
    
    typedef struct Queue{
        Node *data;
        int head,tail,length;
    }Queue;
    
    void Queue_init(Queue *q, int length) {
        q->data=(Node *)malloc(sizeof(Node)*length);
        q->head=0;
        q->tail=-1;
        q->length=length;
    }
    
    int Queue_push(Queue *q, Node *element) {
        if(q->tail + 1 >= q->length) {
            return ERROR;
        }
        q->tail++;
        q->data[q->tail] = *element;
        return OK;
    }
    Node *Queue_front(Queue *q) {
        return q->data+q->head;
    }
    void Queue_pop(Queue *q) {
        q->head++;
    }
    
    int Queue_empty(Queue *q) {
        return q->head>q->tail;
    }
    
    void Queue_clear(Queue *q) {
        free(q->data);
        free(q);
    }
    
    
    int main(){
    
        char str[100];
        gets(str);
        int temp1=(int)strlen(str);
        Queue *queue=(Queue *)malloc(sizeof(Queue));
        Queue_init(queue,temp1);
    
        Node *root=table_build(str);
        if(temp1!=0)
        {
            Queue_push(queue,root);
            while(!Queue_empty(queue))
            {
                Node *temp=Queue_front(queue);
                printf("%c ",temp->data);
                Queue_pop(queue);
                if(temp->lchild)
                {
                    Queue_push(queue,temp->lchild);
                }
                if(temp->rchild)
                {
                    Queue_push(queue,temp->rchild);
                }
            }
        }
        else
        {
            printf("");
        }
    	return 0;
    }
    

     

    展开全文
  • 二叉树层次遍历 二叉树结构 typedef struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; }TreeNode; 这里实现将二叉树的每层放入一个二维数组的一行中。 #define maxSize ...
  • 老师布置的作业呐,自己做完调试运行了先序输入是EACBDGF,中序...先序遍历二叉树:E A C B D G F 中序遍历二叉树:A B C D E F G 后序遍历二叉树:B D C A F G E ****************捞分下题目嗷=A=************
  • #define MaxSize 1000typedef char ElemType;typedef struct node{ElemType data;struct node *lchild;struct node *rchild;...//创建二叉树void CreateBTNode(BTNode *&b,char *str){BTNode *St[MaxSize],*p=N...
  • 数据结构习题 希望能够帮助你学好树的遍历
  • 遍历二叉树C实现代码

    2018-02-24 20:17:25
    遍历二叉树的几种算法实现,主要如下: 1.前序遍历二叉树; 2.中序遍历二叉树; 3.后序遍历二叉树; 4.层次遍历二叉树
  • 数据结构 二叉树层次遍历 C语言

    千次阅读 多人点赞 2018-12-19 16:21:08
    C语言 数据结构 二叉树层次遍历 原创作者:小林 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define max 100 typedef int ElemType; typedef struct BiTNode{ ElemType data; struct ...
  • 非递归版的层次遍历,简单易懂!!!
  • 二叉树层次遍历--C语言

    万次阅读 多人点赞 2018-12-21 17:54:22
    今天写一下二叉树层次遍历层次遍历用到的数据结构是队列。   层次遍历算法中增加了三个int型数据,其中levelcount用于记录现在处理的是树的第几层;curlevel用于记录当前层还有几个节点没有被访问过;next...
  • 聽聽//取得层次遍历长度 聽聽聽聽int聽pos=0; 聽聽聽聽if(len==0) 聽聽聽聽聽聽聽聽return聽; 聽聽聽聽char聽*p=strchr(inorder,level[0]); 聽聽聽聽if(p==NULL)聽聽聽聽聽//如果为空则抛弃第一个,跳到下一个; 聽...
  • LeetCode-102-二叉树层次遍历-C语言

    千次阅读 2019-05-16 09:41:47
    /** * * 算法思想: * 递归的思想,传递变量...右子树 的遍历顺序,达到从左到右的添加顺序。 * 或者 本节点 -> 左子树 ->右子树 顺序,左边在右边前面即可。 * */ #define LEV 1024 #define LEN 10...
  • 问题描述:二叉树采用链接存储结构,试设计一个按层次顺序(同一层次自左至右)遍历二叉树的...因为队列的特点是先进先出,从而达到层次遍历二叉树的目的。完整代码如下:/* 二叉树 - 层次遍历 */ #include "...
  • 数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示: 二叉树先序、中序、后序三种遍历 先序遍历:3 2 2 3 8 6 5 4 中序遍历:2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 ...
  • 层次遍历二叉树,简单易懂,操作容易,结构清晰,运用c语言编程
  • //二叉树节点 struct BinaryNode { char ch; //显示字母 struct BinaryNode* lChild; //左孩子 struct BinaryNode* rChild; //右孩子 }; //递归函数:先序遍历 void recursion(struct BinaryNode* root) { if...
  • 二叉树层次遍历 提示:以下是本篇文章正文内容,下面案例可供参考 一、代码实现 代码如下(示例): #include <stdio.h> #include <stdlib.h> //二叉树 typedef struct BiTNode { BiTNode* ...
  • /*利用先序遍历的方式创建二叉树*/ void traverse_tree(PTREE); /*实现树的层序遍历*/ int main ( void ) { PTREE pT = NULL ; creat_tree( & pT); traverse_tree(pT); return 0 ; } void init_...
  • 二叉树层次遍历 给定一个二叉树,返回其按层次遍历的节点值。 (即逐层地,从左到右访问所有节点)。 例如:给定二叉树:[3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 ...
  • 二叉树层序遍历C语言

    千次阅读 多人点赞 2021-04-25 22:14:28
    二叉树的层序遍历即从上到下,在每一层从左到右依次打印数据。 如下: 层序遍历结果: ABCDEFG 基本思路即将根节点入队后,之后每次都将队首元素出队,打印队首元素数据,并将队首元素左右子树入队,一直重复上述...
  • 实现二叉树层次遍历实现二叉树层次遍历实现二叉树层次遍历实现二叉树层次遍历
  • #include #include/*** 二叉树二叉链表之非递归遍历:层序遍历* 算法思想:借助一个队列;根树进队;队不为空时循环“从队列中出一个树p,访问该树根结点;* 若它有左子树,左子树进队;若它有右子树,右子树进队。...
  • BFS层次遍历二叉树
  • 前边介绍了二叉树的先序、中序和后序的遍历算法,运用了栈的数据结构,主要思想就是按照先...而后每次队列中一个结点出队,都将其左孩子和右孩子入队,直到树中所有结点都出队,出队结点的先后顺序就是层次遍历的最...
  • 二叉树层次遍历--c语言实现

    千次阅读 2018-07-19 17:36:44
    #include &lt;stdio.h&...利用顺序存储的队列实现对二叉树层次遍历 **/ typedef struct TreeNode *BinTree; typedef BinTree ElementType ; struct TreeNode{ int data; BinTree left; BinTre...

空空如也

空空如也

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

层次遍历二叉树c语言

c语言 订阅
友情链接: 07867356.zip