精华内容
下载资源
问答
  • 105前序和中序遍历确定二叉树 根据一棵树的中序遍历与后序遍历构造二叉树 注意: 你可以假设树中没有重复的元素。 例如,给出 中序遍历 inorder =[9,3,15,20,7] 后序遍历 postorder = [9,15,7,20,3] 返回如下的...

    LeetCode: 

    106 中序和后序遍历确定二叉树


    105 前序和中序遍历确定二叉树

    根据一棵树的中序遍历与后序遍历构造二叉树

    注意:
    你可以假设树中没有重复的元素。

    例如,给出

    中序遍历 inorder = [9,3,15,20,7]
    后序遍历 postorder = [9,15,7,20,3]
    返回如下的二叉树:

        3
       / \
      9  20
        /  \
       15   7
    二叉树遍历
    二叉树的前序、中序、后序遍历(深度优先遍历)
    遍历即将树的所有结点都访问且仅访问一次。按照根结点访问次序的不同,可以分为前序遍历,中序遍历,后序遍历。
    前序遍历:根结点 -> 左子树 -> 右子树
    中序遍历:左子树 -> 根结点 -> 右子树
    后序遍历:左子树 -> 右子树 -> 根结点

    思路:递归思想root --> root.left + root.right

    中序+后序确定二叉树:后序遍历的最后一个节点为root, 中序遍历中的root将二叉树划分为左、右子树,对于左右子树同样处理:递归

    前序+中序确定二叉树:前序遍历的第一个节点为root, 中序遍历中的root将二叉树划分为左、右子树,对于左右子树同样处理:递归

    定义二叉树:

    # Definition for a binary tree node.
    from typing import List
    class TreeNode:
        def __init__(self, x):
            self.val = x
            self.left = None
            self.right = None
    

    中序+后序确定二叉树实现:

    class Solution:
        # 根据 中序+后序
        def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
            if len(postorder)==0:   return None
            if len(postorder)==1:   return TreeNode(postorder[0])
            else:
                value = postorder[len(postorder)-1]
                root=TreeNode(value)
                index = inorder.index(value)
                root.left=self.buildTree(inorder[:index], postorder[:index])
                root.right=self.buildTree((inorder[index+1:], postorder[index:len(postorder)-1]))
                return root
    

    前序+中序确定二叉树实现:

        # 根据 前序+中序
        def buildTree2(self,preorder:List[int],inorder:List[int]):
            if len(preorder)==0:    return None
            if len(preorder)==0:    return TreeNode(preorder[0])
            else:
                value=preorder[0]
                root=TreeNode(value)
                index=inorder.index(value)
                root.left=self.buildTree2(preorder[1:index+1],inorder[:index])
                root.right=self.buildTree2(preorder[index+1:],inorder[index+1:])
                return root

    测试代码:

    if __name__ =="__main__":
        s=Solution()
    
        inorder =[9, 3, 15, 20, 7]
        postorder =[9, 15, 7, 20, 3]
    
        r=s.buildTree()
    

     

    展开全文
  • 力扣 根据前序遍历和中序遍历确定二叉树 基本思路 前序遍历确定根节点是哪个(第一个就是根节点) 中序遍历根据已知根节点确定左右子树的元素组成 根节点左 左子树 根节点右 右子树 再根据前序遍历确定 左子树的根...

    力扣 根据前序遍历和中序遍历确定二叉树
    在这里插入图片描述
    在这里插入图片描述
    基本思路
    前序遍历确定根节点是哪个(第一个就是根节点)
    中序遍历根据已知根节点确定左右子树的元素组成
    根节点左 左子树
    根节点右 右子树
    再根据前序遍历确定 左子树的根节点
    根据左子树的根节点确定 左子树元素的左右子树

    理解:每次更新的是提供的前序遍历序列和中序遍历序列 ,官方答案提供的是更新索引,不更新前、中序遍历
    class Solution {
    	public TreeNode buildTree(int[] preorder, int[] inorder) {
    		if(preorder.length==0 || inorder.length==0) {
    			return null;
    		}
    		//根据前序数组的第一个元素,就可以确定根节点
    		TreeNode root = new TreeNode(preorder[0]);
    		for(int i=0;i<preorder.length;++i) {
    			//用preorder[0]去中序数组中查找对应的元素
    			if(preorder[0]==inorder[i]) {
    				//将前序数组分成左右两半,再将中序数组分成左右两半
    				//之后递归的处理前序数组的左边部分和中序数组的左边部分
    				//递归处理前序数组右边部分和中序数组右边部分
    				int[] pre_left = Arrays.copyOfRange(preorder,1,i+1);
    				int[] pre_right = Arrays.copyOfRange(preorder,i+1,preorder.length);
    				int[] in_left = Arrays.copyOfRange(inorder,0,i);
    				int[] in_right = Arrays.copyOfRange(inorder,i+1,inorder.length);
    				root.left = buildTree(pre_left,in_left);
    				root.right = buildTree(pre_right,in_right);
    				break;
    			}
    		}
    		return root;
    	}
    }
    
    
    

    在这里插入图片描述

    class Solution {
        public int numSquares(int n) {
            int[] dp = new int[n + 1]; // 默认初始化值都为0
            for (int i = 1; i <= n; i++) {
                dp[i] = i; // 最坏的情况就是每次+1
                for (int j = 1; i - j * j >= 0; j++) { 
                    dp[i] = Math.min(dp[i], dp[i - j * j] + 1); // 动态转移 
                    //dp[0]=0,当i-j*j=0时,说明只需要一次就可以,如果i-j*j!=0时,说明我们需要根据前面的最优结果进行+1
                    //例如5  因为4的最优只有1个即可,因此5只需在4的基础上+1
                }
            }
            return dp[n];
        }
    }
    
    

    快速排序思想
    1、第一轮 最左侧元素作为Key值(目标:>Key 右侧,<Key 左侧)
    双指针放在第二个元素和最后一个元素
    (1)从r指针开始,寻找小于Key的元素,找到时停下
    (2)从l指针开始,寻找大于Key的元素,找到时停下,交换l、r指针元素的位置
    (3)重复(1)直到左右指针重合(l=r)
    (4)重合后将l指针元素与Key交换顺序(实现了左<Key右>Key)
    2、将Key左侧的作为新的待排列的数组,重复1操作
    将Key右侧的作为新的待排列的数组,重复1操作
    3、排列完成标志 l>r或者输入数组为空时说明排列完成

    class Solution {
        public void sortColors(int[] nums) {
            int len = nums.length;
            quicksort(nums,0,len-1);
        }
    
        public int[] quicksort(int[] nums,int start,int end){
            if(start>end){
                return nums;
            }
            int Key = nums[start];
            int left = start;
            int right = end;
            while(left<right){
                while(left<right&&nums[right]>=Key){  //从右向左找到<Key的值终止循环
                    right--;
                }
                while(left<right&&nums[left]<=Key){ //从左向右找到>Key的值终止循环
                    left++;
                }
                if(left<right){
                    swap(nums,left,right);
                }
                if(left>=right){
                    swap(nums,start,left);
                }
            }
            quicksort(nums,left+1,end);
            quicksort(nums,start,left-1);
            return nums;
    
        }
        public void swap(int[] nums, int a, int b){
            int temp = nums[a];
            nums[a] = nums[b];
            nums[b] = temp;
        }
    }
    

    归并排序 核心思想(两两有序合并)
    1、将序列中待排序数字分为若干组,每个数字分为一组
    2、将若干个组凉凉合并,保证合并后的数组是有序的
    3、重复第二部操直到只剩下一组

    两两合并原则:,比较两组数据头部大小,将小的放入新的序列,更新头部指针,重复操作

    展开全文
  • 此程序可以解决由二叉树的前序遍历和中序遍历确定二叉树的形状 首先提示用户收入一颗二叉树的前序遍历和中序遍历,然后回车, 即可得到完整的前序和中序以及后序遍历序列, 并且打印出二叉树翻转90°后的形状...
  • 已知一个二叉树,我们可以得到它的前序遍历,中序遍历和后续遍历。那么,我们已知前序和中序的遍历结果,怎样还原二叉树呢?假设前序遍历结果为:abdcef,中序遍历结果为dbaecf。 前序遍历:根结点+左子树+右子树 ...

    已知一个二叉树,我们可以得到它的前序遍历,中序遍历和后续遍历。那么,我们已知前序和中序的遍历结果,怎样还原二叉树呢?

    假设前序遍历结果为:abdcef,中序遍历结果为dbaecf。

            前序遍历:根结点+左子树+右子树

            中序遍历:左子树+根结点+右子树

           由此,我们可以得知,前序结果第一个字母a为根结点,在中序遍历结果中找到a,a的左侧d,b为a的左子树,a的右侧e,c,f为a的右子树;前序结果第二个字母b为a的左孩子,在中序遍历结果中找到b,b的左侧d为b的左子树,右子树为空;以此类推,利用递归,最终可以得到二叉树。

    #include <iostream>
    using namespace std;
    #include <string>
    template <class T>
    struct TreeNode
    {
    	TreeNode(const T& data)
    	: _data(data)
    	, _pLeft(NULL)
    	, _pRight(NULL)
    	{}
    
    	T _data;
    	TreeNode<T> *_pLeft;
    	TreeNode<T> *_pRight;
    };
    template <class T>
    class BinTree
    {
    	typedef TreeNode<T> Node;
    public:
    	BinTree()
    		: _pRoot(NULL)
    	{}
    	Node* ReBuildTree(char* preorder, char* inorder)
    	{
    		size_t size = strlen(inorder);
    		return _ReBuildTree(_pRoot, preorder, inorder, inorder + size - 1);
    	}
    	void PostOrder()
    	{
    		cout << "后序遍历结果:";
    		_PostOrder(_pRoot);
    		cout << endl;
    	}
    private:
    	Node* _ReBuildTree(Node*& pRoot, char*& preorder, char* inbegin, char* inend)
    	{
    		if (inbegin>inend || *preorder == '\0')
    			return NULL;
    		pRoot = new Node(*preorder);
    		char* cur = inbegin;
    		for (cur = inbegin; cur <= inend; cur++)
    		{
    			if (*cur == *preorder)
    			{
    				if (inbegin <= cur - 1)
    					_ReBuildTree(pRoot->_pLeft, ++preorder, inbegin, cur - 1);
    				if (cur + 1 <= inend)
    					_ReBuildTree(pRoot->_pRight, ++preorder, cur + 1, inend);
    			}
    		}
    		return pRoot;
    	}
    	void _PostOrder(const Node* pRoot)
    	{
    		if (pRoot)
    		{
    			_PostOrder(pRoot->_pLeft);
    			_PostOrder(pRoot->_pRight);
    			cout << pRoot->_data << " ";
    		}
    	}
    private:
    	Node* _pRoot;
    };


    展开全文
  • 根据二叉树性质,由二叉树的前序遍历序和中序遍历序,可以唯一确定一棵二叉树(设二叉树中各结点不相同)。请编写程序,根据输入的二叉树的前序遍历序和中序遍历序,计算并输出其后序遍历序。 输入 输入第一行为...

    问题 B: 二叉树的遍历

    时间限制: 1 Sec  内存限制: 128 MB
    提交: 582  解决: 331
    [提交][状态][讨论版]

    题目描述

    根据二叉树性质,由二叉树的前序遍历序和中序遍历序,可以唯一确定一棵二叉树(设二叉树中各结点不相同)。请编写程序,根据输入的二叉树的前序遍历序和中序遍历序,计算并输出其后序遍历序。

    输入

    输入第一行为二叉树的个数n,0<n≤1000,其后n行每行中由两个字符串组成,第一个是二叉树的前序遍历序,第二个是二叉树的中序遍历序,字符串中每个字符表示一个结点,字符串长度不超过2000。

    输出

    对每个二叉树,输出一行后序遍历序。

    样例输入

    2
    abc bac
    ab ba
    

    样例输出

    bca
    ba


    #include "bits/stdc++.h"
    using namespace std;
    typedef struct tree1
    {
        char data;
        tree1 *leftchild;
        tree1 *rightchild;
    }*Tree1;
    void creattree1(Tree1 &T,string s1,string s2)
    {
        if(s1.length() == 0)
        {
            T = NULL;
            return;
        }
        char roots  = s1[0];
        int position = s2.find(roots);
        string leftstr2 = s2.substr(0,position);
        string rightstr2 = s2.substr(position+1);
    
        int lenleft = leftstr2.length();
        int lenright = rightstr2.length();
    
        string leftstr1 = s1.substr(1,lenleft);
        string rightstr1 = s1.substr(lenleft+1);
    
        T = (Tree1)malloc(sizeof(tree1));
        if(T != NULL)
        {
            T->data = roots;
            creattree1(T->leftchild,leftstr1,leftstr2);
            creattree1(T->rightchild,rightstr1,rightstr2);
        }
    }
    
    void houxubianli(Tree1 &T)
    {
        if(T == NULL)
            return;
        houxubianli(T->leftchild);
        houxubianli(T->rightchild);
        cout << T->data;
    }
    
    int main()
    {
        int n;
        cin >> n;
        while(n--)
        {
            Tree1 T;
            string s1,s2;
            cin >> s1 >> s2;
            creattree1(T,s1,s2);
            houxubianli(T);
            cout <<endl;
        }
        return 0;
    }

    思想是递归,蛮难想的,半抄半写。

    转载于:https://www.cnblogs.com/cunyusup/p/7998531.html

    展开全文
  • 我们知道,中序遍历和前序或者后序能够唯一确定一颗二叉树,因此,给定前序遍历以及中序遍历序列能够确定建立这颗二叉树,然后后序遍历便能够得到相应的序列 代码如下(内含二叉树的建立,求二叉树的高度) #...
  • /* 解题思路 1.根据后序序列最后一个元素建立根节点; 2.在中序序列中找到该元素,确定根节点的左右子树序列; 3.在后序序列中确定左右子树的后序...1 2 3 4 5 6 7 //中序遍历序列 取出后序序列最后一个元素4,将...
  • //由于希望得到一颗二叉树, //所以返回值类型是一个指向根节点的指针 //表示得到了一颗二叉树 BTNode *CreatBT(char pre[],char int[],int L1,int R1,int L2,int R2) //参数列表有传入的先序序列和后序序列和他们...
  • //设 T 是一棵具有 n 个节点的二叉树,若给定二叉树 T 的先序序列和中序序列,并假设 T 的先序序列和中序序列分别放在数组 PreOrder[1..n]和 InOrder[1..n ]中,设计一个构造二叉树 T 的链式存储结构的算法。...
  • 只要清楚了先序中序后序的含义 先序是中左右 中序是左中右 后序是左右中 那么我们只要在递归的: 在先序列里取第一个元素 这个元素就是根元素 然后在中序列里找到根 根的左边(左子树)作为下一次递归的(左)中序列...
  • 这样的题目比较少, 但是据说计算机里就是使用后序遍历的..(忘记哪里说的了), 多做几次. 后序: KBFDCAE, 中序:BKEFACD ------------------------------------------------------------------ 第一轮: 出E---&...
  • 例如,给出 中序遍历 inorder = [9,3,15,20,7] ...//和用前序遍历和中序遍历确定二叉树类似 import java.util.*; class Solution { public TreeNode buildTree(int[] inorder, int[] postorder) { ...
  • 通过前序遍历和中序遍历确定二叉树 Tip:以1为结点的前序遍历是 1 2 4 5 3 6 7 8 中序:4 2 5 1 6 3 8 7 以2为结点的前序: 2 4 5 中序 :4 2 5 以3为结点的前序: 3 6 7 8 中序: 6 3 8 7 以上图为例子: 由前...
  • 根据中序遍历与前序遍历确定二叉树 对于一棵树而言,前序遍历的形式为: [根节点,[左子树的前序遍历],[右子树的前序遍历]]。 中序遍历形式为: [[左子树的中序遍历],根节点,[右子树的中序遍历]] 因此,只要我们...
  • 前序遍历 + 中序遍历 --------------- 可以确定唯一一棵二叉树 后序遍历 + 中序遍历 --------------- 可以确定唯一一颗二叉树 前序遍历 + 中序遍历 --------------- 不能唯一确定 !因为先序后序遍历都是确定根的...
  • 需要知道先序、中序序列的区间 //当前先序序列区间为[preL,preR],中序序列区间为[inL,inR],返回根节点地址 node* create(int preL,int preR,int inL,int inR){ if(preL>preR){ return NULL;//先序序列长度...
  • 前序遍历和后序遍历确定的是根的位置,而中序遍历二叉树的左右子树,所以如果同时有二叉树的前序遍历和后序遍历是不能求出二叉树的。下面给出已知前序遍历和中序遍历二叉树二叉树的方法 前序遍历:a b d e g c
  • 思路:用前序或者后序遍历找根,用中序遍历确定左右树。1.找到根2:在中序遍历当中找到根的位置,此时根的左边是作数右边是右树。 1.根据一棵树的前序遍历与中序遍历构造二叉树。 class Solution { public int ...
  • 假设某二叉树的先序遍历序列是abdgcefh,中序遍历序列是dgbaechf,画出二叉树,并给出其后序遍历序列。 分析过程: 以下面的例题为例进行讲解: 已知一棵二叉树的先序遍历序列和中序遍历序列分别是abdgcefh、...
  • 二叉树遍历的循序 ...只要在中序遍历中找到根结点的位置,就能确定左子树和右子树的结点数目。在先序遍历和中序遍历中分别对左右子树进行定位,递归构造出左子树和右子树,再将这两棵子树连接到根结点上。 首
  • 同根据前序遍历和中序遍历构建二叉树 先确定二叉树 找根结点: 后序的最后一个为根结点1 在中序中找到1 中序中 1前面的对应根结点1的左子树 一共三个结点 在后序中前三个结点4 5 2 为1的左子树后序遍历结果 确定 2 ...
  • 添加链接描述 二叉树的前序、中序、后序遍历的定义: 前序遍历... 给定一棵二叉树的前序遍历和中序遍历,求其后序遍历(提示:给定前序遍历与中序遍历能够唯一确定后序遍历)。 输入描述: 两个字符串,其长度n...
  • 根据一棵树的前序遍历与中序遍历构造二叉树。 思路: 有了前序遍历,首先我们可以知道根节点的值,也就是数组中下标为0的位置,由此创建根节点。 然后在中序遍历中找到根的值所在的下标,切出左右子树的前序和中序。...
  • 下面三种序列可以唯一的构造唯一的一棵...层次遍历序列和中序遍历序列构造二叉树 #include<stdio.h> #include<stdlib.h> #include<string.h> #include<math.h> #define MaxSize 10 typ...
  • 例如,给出: 前序遍历 preorder = [3,9,...//前序遍历和中序遍历可唯一地确定一棵二叉树 //中序遍历和后序遍历可唯一地确定一棵二叉树 import java.util.*; class Solution { public TreeNode buildTree(int[] pre...

空空如也

空空如也

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

中序遍历确定二叉树