精华内容
下载资源
问答
  • c语言遍历二叉树

    2018-11-01 10:02:09
    遍历(Traversal)是指沿着某条搜索路线,依次对中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问 题。 遍历是二叉上最重要的运算之一,是二叉上进行其它运算之基础。
  • #include "stdio.h"#include "windows.h"#include <iostream>using namespace std;...//////////////////////////////////////////////////////////////////////////// 目录链表结点定义typedef...

    #include "stdio.h"
    #include "windows.h"
    #include <iostream>
    using namespace std;
    unsigned long sum = 0;
    //
    // 目录树链表结点定义
    typedef struct _tFileTreeItem
    {
        struct _tFileTreeItem* pPrevItem;   // 前一个单元
        struct _tFileTreeItem* pNextItem;   // 后一个单元
        struct _tFileTreeItem* pParentItem; // 父单元
        struct _tFileTreeItem* pChildItem;  // 子单元
        char FilePath[MAX_PATH];
        char FileName[MAX_PATH];
        unsigned long dwHashIndex;          // 索引序号
        int level;                          // 树的深度
        int nNameLength;                    // 名称长度
        char *strItemName;                  // 单元名称,不包含路径.(可变长度)
    }FileTreeItem, *PFileTreeItem;

    //
    //查找文件或文件夹,保存到树中
    void FindDir( FileTreeItem* TreeNode )
    {
        WIN32_FIND_DATA fd;
        HANDLE hSearch;
        char filePathName[MAX_PATH];

        FileTreeItem* temp;
        FileTreeItem* tempnode;

        ZeroMemory( &fd, sizeof(WIN32_FIND_DATA) );
        ZeroMemory( filePathName, MAX_PATH );

        strcpy_s( filePathName, MAX_PATH, TreeNode->FilePath );

        if( filePathName[strlen(filePathName) - 1] != '\\' )
        {
            strcat_s( filePathName, MAX_PATH, "\\" );
            strcat_s( TreeNode->FilePath, MAX_PATH, "\\" );
        }
        strcat_s( filePathName, MAX_PATH, "*" );

        char* wcFilePathName = filePathName;
        hSearch = FindFirstFile( wcFilePathName, &fd );
        if ( hSearch != INVALID_HANDLE_VALUE )
        {
            if( (fd.dwFileAttributes == FILE_ATTRIBUTE_DIRECTORY)
                && lstrcmp(fd.cFileName, ".") && lstrcmp(fd.cFileName,"..") )      
            {
                tempnode= new FileTreeItem;
                char *tempBuffer = fd.cFileName ;
                //保存临时节点的信息
                tempnode->level = TreeNode->level + 1;
                strcpy_s( tempnode->FilePath, MAX_PATH, TreeNode->FilePath );
                strcat_s( tempnode->FilePath, MAX_PATH, tempBuffer );
                strcpy_s( tempnode->FileName, MAX_PATH, tempBuffer );

                tempnode->pPrevItem = NULL;
                tempnode->pNextItem = NULL;
                tempnode->pParentItem = NULL;
                tempnode->pChildItem = NULL;

                if( NULL == TreeNode->pChildItem )
                {// 根结点没有孩子结点,这个就是第一个孩子结点了
                    TreeNode->pChildItem = tempnode;
                    tempnode->pPrevItem = tempnode->pNextItem = tempnode;// 双向循环链表指针指向自身
                }
                else
                {// 将此结点插入到父结点指向的双向循环链表中去
                    temp = TreeNode->pChildItem;// 指向父结点的第一个孩子用来插入结点
                    // 将此结点插入到第一个结点之前,即本级目录树的尾部【小技巧】
                    tempnode->pNextItem = temp;
                    tempnode->pPrevItem = temp->pPrevItem;
                    temp->pPrevItem->pNextItem = tempnode;
                    temp->pPrevItem = tempnode;
                }
                tempnode->pParentItem = TreeNode;// 指向父结点
                FindDir(tempnode);
            }
            while( FindNextFile(hSearch, &fd) )
            {
                if ( !lstrcmp(fd.cFileName, ".") || !lstrcmp(fd.cFileName,"..") )
                {
                    continue;
                }
                else if ( (fd.dwFileAttributes == FILE_ATTRIBUTE_DIRECTORY) || (fd.dwFileAttributes ==48)
                    && lstrcmp(fd.cFileName, ".") && lstrcmp(fd.cFileName,"..") )
                { 
                    tempnode= new FileTreeItem;
                    char *tempBuffer = fd.cFileName ;
                    //保存临时节点的信息
                    tempnode->level = TreeNode->level + 1;
                    strcpy_s( tempnode->FilePath, MAX_PATH, TreeNode->FilePath );
                    strcat_s( tempnode->FilePath, MAX_PATH, tempBuffer );
                    strcpy_s( tempnode->FileName, MAX_PATH, tempBuffer );

                    tempnode->pPrevItem = NULL;
                    tempnode->pNextItem = NULL;
                    tempnode->pParentItem = NULL;
                    tempnode->pChildItem = NULL;

                    if( NULL == TreeNode->pChildItem )
                    {// 根结点没有孩子结点,这个就是第一个孩子结点了
                        TreeNode->pChildItem = tempnode;
                        tempnode->pPrevItem = tempnode->pNextItem = tempnode;// 双向循环链表指针指向自身
                    }
                    else
                    {// 将此结点插入到父结点指向的双向循环链表中去
                        temp = TreeNode->pChildItem;// 指向父结点的第一个孩子用来插入结点
                        // 将此结点插入到第一个结点之前,即本级目录树的尾部【小技巧】
                        tempnode->pNextItem = temp;
                        tempnode->pPrevItem = temp->pPrevItem;
                        temp->pPrevItem->pNextItem = tempnode;
                        temp->pPrevItem = tempnode;
                    }
                    tempnode->pParentItem = TreeNode;// 指向父结点
                    FindDir(tempnode);
                }
                else if ( lstrcmp( fd.cFileName, ".." ) && fd.dwFileAttributes != 48 )
                {// 此时存放的是文件
                    tempnode= new FileTreeItem;
                    char *tempBuffer = fd.cFileName;
                    //保存临时节点的信息
                    tempnode->level = TreeNode->level + 1;
                    strcpy_s( tempnode->FilePath, MAX_PATH, TreeNode->FilePath );
                    strcat_s( tempnode->FilePath, MAX_PATH, tempBuffer );
                    strcpy_s( tempnode->FileName, MAX_PATH, tempBuffer );

                    tempnode->pPrevItem = NULL;
                    tempnode->pNextItem = NULL;
                    tempnode->pParentItem = NULL;
                    tempnode->pChildItem = NULL;

                    if( NULL == TreeNode->pChildItem )
                    {// 根结点没有孩子结点,这个就是第一个孩子结点了
                        TreeNode->pChildItem = tempnode;
                        tempnode->pPrevItem = tempnode->pNextItem = tempnode;// 双向循环链表指针指向自身
                    }
                    else
                    {// 将此结点插入到父结点指向的双向循环链表中去
                        temp = TreeNode->pChildItem;// 指向父结点的第一个孩子用来插入结点
                        // 将此结点插入到第一个结点之前,即本级目录树的尾部【小技巧】
                        tempnode->pNextItem = temp;
                        tempnode->pPrevItem = temp->pPrevItem;
                        temp->pPrevItem->pNextItem = tempnode;
                        temp->pPrevItem = tempnode;
                    }
                    tempnode->pParentItem = TreeNode;// 指向父结点
                }
            }
            FindClose(hSearch);
        }
    }

    //
    //深度遍历
    void SearchTree(FileTreeItem* treeRoot)
    {
        printf(treeRoot->FilePath);
        printf("\tlevel:%d.",treeRoot->level );
        printf("\n");
        sum++;

        if( (treeRoot->pChildItem != NULL) )
        {
            SearchTree( treeRoot->pChildItem );
        }

        if ( treeRoot->pNextItem != treeRoot->pParentItem->pChildItem )
        {
            SearchTree( treeRoot->pNextItem );
        }
    }

    void main()
    {
        char* input_path= "e:\\";
        //初始化树根节点
        DWORD dw_time_start  = GetTickCount();
        FileTreeItem *DirTreeRoot= new FileTreeItem;
        DirTreeRoot->level = 0; 
        strcpy_s( DirTreeRoot->FileName, strlen(DirTreeRoot->FileName), input_path );
        strcpy_s(DirTreeRoot->FilePath, strlen(DirTreeRoot->FilePath), input_path);
        DirTreeRoot->pPrevItem = NULL;
        DirTreeRoot->pNextItem = NULL;
        DirTreeRoot->pParentItem = DirTreeRoot;
        DirTreeRoot->pChildItem = NULL;     
        FindDir( DirTreeRoot );

        DWORD dw_time_end  = GetTickCount();
        DWORD dw_time_delta  = dw_time_end - dw_time_start;
       
        SearchTree(DirTreeRoot->pChildItem);
        cout << "目录树建立时间:" << dw_time_delta / 1000.0 << "秒." << endl;
        cout << "文件和目录的总数为:" << sum << endl;
        system( "pause" );
    }

    转载于:https://www.cnblogs.com/zzili/archive/2012/12/06/6663287.html

    展开全文
  • 层次遍历树 rar c语言版本... 不会的来看看
  • #include #include #include struct BTNode { int data; struct BTNode* pLchild;//p是指针 L是左 child是孩子 struct BTNode* pRchild;//Rchild右孩子 };... } 的结构 在CreateBTree(void)中定义 运行结果
    #include<stdio.h>
    #include<malloc.h>
    #include<stdlib.h>
    struct BTNode
    {
    	int data;
    	struct BTNode* pLchild;//p是指针 L是左 child是孩子
    	struct BTNode* pRchild;//Rchild右孩子
    };
    struct BTNode * CreateBTree(void)
    {
    	struct BTNode* pA = (struct BTNode*)malloc(sizeof(struct BTNode));
    	struct BTNode* pB = (struct BTNode*)malloc(sizeof(struct BTNode));
    	struct BTNode* pC = (struct BTNode*)malloc(sizeof(struct BTNode));
    	struct BTNode* pD = (struct BTNode*)malloc(sizeof(struct BTNode));
    	struct BTNode* pE = (struct BTNode*)malloc(sizeof(struct BTNode));
    	
    	pA->data = 'A';
    	pB->data = 'B';
    	pC->data = 'C';
    	pD->data = 'D';
    	pE->data = 'E';
    
    	pA->pLchild = pB;
    	pA->pRchild = pC;
    	pB->pLchild = pB->pRchild = NULL;
    	pC->pLchild = pD;
    	pC->pRchild = NULL;
    	pD->pLchild = NULL;
    	pD->pRchild = pE;
    	pE->pLchild = pE->pRchild = NULL;
    	return pA;
    };
    void PreTraverseBTree(BTNode* pT) {
    	//先访问根  再访问左子树 再访问右子树 递归
    	if (NULL!=pT)
    	{
    		printf("%c\n", pT->data);
    		if (NULL != pT->pLchild)
    		{
    			PreTraverseBTree(pT->pLchild); //代表左子树
    		}
    		if (NULL!=pT->pRchild)
    		{
    			PreTraverseBTree(pT->pRchild);  //代表右子树
    		}
    	}	
    }
    void InTraverseBTree(BTNode* pT) {
    	if (NULL != pT)
    	{
    		if (NULL != pT->pLchild)
    		{
    			InTraverseBTree(pT->pLchild); //代表左子树
    		}
    		printf("%c\n", pT->data);
    		if (NULL != pT->pRchild)
    		{
    			InTraverseBTree(pT->pRchild);  //代表右子树
    		}
    	}
    }
    void PostTraverseBTree(BTNode* pT) {
    	if (NULL != pT)
    	{
    		if (NULL != pT->pLchild)
    		{
    			PostTraverseBTree(pT->pLchild); //代表左子树
    		}
    		
    		if (NULL != pT->pRchild)
    		{
    			PostTraverseBTree(pT->pRchild);  //代表右子树
    		}
    		printf("%c\n", pT->data);
    	}
    }
    int main() {
    	struct BTNode* pT = CreateBTree();//函数内部动态创建二叉树 返回根节点地址(省空间)
    	PreTraverseBTree(pT);//先序
    	printf("\n");
    	InTraverseBTree(pT);//中序
    	printf("\n");
    	PostTraverseBTree(pT);//后序
    	return 0;
    }
    
    

    树的结构 在CreateBTree(void)中定义
    在这里插入图片描述
    运行结果
    在这里插入图片描述

    展开全文
  • [问题描述] 很多涉及图上操作的算法都是以图的遍历操作为基础的。试写一个程序,演示在连通放入无向图上访问全部结点的操作。...以用户指定的结点为起点,分别输出每种遍历下的结点访问序列和相应生成的边集。
  • 遍历二叉树先中后序递归遍历二叉树中序非递归遍历二叉树 先中后序递归遍历二叉树 #include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int...

    先中后序递归遍历二叉树

    #include <stdio.h>
    #include <stdlib.h>
    
    #define OK 1
    #define ERROR 0
    #define TRUE 1
    #define FALSE 0
    
    typedef int Status; 
    
    typedef struct BiTNode
    {
    	char data;
    	struct BiTNode *lchild,*rchild;
    }BiTNode,*BiTree;
    
    //递归建立一棵树 
    Status CreateTree(BiTree *T)
    {
    	char ch;
    	scanf("%c",&ch);
    	if(ch == '#') *T=NULL;
    	else
    	{
    		*T = (BiTree)malloc(sizeof(BiTNode));  //不为空开辟一个结点空间 
    		if(!(*T))
    		{
    			printf("分配内存空间失败~");
    			return ERROR;
    		}
    		(*T)->data = ch;    //输入数据 
    		CreateTree(&((*T)->lchild));    //递归创建左子树 
    		CreateTree(&((*T)->rchild));    //递归创建右子树 
    	}
    	return OK;
    }
    
    //先序递归遍历二叉树
    void preOrder(BiTree T)
    {
    	if(T)
    	{
    		printf("%c",T->data);     //输出根 D 
    		preOrder(T->lchild);      //递归输出 L 
    		preOrder(T->rchild);      //递归输出 R 
    	}
    }
    
    //中序递归遍历二叉树
    void InOrder(BiTree T)
    {
    	if(T)
    	{
    		InOrder(T->lchild);      //递归输出 L 
    		printf("%c",T->data);     //输出根 D 
    		InOrder(T->rchild);      //递归输出 R 
    	}
    }
    
    //后序递归遍历二叉树
    void postOrder(BiTree T)
    {
    	if(T)
    	{
    		postOrder(T->lchild);      //递归输出 L 
    		postOrder(T->rchild);      //递归输出 R 
    		printf("%c",T->data);     //输出根 D 
    	}
    }
    
    int main()
    {
    	BiTree T;
    	printf("输入字母建立二叉树(#作为空树标志):");
    	CreateTree(&T);
    	printf("先序遍历的结果: ");
    	preOrder(T);
    	printf("\n中序遍历的结果: ");
    	InOrder(T);
    	printf("\n后序遍历的结果: ");
    	postOrder(T);
    	return 0;
    }
    

    结果:
    在这里插入图片描述

    分析:
    ABD#J##E##C#F## 则是建立以下这样一棵树。
    在这里插入图片描述

    中序非递归遍历二叉树

    #include <stdio.h>
    #include <stdlib.h>
    
    #define OK 1
    #define ERROR 0
    #define TRUE 1
    #define FALSE 0
    
    #define MAXSIZE 100
    
    typedef int Status;
    
    //定义二叉树的二叉链表存储结构
    typedef struct BiTNode
    {
    	char data;
    	struct BiTNode *lchild,*rchild;   //左右孩子指针 
    }BiTNode,*BiTree;
    
    //定义顺序栈存储结构 
    typedef struct
    {
    	BiTree *base;   //二重指针 ——指向二叉树结点指针的指针 
    	BiTree *top;
    	int stacksize;
    }SqStack;
    
    //初始化栈 
    Status InitStack(SqStack *S)
    {
    	(*S).base = (BiTree *)malloc(sizeof(BiTNode)*MAXSIZE);     //为顺序栈开辟一段空间 
    	if(!(*S).base) return ERROR;
    	(*S).top = (*S).base;
    	(*S).stacksize = MAXSIZE;
    	return OK;
    }
    
    //入栈
    Status push(SqStack *S,BiTree p)    //二叉树结点指针入栈 
    {
    	if((*S).base==NULL) return ERROR;
    	*((*S).top)++=p;
    	return OK; 
    }
    
    //出栈
    Status pop(SqStack *S,BiTree *p)
    {
    	if((*S).base == NULL) return ERROR;
    	*p = *--(*S).top;
    	return OK; 
    }
    
    //判断是否为空 
    Status StackEmpty(SqStack S)
    {
    	if(S.base == S.top) return TRUE;
    	return FALSE;
    }
    
    //递归建立二叉树
    Status CreateTree(BiTree *T)
    {
    	char ch;
    	scanf("%c",&ch);
    	if(ch == '#') *T = NULL;
    	else
    	{
    		*T = (BiTNode *)malloc(sizeof(BiTNode));    //新建一个二叉树结点 
    		if(!(*T))
    		{
    			printf("内存单元分配失败!\n");
    			return ERROR;
    		}
    		(*T)->data = ch;
    		CreateTree(&((*T)->lchild));
    		CreateTree(&((*T)->rchild));
    	}
    }
    
    //非递归中序遍历二叉树
    Status preOrder(BiTree T)
    {
    	SqStack S;   //栈 
    	InitStack(&S);   //初始化栈 
    	BiTNode *p,*q;   //指向栈结点的指针,p指针用于遍历,q指针用于临时存放出栈的根 
    	p=T;   //初始化状态,p指向T所指向的二叉树的根结点 
    	q = (BiTNode *)malloc(sizeof(BiTNode));    //为q开辟空间单元,存放出栈结点数据 
    	while(p||!StackEmpty(S))   //满足两个条件即循环 
    	{
    		if(p)
    		{
    			push(&S,p);     //非空,先把根入栈 
    			p=p->lchild;    //把左孩子,即左子树的根传递给p,开启下一遍遍历 
    		}
    		else
    		{
    			pop(&S,&q);   //空,把栈顶结点出栈 
    			printf("%c",q->data);    //输出数据 
    			p=q->rchild;    //遍历右子树 
    		}
    	}
    }
    
    int main()
    {
    	BiTree T;
    	printf("输入字母建立二叉树(#作为空树标志):");
    	CreateTree(&T);
    	printf("非递归中序遍历二叉树结果: ");
    	preOrder(T);
    	return 0;
    }
    

    结果:
    在这里插入图片描述

    层次遍历二叉树

    #include <stdio.h>
    #include <stdlib.h>
    
    #define OK 1
    #define ERROR 0
    #define TRUE 1
    #define FALSE 0
    
    #define MAXSIZE 100
    
    typedef int Status;
    typedef struct BTNode
    {
    	char data;
    	struct BTNode *lchild,*rchild;
    }BTNode,*BTree;
    
    typedef struct
    {
    	BTree *base;   //数组元素的值的类型是BTree->BTNode * 
    	int front;
    	int rear;
    }SqQueue;
    
    //初始化
    Status InitQueue(SqQueue *Q)
    {
    	Q->base = (BTree *)malloc(sizeof(BTree)*MAXSIZE);
    	if(!(*Q).base) return ERROR;
    	Q->front = Q->rear =0;
    	return OK;
    }
    
    //判断队列是否为空
    Status isEmpty(SqQueue Q)
    {
    	if(Q.front == Q.rear) return TRUE;
    	return FALSE;
    }
    
    //入队
    Status enQueue(SqQueue *Q,BTNode *T)
    {
    	if((*Q).rear + 1 ==(*Q).front) return ERROR;  //队满
    	Q->base[(*Q).rear] = T;
    	Q->rear = (Q->rear+1)%MAXSIZE; 
    }
    
    //出队
    Status deQueue(SqQueue *Q,BTree *T)
    {
    	if((*Q).front == (*Q).rear) return ERROR;  //对空
    	*T = Q->base[(*Q).front];
    	Q->front = (Q->front + 1)%MAXSIZE;
    }
    
    //递归创建二叉树
    Status CreateTree(BTree *T)
    {
    	char ch;
    	scanf("%c",&ch);
    	if(ch == '#') *T=NULL;
    	else
    	{
    		*T = (BTNode *)malloc(sizeof(BTNode));
    		if(!(*T)) return ERROR;
    		(*T)->data = ch;
    		CreateTree(&((*T)->lchild));
    		CreateTree(&((*T)->rchild));
    	}
    	return OK;
    }
    
    //层次遍历 
    Status LevelOrder(BTNode *T)
    {
    	SqQueue Q;
    	BTNode *p;
    	InitQueue(&Q);   //传Q的地址, 
    	enQueue(&Q,T);
    	while(!isEmpty(Q))
    	{
    		deQueue(&Q,&p);   //&p  二重指针,指针的指针 
    		printf("%c",p->data);   //输出出栈元素值 
    		if(p->lchild != NULL) enQueue(&Q,p->lchild);
    		if(p->rchild != NULL) enQueue(&Q,p->rchild);
    	}
    }
    
    int main()
    {
    	BTree T;
    	printf("输入字母建立二叉树(#作为空树标志):");
    	CreateTree(&T);
    	printf("层次遍历的结果:");
    	LevelOrder(T);
    	return 0;
    }
    

    在这里插入图片描述

    展开全文
  • 的层序遍历遍历一种,也是使得的线索化变得轻而易举。

    本实验取材于浙江大学《数据结构》
    除了先序、中序和后序三种基本的二叉树遍历方法外,有时还用到二叉树的层序遍历。层序遍历是按树的层次,从第1层的根结点开始向下逐层访问每个结点,对某一层中的结点是按从左到右的顺序访问。因此在进行层序遍历时,完成某一层结点的访问后,再按它们的访问次序依次访问各结点的左右孩子,这样一层一层进行下去,先遇到的结点先访问,这与队列的操作过程是吻合的。具体的算法实现可以设置一个队列结构,遍历从根节点开始,首先将根节点指针入队,然后开始执行下面三个操作:

    1. 从队列中取出一个元素;
    2. 访问该元素所指结点;
    3. 若该元素所指结点的左、右孩子结点非空,则将其左、右孩子的指针顺序入队。

    不断执行这三步操作,直到队列为空,再无元素可取,二叉树的层序遍历就完成了。

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    
    //树的层序遍历--采用队列模型
    //设置一个队列结构,遍历从根节点开始,首先将根节点指针入队,然后开始执行下面三个操作:
    //1、从队列中取出一个元素;
    //2、访问该元素所指结点;
    //3、若该元素所指结点的左右孩子结点非空,则将其左、右孩子的指针顺序入队
    //不断执行这三部操作,直到队列为空,再无元素可取,二叉树的程序遍历就完成了。
    #define ERROR -1
    #define MaxSizel 10
    //typedef struct SNode *PtrToSNode;
    typedef int ElementType;
    typedef struct TNode *Position;
    typedef Position BinTree; /* 二叉树类型 */
    struct TNode{ /* 树结点定义 */
        ElementType Data; /* 结点数据 */
        BinTree Left;     /* 指向左子树 */
        BinTree Right;    /* 指向右子树 */
    };
    struct QNode{
    	ElementType *Data;
    	int rear;
    	int front;
    	int MaxSize;
    };
    typedef struct QNode *Queue;
    Queue CreateQueue(int MaxSize1);//生成长度为MaxSize的空队列
    int IsFullQ(Queue Q);//判断队列Q是否已满
    void AddQ(Queue Q,Position item);//将数据元素item插入队列Q中
    int IsEmptyQ(Queue Q);//判断队列Q是否为空
    ElementType DeleteQ(Queue Q);//将队头数据元素从队列中删除并返回
    Queue CreateQueue(int MaxSize1){
    	Queue Q = (Queue)malloc(sizeof(struct QNode));
    	Q->Data = (ElementType *) malloc(MaxSize1 * sizeof(ElementType));
    	Q->front = Q->rear = 0;
    	Q->MaxSize = MaxSize1;
    	return Q;
    	
    }
    int IsFullQ(Queue Q){
    	
    	return ((Q->rear+1)%Q->MaxSize == Q->front);
    }
    void  AddQ(Queue Q,Position item){
    	if(IsFullQ(Q)){
    		printf("Queue is full\n");
    		return ;
    	}
    	Q->rear = (Q->rear+1) %Q->MaxSize;
    	Q->Data[Q->rear] = (int)item;
    }
    int IsEmptyQ(Queue Q){
    	return (Q->front == Q->rear);
    }
    ElementType DeleteQ(Queue Q){
    	if(IsEmptyQ(Q))
    	{
    		printf("Queue is empty\n");
    		return ERROR;
    		
    	}else{
    		Q->front = (Q->front+1)%Q->MaxSize;
    		return Q->Data[Q->front];
    	}
    }
    void LevelorderTraversal(BinTree BT)
    {
    	Queue Q;
    	BinTree T;
    	if(!BT) return;
    	Q=CreateQueue(MaxSizel);
    	AddQ(Q,BT);
    	while(!IsEmptyQ(Q)){
    		T=(struct TNode * )DeleteQ(Q);
    		printf("%d ",T->Data);//访问取出队列的结点
    		if(T->Left) AddQ(Q,T->Left);
    		if(T->Right) AddQ(Q,T->Right);
    	}
    }
    int main()
    {
    	
    		BinTree Bt = (BinTree)malloc(sizeof(struct TNode));
    	BinTree Bt1 = (BinTree)malloc(sizeof(struct TNode));
    	BinTree Bt2 = (BinTree)malloc(sizeof(struct TNode));
    	BinTree Bt3 = (BinTree)malloc(sizeof(struct TNode));
    	BinTree Bt4 = (BinTree)malloc(sizeof(struct TNode));
    	Bt->Data = 1;
    	Bt1->Data=2;
    	Bt2->Data=3;
    	Bt3->Data=4;
    	Bt4->Data=5;
    	Bt->Left = Bt1;
    	Bt->Right = Bt2;
    	Bt1->Left = NULL;
    	Bt1->Right = NULL;
    	
    	Bt2->Left = Bt3;
    	Bt2->Right = Bt4;
    	Bt3->Left = NULL;
    	Bt3->Right = NULL;
    	Bt4->Left = NULL;
    	Bt4->Right = NULL;	
    	printf("\nceng xu bian li\n");
    	
    	LevelorderTraversal(Bt);
    	printf("\n");
    
    	
    	return 0;
    
    }
    
    展开全文
  • c语言 的层序遍历

    2021-05-05 20:05:26
    层序遍历比先序递归和非递归都要简单。 #include <stdio.h> #include <stdlib.h> typedef struct tree_node{ int val; struct tree_node *left; struct tree_node *right; }tree,*tree_point; //...
  • C语言的建立和遍历

    千次阅读 2017-05-02 17:31:50
    遍历分为三种:前序遍历(根左右),中序遍历(左根右),后序遍历(左右根)。 PS:根左右,就是先遍历根节点,然后是左子树,最后是右子。如下图: 前序遍历:ABDECF。 中序遍历:DBEACF。 后序遍历...
  • 遍历 先跟(次序)遍历不空,则先访问根节点,然后依次先跟遍历各棵子树。 后跟(次序)遍历: 若不空,则先依次后跟遍历各棵子树,然后访问根节点。 按层次遍历: 若不空,则自上而下自左至右访问中...
  • ``` #include #include typedef struct node { int num;...我的Change函数是先序遍历,小弟刚学实在不知道错在哪里。...如果我要想从大到小的顺序输出二叉排序的各结点的算法,怎么实现,跪求大神门的指教,感谢!
  • 非递归遍历树

    2012-05-16 14:36:49
    C语言对非递归的实现、先序、中序、后序遍历
  • Java 构建与遍历树

    2014-11-18 10:53:32
    /** * 功能:把一个数组的值存入二叉树中,然后进行3种方式的遍历 * * 参考资料0:数据结构(C语言版)严蔚敏
  • C语言 红黑插入/删除/查找/遍历

    千次阅读 2018-12-14 18:31:04
    1 红黑介绍 红黑(Red-Black Tree,简称R-B Tree),它一种特殊的二叉查找。 红黑是特殊的二叉查找,意味着它满足二叉查找的特征:任意一个节点所包含的键值,大于等于左孩子的键值,小于等于右孩子的...
  • C语言 Dev C++ 1 实验题目 通过添加虚结点,为二叉树的每一实结点补足其孩子,再对补足虚结点后的...3)完成后序线索化上的遍历算法,依次输出该二叉树先序遍历、中序遍历和后序遍历结果。 3 输入输出样例 ...
  • C语言-

    2021-03-11 17:58:27
    C语言-树C语言树,通过题目感受代码风格的重要性根据后序和中序遍历输出前序遍历 C语言树,通过题目感受代码风格的重要性 在基于C语言的数据结构与算法的学习中,阅读经典题目的解答可以形成良好的基本代码风格,...
  • 最后先序遍历右子 中序遍历:【中间访问根节点】 先中序遍历左子树, 再访问根节点, 最后中序遍历右子, 后序遍历:【最后访问根节点】 先后序遍历左子树, 再后序遍历左子树, ...
  • 主要介绍了C语言数据结构之后序遍历的实现的相关资料,这里提供一个简单实例来实现后续遍历,对于数据结构的学习很有帮助,需要的朋友可以参考下
  • 本题要求实现给定的二叉树的三种遍历。函数接口定义:void Preorder(BiTree T);void Inorder(BiTree T);void Postorder(BiTree T);T是二叉树树根指针,Preorder、Inorder和Postorder分别输出给定二叉树的先序、中序...
  • 的层次遍历的的深度遍历,都是用非递归的方法实现的
  • 遍历是考验程序员的基本本领,采用非递归遍历效率会更高!
  • void PostorderThreading (Tree * const ptree) ;static void Postorder_Threading (Tree * const ptree, Node * * const previous) ;void PostorderThreadedTraversal (const Tree tree, void (* pfun) (const ...
  • C语言二叉树先序遍历、中序遍历、后序遍历、结点数目、二叉树的高度 二叉树的遍历 先序遍历(DLR)——访问根节点,遍历左子树,遍历右子 中序遍历(LDR)——遍历左子树,访问根节点,遍历右子 后序遍历(LRD)...
  • 本试验取材于浙江大学《数据结构》,内含表示及遍历的测试源码! //的实现上 #include<stdio.h> #include<stdlib.h> #include<string.h> typedef int ElementType; typedef struct TNode *...
  • 由于我们可能遇到输入为二叉树,或是不规则的,故我们声明的结构体为包含兄弟指针和子...我们示例的结构为百度百科解释的前序遍历即后续遍历的例子如图 代码 #include <iostream> struct Node; typedef struc...

空空如也

空空如也

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

c语言遍历树

c语言 订阅