精华内容
下载资源
问答
  • NULL 博文链接:https://128kj.iteye.com/blog/1692248
  • 以前大学学数据结果的时候,我们就知道,根据一棵树的先序遍历和中序遍历,或者后序遍历和中序遍历序列,都可以唯一地确定一棵树。
  • 思路:用递归把中序遍历的数组划分为左右子树部分,直到没有左右子树(叶子节点)。层序遍历的方法:使用队列。 #include <iostream> #include<vector> #include<queue> using namespace std; #...

    思路:用递归把中序遍历的数组划分为左右子树部分,直到没有左右子树(叶子节点)。层序遍历的方法:使用队列。

    #include <iostream>
    #include<vector>
    #include<queue>
    using namespace std;
    #define maxsize 30
    typedef struct node* T;
    struct node {
    	int data;
    	T left;
    	T right;
    };
    int n, postorder[maxsize], inorder[maxsize];
    T buildTree(T tree,int start,int end) {
    	int flag = 0,j=n-1,stop=0;
    	while (1) {
    		for (int i = start; i < end; i++) {
    			if (inorder[i] == postorder[j]) {
    				flag++;
    				tree->data = inorder[i];
    				stop = i;
    				break;
    			}
    		}
    		if (flag==0) j--;
    		if (flag!=0||j < 0) break;
    	}
    	T Tleft = (T)malloc(sizeof(node));
    	T Tright = (T)malloc(sizeof(node));
    	Tleft->data = 0; Tleft->left = Tleft->right = nullptr;
    	Tright->data = 0; Tright->left = Tright->right = nullptr;
    	if (stop > start && stop < end-1) {
    		tree->left = buildTree(Tleft, start, stop);
    		tree->right = buildTree(Tright, stop + 1, end);
    	}
    	else if (stop == start&&start!=end-1) {
    		tree->right = buildTree(Tright, stop + 1, end);
    	}
    	else if (stop == end - 1 && start != end-1)
    		tree->left = buildTree(Tleft, start, stop);
    	else if (start == end - 1)	return tree;
    	return tree;
    }
    int main() {
    	cin >> n;
    	for (int i = 0; i < n; i++)
    		cin >> postorder[i];
    	for (int i = 0; i < n; i++)
    		cin >> inorder[i];
    	T head = (T)malloc(sizeof(node));
    	head->left = head->right = nullptr;
    	head=buildTree(head,0,n);
    	queue<T> Q;
    	Q.push(head);
    	while (!Q.empty())
    	{
    		cout << Q.front()->data<<" ";
    		if (Q.front()->left) Q.push(Q.front()->left);
    		if (Q.front()->right) Q.push(Q.front()->right);
    		Q.pop();
    	}
    }

    展开全文
  • voidBuildTree(char*level,char*inorder,pBiTreeT){inti;...//取得层次遍历长度intpos;if(len==0)return;char*p=strchr(inorder,level[0]);if(p==NULL)//如果为空则...void BuildTree(char *level,char *inorde...

    voidBuildTree(char*level,char*inorder,pBiTreeT){inti;intlen=strlen(level);//取得层次遍历长度intpos;if(len==0)return;char*p=strchr(inorder,level[0]);if(p==NULL)//如果为空则...

    void BuildTree(char *level,char *inorder,pBiTree T)

    {

    int i;

    int len=strlen(level); //取得层次遍历长度

    int pos;

    if(len==0)

    return ;

    char *p=strchr(inorder,level[0]);

    if(p==NULL) //如果为空则抛弃第一个,跳到下一个;

    {

    char *L=(char*)malloc(sizeof(char)*len); //开辟数组

    strncpy(L,level+1,len-1); //舍弃第一个

    L[len-1]=0;

    T->lchild=NULL;

    T->rchild=NULL;

    BuildTree(L,inorder,T); //调用建树函数

    return ;

    }else{

    pos=p-inorder; //得到中序遍历左子树字符串长度

    T->data=level[0]; //为根节点赋值

    T->lchild=NULL;

    T->rchild=NULL;

    }

    if(pos!=0) //左子树的递归调用

    {

    pBiTree left;

    T->lchild=(pBiTree)malloc(sizeof(BiNode));

    left=T->lchild;

    char *left_level=(char*)malloc(sizeof(char)*len);

    char *left_inor=(char*)malloc(sizeof(char)*(pos));

    strncpy(left_level,level+1,len-1); //舍去层次遍历第一个

    strncpy(left_inor,inorder,pos); //截取左子树字符串

    left_level[len-1]=0;

    left_inor[pos]=0;

    BuildTree(left_level,left_inor,left);

    }

    if(pos!=len-1) //右子树的递归调用

    {

    pBiTree right;

    T->rchild=(pBiTree)malloc(sizeof(BiNode));

    right=T->rchild;

    char *right_level=(char*)malloc(sizeof(char)*(len));

    char *right_inor=(char*)malloc(sizeof(char)*(len-pos));

    strncpy(right_level,level+1,len-1);

    strncpy(right_inor,inorder+pos+1,len-pos-1);

    right_level[len-1]=0;

    right_inor[len-pos-1]=0;

    BuildTree(right_level,right_inor,right);

    }

    }

    运行结果:

    2

    输入:

    CBA

    BCA

    输出:

    CB燗

    燘AC

    输入:

    BACDE

    DAEBC

    输出:

    BAD燛C

    燚EA谻B

    展开

    展开全文
  • 输入后序遍历中序遍历的结果。输出层次遍历的结果。 import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); String hx =sc.next();...

    一棵二叉树,分布大写英文字母(最多26个);输入后序遍历,中序遍历的结果。输出层次遍历的结果。

    import java.util.Scanner;
    
    public class Main {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            String hx =sc.next();  //后序遍历的字符串
            String zx = sc.next();      //中序遍历的字符串
            //hx:2315764  zx:1234567
            String[] s = new String[]{"", "", "", "", ""};  //最多五层
            int i = 0;
            String r = "";
            String[] zxc = zxc(hx, zx, i, s);
            for (int i1 = 0; i1 < zxc.length; i1++) {
                r+=zxc[i1];
            }
            System.out.println(r);//4163572
    
        }
        
        /**
         *
         * @param String hx 后序遍历的值
         * @param String zx 中序遍历的值
         * @param int i 二叉树的层级,根节点为0层
         * @param String [] s 每层二叉树作为数组的一个元素,初始各个元素为"",
         * @return String [] s
         */
        public static String[] zxc(String hx, String zx, int i, String[] s) {
            String ss = String.valueOf(hx.charAt(hx.length() - 1)); //根节点
            s[i] += ss;
            String[] zs = zx.split(s[i].substring(s[i].length()-1));
            String hl = hx.substring(0, zs[0].length());
            String hr = hx.substring(zs[0].length(), hx.length() - 1);
    
            i = i + 1;
            if (i < 4 && hl.length() > 1) {
                zxc(hl, zs[0], i, s);
            } else {
                    s[i] += zs[0];
    
            }
            if (i < 4 && hr.length() > 1) {
                zxc(hr, zs[1], i, s);
            } else {if(zs.length>1){
                    s[i] += zs[1];}
            }
            return s;
        }
    }
    
    
    
    
    展开全文
  • C语言实现数据结构中根据中序后序遍历构建树,并进行先序与层次遍历,以树形结构输出,附有详细中文注释
  • 给定一棵二叉树的后序遍历和中序遍历,请你输出其层序遍历的序列。这里假设键值都是互不相等的正整数。 输入样例: 7 2 3 1 5 7 6 4 1 2 3 4 5 6 7 输出样例: 4 1 6 3 5 7 2 解题思路: 已知后序序列和中序序列...

    给定一棵二叉树的后序遍历和中序遍历,请你输出其层序遍历的序列。这里假设键值都是互不相等的正整数。

    输入样例:
    7
    2 3 1 5 7 6 4
    1 2 3 4 5 6 7
    
    输出样例:
    4 1 6 3 5 7 2
    
    解题思路:

    已知后序序列和中序序列确定树的结构:
    先建立一个树根节点,后续序列的最后一个即为树根节点。确定树根后,遍历中序序列找到树根节点,树根节点的左边的序列即为树根左孩子的中序序列,右边为右孩子的中序序列。计算左孩子的节点个数n,右孩子节点个数m,遍历后序序列的前n个是左孩子的后续序列,再后面m个是右孩子的后序序列,根据左孩子和右孩子的后序和中序序列进行递归,最后建立一棵树

    答案:
    #include<stdio.h>
    #include<malloc.h>
    typedef struct tnode  //二叉树节点
    {
        struct node *lchild, *rchild;
        char data;
    } BTNode;
    typedef BTNode* ElementType ;  
    
    typedef struct Node* PtrToNode;  
    struct Node{          // 队列中的节点
        ElementType data;
        PtrToNode Next;
    };
    typedef PtrToNode Position;
    
    typedef struct QNode * PtrToQNode;
    struct QNode{          
        Position Front,Rear;  //队列头尾指针
    };
    typedef PtrToQNode Queue;
    
    Queue CreateQueue()    // 创建队列(用于层序输出)
    {
        Queue Q = (Queue)malloc(sizeof(struct QNode));
        Q->Front = NULL;
        Q->Rear = NULL;
        return Q;
    }
    
    void AddQ(Queue Q,ElementType x)  // 队列添加元素
    {
        PtrToNode p = (PtrToNode)malloc(sizeof(struct Node));
        p->Next = NULL;
        p->data = x;
        if(Q->Front == NULL)  // 队列空时
        {
            Q->Front = p;
            Q->Rear = p;
        }
        else
        {
            Q->Rear->Next = p;
            Q->Rear = p;
        }
    }
    
    ElementType DeleteQ(Queue Q)
    {
        ElementType n ;
        Position FrontCell;
        FrontCell = Q->Front;
        if(Q->Front == Q->Rear)
        {
            Q->Front = Q->Rear = NULL;
        }
        else{
            Q->Front = Q->Front->Next;
        }
        n = FrontCell->data;
        free(FrontCell);
        return n;
    }
    
    int IsEmpty(Queue Q)
    {
        if(Q->Front == NULL)
            return 1;
        else
            return 0;
    }
    
    BTNode* CreateBTree(int *pre, int *in, int n)   // 根据后序和中序遍历序列确定树的结构
    {
        int k;   // 记录根节点左子树的个数
        int *p;  // 指向根节点
        if (n <= 0)
            return NULL;
        BTNode *b = (BTNode*)malloc(sizeof(BTNode));
        b->data = *(pre+n-1);  // 树的根节点为后序序列的最后一个编号
        for (p = in; p < in + n; ++p)  
            if (*p == *(pre+n-1))  // 在中序序列中寻找根节点的位置
                break;				// 找到后退出循环
        k = p-in;          // 记录根节点左子树节点个数
        b->lchild = CreateBTree(pre, in, k);  // 递归
        b->rchild = CreateBTree(pre+k, p+1, n-k-1);
        return b;
    }
    
    
    void LevelorderTraversal(BTNode * BT)
    {
        Queue Q;
        BTNode * T;
        int temp = 1;
        if(!BT) return;
    
        Q = CreateQueue();
        AddQ(Q,BT);
        while(!IsEmpty(Q))
        {
            T = DeleteQ(Q);
            if(temp)
            {
                printf("%d",T->data);
                temp = 0;
            }
            else
                printf(" %d",T->data);
            if(T->lchild)
                AddQ(Q,T->lchild);
            if(T->rchild)
                AddQ(Q,T->rchild);
        }
    }
    
    
    int main()
    {
        BTNode* b;
        int n,i;
        scanf("%d",&n);
        int pre[n],in[n];
        for(i=0 ;i<n;i++)
        {
            scanf("%d",&pre[i]);
        }
        for(i=0;i<n;i++)
        {
            scanf("%d",&in[i]);
        }
    
    
        b = CreateBTree(pre, in, n);
        LevelorderTraversal(b);
        return 0;
    }
    
    
    展开全文
  • 中序遍历:dbaec —> db a ec 可看出 根结点为a,左子是bd,右子就是ce 先序 bd 中序 bd 二叉树中,位置是b为父,d为右子。 先序 ce 中序 ec 位置是 e为左子,c为右子。 //构造完全二叉树的顺序存储结构 //按照层...
  • 二叉树遍历算法 (递归的、非递归的中序、前序、后序遍历 层次遍历 以及 二叉树的宽度深度)
  • 后序遍历和中序遍历输出层序遍历C++ 给定一棵二叉树的后序遍历和中序遍历,请你输出其层序遍历的序列。这里假设键值都是互不相等的正整数。 输入格式: 输入第一行给出一个正整数N(≤30),是二叉树中结点的个数...
  • 输入某二叉树的前序遍历和中序遍历的结果,请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6},则重建二叉树并返回...
  • 二叉树的遍历方式主要有:先序遍历、中序遍历后序遍历层次遍历。先序、中序、后序其实指的是父节点被访问的次序。若在遍历过程中,父节点先于它的子节点被访问,就是先序遍历;父节点被访问的次序位于左右孩子...
  • 给定一棵二叉树的后序遍历和中序遍历,请你输出其层序遍历的序列。这里假设键值都是互不相等的正整数。 输入格式: 输入第一行给出一个正整数N(≤30),是二叉树中结点的个数。第二行给出其后序遍历序列。第三行给...
  • 作为例子的树长这样:package bstpractice;import java.util.ArrayList;...public class BstTest {public static void main(String args[]){//step1,先根据中序后序序列建树List posOrder = ...
  • 满意答案文件 main.cpp 代码如下:#include // malloc()等#include // 标准输入输出头文件,包括EOF(=^Z或F6),NULL等#include // atoi(),exit()#include // 数学函数头文件,包括floor...清空二叉树销毁二叉树的...
  • 一、前序遍历 根节点-&gt;左子树-&gt;右子树 二、中序遍历 左子树-&gt;根节点-&gt;右子树 三、后序遍历 ...四、层次遍历 ...1、后序遍历序列与中序遍历序列相同 说明该二叉树无右结点 ...
  • 二叉树简介 ...二叉树的遍历有4种方式,先序遍历,中序遍历后序遍历层次遍历,前三者均属于深度优先遍历,先序、中序、后序指的是遍历时根节点相对于左右孩子的次序,先序遍历的顺序为根节点->左子树->
  • 这是三个节点的二叉树的类型 树类型 先序遍历 中序遍历 (1) ...所以,这个结论应该是先序/后序遍历+中序遍历能确定一个二叉树,一个二叉树确定遍历,但是这树这遍历没有一一对应的关系。
  • =0)个结点的有限集合,该集合或者为空集(称为空二叉树),或者由一个根结点两棵互不相交的、分别称为根结点的左子树右子树组成。或者更通俗点讲: 二叉树(binary tree)是一棵树,其中每个节点都...
  • 二叉树的先序遍历,中序遍历,后序遍历,层次遍历(递归非递归) 先序遍历 二叉树的先序遍历是进行先根遍历,接下来是左子树,然后是右子树这样的顺序。 void preorder(BiTree T){ if(T!=NULL){ visit(T); ...
  • 用C++写的,包括二叉树的构建,二叉树的先序遍历、中序遍历和后序遍历非递归算法。
  • public class Tree { public static void main(String[] args) { TreeNode root = new TreeNode(1); root.left = new TreeNode(2); root.right = new TreeNode(3); root.left.left = new TreeNode(4);...
  • 1.二叉树的构成 任何一个非空的二叉树都由根结点、左子树、右子树这三部分构成。 ...先序遍历: DLR 中序遍历:LDR 后序遍历:LRD 层序遍历:一层一层从左向右依次输出   3.实现代码: ...
  • DFS 与 BFS一、BFS1.1 什么是 BFS二、DFS2.1 什么是 DFS ...BFS(Breadth First Search) 即广度优先搜索,在数图中非常常见 二、DFS 2.1 什么是 DFS DFS 即深度优先搜索,同 BFS,在树图中也是非常常见的 ...
  • 中序遍历先访问左子树,然后访问根节点,最后访问右子树。 后续遍历先访问左子树,然后访问又子树,最后访问根节点。 遍历树结构如下所示: 1.首先建立节点类 public class Node { private String data; private ...
  • 二叉树的遍历通常有三种方法:迭代法,递归法,Morris算法。 前序遍历 LeetCode 144. 二叉树的前序遍历 https://leetcode-cn.com/problems/binary-tree-preorder-traversal/ 方法1:迭代法 class Solution { public:...
  • 1.前序遍历 前序遍历(DLR,lchild,data,rchild),是二叉树遍历的一种,也叫做先根遍历、先序遍历、前序周游,可记做根左右。前序遍历首先访问根结点然后遍历左子树,最后遍历右子树。前序遍历首先访问根结点然后...
  • 2、这样的话看中序遍历:8前面的便是左子树:5374,后序遍历中最后遍历的是7,所以7是左子树的根结点 3、7前面的35为7的左子树,可以由中序和后序的(遍历顺序)得到7的左子树为5,5的右子树为3;同理可...
  • c语言,二叉树的先序,中序后序遍历以及叶子结点数目
  • 事实上,一个中序遍历的算法中入栈的过程中,如果你把每个入栈的结点保存起来,你会发现这些结点就是先序遍历的结果,同样,出栈就是中序遍历,如下图 核心算法 先序遍历的第一个结点一定是根结点,也是后序遍历...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,415
精华内容 8,166
关键字:

后序遍历和中序遍历求层次遍历