精华内容
下载资源
问答
  • Java根据前序、中序遍历创建二叉树...(包括前序、中序、后序遍历代码实现) import java.util.Scanner; class TreeNode {//树节点 int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } }...
    • Java根据前序、中序遍历创建二叉树

    • 根据中序、后序遍历创建二叉树代码实现

    • (包括前序、中序、后序遍历代码实现)

    import java.util.Scanner;
    
    class TreeNode {//树节点
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode(int x) { val = x; }
    }
    
    public class Test{
    	public static void main(String[] args) {
    		Scanner scanner = new Scanner(System.in);
    		int[] DLR = new int[] {4, 2, 6, 3, 1, 5};//前序
    		int[] LDR = new int[] {6, 2, 3, 4, 1, 5};//中序
    		int[] LRD = new int[] {6, 3, 2, 5, 1, 4};//后序
    		TreeNode root;
    		root = reConstructBinaryTreeByPI(DLR, LDR);//前中建二叉树
    		LRD(root);//后序
    		System.out.println();
    		LDR(root);//中序
    		System.out.println();
    		root = reConstructBinaryTreeByIO(LRD, LDR);//中后建二叉树
    		DLR(root);//前序
    		System.out.println();
    		LDR(root);//中序
    		System.out.println();
    	}	
    	
    	public static TreeNode reConstructBinaryTreeByPI(int [] pre,int [] in) {//前中序创建二叉树
            TreeNode root = reConstructBinaryTreeByPI(pre, 0, pre.length-1, in, 0, in.length-1);
            return root;
    	}
    	
    	public static TreeNode reConstructBinaryTreeByPI(int[] pre, int startPre, int endPre, int[] in, int startIn, int endIn){//pre是前序遍历,in是中序遍历
            if(startPre > endPre || startIn > endIn){
                return null;
            }
            // 根据前序遍历结果,创建根节点
            TreeNode root  = new TreeNode(pre[startPre]);
            // 在中序遍历的结果中找到根节点,找到其左右结点
            //【4】 2 6 3 1 5 - 前
            //6 2 3 【4】 1 5 - 中
            //6 3 2 5 1 【4】 - 后
            for(int i = startIn; i <= endIn; i++){
                if(in[i] == pre[startPre]){
                    root.left = reConstructBinaryTreeByPI(pre, startPre+1, startPre + (i - startIn), in, startIn, i-1); //左孩子是中序遍历根节点左子树的根节点
                    root.right = reConstructBinaryTreeByPI(pre, startPre + (i-startIn) + 1, endPre, in, i+1, endIn);//右孩子是中序遍历根节点右子树的根节点
                }
            }
            return root;
        }
    	
    	public static TreeNode reConstructBinaryTreeByIO(int [] out,int [] in) {//中后序创建二叉树
            TreeNode root = reConstructBinaryTreeByIO(out, 0, out.length-1, in, 0, in.length-1);
            return root;
    	}
    	
    	public static TreeNode reConstructBinaryTreeByIO(int[] out, int startOut, int endOut, int[] in, int startIn, int endIn){//out是后序遍历,in是中序遍历
            if(startOut > endOut || startIn > endIn){
                return null;
            }
            // 根据后序遍历结果,创建根节点
            TreeNode root  = new TreeNode(out[endOut]);
            // 在中序遍历的结果中找到根节点,找到其左右结点
            //6 3 2 5 1 【4】 - 后
            //6 2 3 【4】 1 5 - 中
            //【4】 2 6 3 1 5 - 前
            for(int i = startIn; i <= endIn; i++){
                if(in[i] == out[endOut]){
                    root.left = reConstructBinaryTreeByIO(out, startOut, endOut - (endIn - i) - 1, in, startIn, i-1); //左孩子是中序遍历根节点左子树的根节点
                    root.right = reConstructBinaryTreeByIO(out, endOut - (endIn - i), endOut - 1, in, i + 1, endIn);//右孩子是中序遍历根节点右子树的根节点
                }
            }
            return root;
        }
    	
    	public static void LRD(TreeNode head) {//后序遍历
    		if(head.left != null) LRD(head.left);
    		if(head.right != null) LRD(head.right);
    		System.out.print(head.val);
    	}
    	public static void LDR(TreeNode head) {//中序遍历
    		if(head.left != null) LDR(head.left);
    		System.out.print(head.val);
    		if(head.right != null) LDR(head.right);
    		
    	}
    	public static void DLR(TreeNode head) {//前序遍历
    		System.out.print(head.val);
    		if(head.left != null) DLR(head.left);
    		if(head.right != null) DLR(head.right);
    	}
    }
    
    展开全文
  • 数据结构之二叉树的前、中、后序遍历代码初试 package cn.ycl.dataStructures.BinaryTree; public class BinaryTreeDemo { public static void main(String[] args) { //先手动创建一颗二叉树 , 以后用递归创建 ...

    数据结构之二叉树的前、中、后序遍历代码初试

    package cn.ycl.dataStructures.BinaryTree;
    public class BinaryTreeDemo {
    	public static void main(String[] args) {
    		//先手动创建一颗二叉树 , 以后用递归创建
    		BinaryTree binaryTree = new BinaryTree();
    		heroNode root=new heroNode( 1 , "宋江" );
    		heroNode node2=new heroNode( 2 , "吴用" );
    		heroNode node3=new heroNode( 3 , "卢俊义" );
    		heroNode node4=new heroNode( 4 , "林冲" );
    		
    		root.setLeft(node2);
    		root.setRight(node3);
    		node3.setRight(node4);
    		binaryTree.setRoot(root);
    		
    		//测试前序遍历
    		System.out.println("前序遍历--》");
    		binaryTree.preList();
    		//测试中序遍历
    		System.out.println("中序遍历--》");
    		binaryTree.midList();
    		//测试后序遍历
    		System.out.println("后序遍历--》");
    		binaryTree.afterList();
    	}
    }
    //创建树
    class BinaryTree{
    	private heroNode root;
    	public heroNode getRoot() {
    		return root;
    	}
    	public void setRoot(heroNode root) {
    		this.root = root;
    	}
    	
    	//前序遍历
    	public void preList() {
    		if (this.root !=null) {//先判断不是空树
    			//头结点开始调用前序遍历
    			this.root .DLRList();
    		}else {
    			System.out.println("当前树是空树。。。。");
    		}
    	}
    	//中序遍历
    	public void  midList() {
    		if (this.root !=null) {//先判断不是空树
    			//头结点开始调用前序遍历
    			this.root .LDRList();
    		}else {
    			System.out.println("当前树是空树。。。。");
    		}
    	}
    	//后序遍历
    	public void afterList() {
    		if (this.root !=null) {//先判断不是空树
    			//头结点开始调用前序遍历
    			this.root .LRDList();
    		}else {
    			System.out.println("当前树是空树。。。。");
    		}
    	}
    }
    
    
    //创建结点,每个结点为一个heroNode。
    class heroNode {
    	private int no;
    	private String name;
    	private heroNode left;
    	private heroNode right;
    	public heroNode() {
    		super();
    	}
    	public heroNode(int no, String name) {
    		super();
    		this.no = no;
    		this.name = name;
    	}
    	public heroNode getLeft() {
    		return left;
    	}
    	public void setLeft(heroNode left) {
    		this.left = left;
    	}
    	public heroNode getRight() {
    		return right;
    	}
    	public void setRight(heroNode right) {
    		this.right = right;
    	}
    	public int getNo() {
    		return no;
    	}
    	public void setNo(int no) {
    		this.no = no;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	@Override
    	public String toString() {
    		return "heroNode [no=" + no + ", name=" + name + "]";
    	}
    	// 前序遍历,D代表根结点,L代表左结点,R代表右节点,前序遍历的顺序就是D-->L -->R
    	public void DLRList() {
    		//先输出当前结点
    		System.out.println(this);
    	
    		if (this.left != null) {// 如果当前结点的左结点不为空
    			this.left.DLRList();
    		}
    		if (this.right != null) {// 如果当前结点的右节点不为空
               this.right.DLRList();
    		}
    	}
    	//中序遍历
    	public void LDRList() {
    //递归向左子树前序遍历
    		if (this.left !=null) {
    			this.left.LDRList();
    		}
    		//跳出了上面的循环表示this.left=null,当前的结点是叶子结点,是最左边的一个叶子结点了
    		//输出当前结点
    		System.out.println(this);
    		
    		//上面输出后,就需要遍历查找右子树了,其顺序是先将右子树的左子树先遍历,再找右子树的右子树,层层遍历,及其费脑,最后将最右边的叶子结点输出就结束递归了
    		if (this .right!=null) {
    			this.right.LDRList();
    		}
    	}
    	//后序遍历
    public void LRDList() {
    	//先循环遍历左子树
    	if (this.left !=null) {
    		this.left.LRDList();
    	}
    	//跳出了上面的循环表示this.left=null,当前的结点是叶子结点,是最左边的一个叶子结点了
    	if (this.right !=null) {
    		this.right.LRDList();
    	}
    	//又跳出了上面的循环表示此时右边也递归完了
    	//现在可以输出当前结点了
    	System.out.println(this);
    }
    }
    

    结果如图所示
    在这里插入图片描述

    展开全文
  • #include <stdio.h> #include <stdlib.h> typedef struct Node { int data; struct Node *lchild, *rchild; }Node; Node* init(int data) { Node *node = (Node *)malloc(sizeof(Node));...
    #include <stdio.h>
    #include <stdlib.h>
    
    typedef struct Node {
        int data;
        struct Node *lchild, *rchild;
    }Node;
    
    Node* init(int data) {
        Node *node = (Node *)malloc(sizeof(Node));
        node->data = data;
        node->lchild = NULL;
        node->rchild = NULL;
        return node;
    }
    
    void preorder(Node *node) {
        printf("%d ", node->data);
        if (node->lchild != NULL) {
            preorder(node->lchild);
        }
        if (node->rchild != NULL) {
            preorder(node->rchild);
        }
    }
    
    void inorder(Node *node) {
        if (node->lchild != NULL) {
            inorder(node->lchild);
        }
        printf("%d ", node->data);
        if (node->rchild != NULL) {
            inorder(node->rchild);
        }
        
    }
    
    void postorder(Node *node) {
        if (node->lchild != NULL) {
            postorder(node->lchild);
        }
        if (node->rchild != NULL) {
            postorder(node->rchild);
        }
        printf("%d ", node->data);
    }
    
    Node* build_demo() {
        Node *node = init(4);
        node->lchild = init(2);
        node->rchild = init(6);
        node->lchild->lchild = init(1);
        node->lchild->rchild = init(3);
        node->rchild->lchild = init(5);
        node->rchild->rchild = init(7);
        return node;
    }
    
    void clear(Node *node) {
        if (node->lchild != NULL) {
            clear(node->lchild);
        }
        if (node->rchild != NULL) {
            clear(node->rchild);
        }
        free(node);
    }
    
    int main() {
        Node *root = build_demo();
        preorder(root);
        printf("\n");
        inorder(root);
        printf("\n");
        postorder(root);
        printf("\n");
        return 0;
    }
    
    展开全文
  • 用C语言实现数据结构中二叉树的前序中序后序遍历 int main()//主函数部分 { BiTree T=NULL; int Layer=0; int LayerT=0; printf("请输入二叉树:\n"); CreatBiTree(&T);printf("你输入的二叉树为:(竖型树状...
  • class Solution { public: vector<int> postorderTraversal(TreeNode* root) { vector<int> vec; travel(root, vec); ... //后序遍历 void travel(TreeNode* root, vec...
    class Solution {
    public:
    	vector<int> postorderTraversal(TreeNode* root) {
    		vector<int> vec;
    		travel(root, vec);
    		return vec;
    	}
           //后序遍历
    	void travel(TreeNode* root, vector<int>& v)
    	{
    		if (root == NULL)return;
    		travel(root->left,v);
    		travel(root->right, v);
    		v.push_back(root->val); 
    	}
           //前序遍历
    	void pretravel(TreeNode* root, vector<int>& v)
    	{
    		if (root == NULL)return;
    		travel(root->left,v);
    		travel(root->right, v);
    		v.push_back(root->val); 
    	}        
           //中序遍历
    	void midtravel(TreeNode* root, vector<int>& v)
    	{
    		if (root == NULL)return;
    		travel(root->left,v);
    		v.push_back(root->val); 
    		travel(root->right, v);
    	}     
    };
    

      

    转载于:https://www.cnblogs.com/creativityroom/p/6807141.html

    展开全文
  • 二叉树前中后序遍历代码实现

    千次阅读 2015-01-10 21:36:23
    二叉树的递归遍历实现起来比较简单,而且代码简洁;而非递归遍历则不那么简单,我们需要借助另一种数据结构---栈...三种非递归遍历中,前序和中序都不是太复杂,而后序遍历则相对较难。 一、前序遍历  
  • 前序遍历——迭代 public static void preOrder(TreeNode node){ if(node==null) return; System.out.println(node.getData()+" "); preOrder(node.left); preOrder(node.right); } 中序遍历——...
  • 前序遍历/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */ public class Solution
  • 145. 二叉树的后序遍历题目解题思路代码 题目 给定一个二叉树,返回它的 后序 遍历。 解题思路 简单,后序遍历 代码 class Solution { List<Integer> list=new ArrayList<>(); public List<...
  • 前序遍历 利用栈的后进先出性质 class Solution { public: vector<int> preorderTraversal(TreeNode* root) { stack<TreeNode*> st; vector<int> result; if (root == NULL) return result; ...
  • C中二叉排序树的非递归和递归插入操作以及中序遍历代码实现【可运行】 #include <stdio.h> #include <stdlib.h> typedef int KeyType; typedef struct node { KeyType key; struct node* lchild, * ...
  • 后序遍历 代码 package com.li.traversal; import java.util.Stack; public class LRD { public static void main(String[] args) { TreeNode[] nodes = new TreeNode[10]; for(int i=0;i<10;...
  • 按要求输入二叉树,然后执行可输出先序 中序 后序遍历二叉树的结果。
  • 后序遍历代码如下: if(!root)return; stack<Node *> s; s.push(root); char flat='o'; //三异性标志位 bool lr[100]; // 1表示左子树,0 表示右子树 int i=0; lr[i]=false; //其实第一个代表根...
  • 二叉树的前序、中序、后序遍历的定义:  前序遍历:对任一子树,先访问根,然后遍历其左子树,最后遍历其右子树;  中序遍历:对任一子树,先遍历其左子树,然后访问根,最后遍历其右子树;  后序遍历:对任一...
  • 二叉树遍历主要有三种,分为前序遍历,中序遍历,后序遍历。 先序遍历: (1)先访问跟节点 (2)再先序访问左子树(递归) (3)再先序访问右子树(递归)中序遍历: (1)中序遍历左子树 (2)再访问根节点 (3)再...
  • 解题思路递归在后序遍历中,它的最后一个节点是根节点。根据根节点在中序遍历中的位置,我们可以定位到它的左边是左子树,右边是右子树。通过递归,根据左子树的后序和中序遍历,以及右子树的后序和中序遍历,不断...
  • 前序遍历是后序遍历的准镜像算法。无论是从递归的角度看,还是迭代的角度看。都是!我们怎么定义准镜像算法?就是通过微调原来前序遍历的定义后,再进行镜像操作。 //看一下如下代码框架: //递归前后序遍历 // ...
  • 主要讲解前序遍历、中序遍历、后序遍历的Java代码实现。 正文: 对下图所示二叉树为测试对象: 二叉树基于如下的数据结构: public class TreeNode{ int val; TreeNode left; TreeNode right; public TreeNode...
  • 根据树的前序遍历和中序遍历构造树并输出后序遍历代码如下: <?php class BinaryTreeNode{ public $m_value; public $m_left; public $m_right; } function ConstructCore($preorder,$inorder){ if(count($...
  • 输入一个整数数组,判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则返回true。否则返回false。假设输入的数组的任意两个数字都互不相同。 二、解题思路 在后序遍历得到的序列中, 最后一个数字是树的根结点...
  • LeetCode 题目中,二叉树的遍历方式是最基本,也是最重要的一类题目,我们将从「前序」、... 二叉树的后序遍历 4. 102. 二叉树的层序遍历二叉树及遍历方式要解决这四道题目,最基本的前提是要了解什么是二叉树,以及...
  • 二叉树的非递归前、中、后序遍历算法详解及代码实现(C语言) 1. 前序遍历和中序遍历非递归算法思路 前序和中序非递归遍历的C代码 2. 后序遍历非递归算法思路 后序非递归遍历的C代码 1. 前序遍历和中序遍历非...
  • LeetCode 题目中,二叉树的遍历方式是最基本,也是最重要的一类题目,我们将从「前序」、... 二叉树的后序遍历 4. 102. 二叉树的层序遍历二叉树及遍历方式要解决这四道题目,最基本的前提是要了解什么是二叉树,以及...

空空如也

空空如也

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

后序遍历代码