遍历二叉树

遍历二叉树

目录

• 遍历二叉树
  • 1、创建二叉树
  • 2、前序遍历
  • 3、中序遍历
  • 4、后序遍历
  • 5、力扣真题

二叉树遍历：顺着一条搜索路径访问二叉树中的节点，每个节点均被访问一次，且只被访问一次。

遍历目的：得到树中所有节点的一个线性排列。

遍历用途：是二叉树元素增删改查等操作的前提。

1、创建二叉树

方法一：

class TreeNode {
    int value;      //数据域
    TreeNode left;  //指针域（左子节点）
    TreeNode right; //指针域（右子节点）
    //实例化
    public TreeNode(int value) {
        this.value = value;
        this.left = null;
        this.right = null;
    }
}
public class BinaryTree {
    static void main(String[] args) {
        System.out.println("1.手动创建二叉树");
        //             10
        //            /   \
        //          20      30
        //         /       /   \
        //       40     50      60
        TreeNode root = new TreeNode(10);//创建根节点
        root.left = new TreeNode(20);//创建左子节点
        root.right = new TreeNode(30);//创建右子节点
        root.left.left = new TreeNode(40);
        root.right.left = new TreeNode(50);
        root.right.right = new TreeNode(60);
        System.out.println("2.修改二叉树结点的值：");
        //             10
        //            /   \
        //          20      30
        //         /       /   \
        //       40      80      60
        root.right.left.value = 80;
        System.out.println("3.删除二叉树结点：");
        root.left.left = null;
        System.out.println();
    }
}

方法二：

public class BinaryTreeTraversal {

    public static void main(String[] args) {

    TreeNode a = new TreeNode( data: "A" );
    TreeNode b = new TreeNode( data: "B" );
    TreeNode c = new TreeNode( data: "C" );
    TreeNode d = new TreeNode( data: "D" );

    TreeNode e = new TreeNode( data: "E" );
    TreeNode f = new TreeNode( data: "F" );
    TreeNode g = new TreeNode( data: "G" );
    TreeNode h = new TreeNode( data: "H" );

    a.setLeft( b );
    a.setRight( c );

    b.setLeft( d );
    b.setRight( e );

    c.setLeft( f );
    c.setRight( g );

    d.setLeft( h );
  }
}

2、前序遍历

package com.test;

class TreeNode {
    int value;      //数据域
    TreeNode left;  //指针域（左子节点）
    TreeNode right; //指针域（右子节点）
    //实例化
    public TreeNode(int value) {
        this.value = value;
        this.left = null;
        this.right = null;
    }
}
public class BinaryTree {
    //前序遍历
    public static void preOrder(TreeNode root) {
        if(root == null){
            return;
        }
        System.out.println(root.value);
        //递归遍历
        preOrder(root.left);
        preOrder(root.right);
    }
    static void main(String[] args) {
        System.out.println("1.手动创建二叉树");
        //             10
        //            /   \
        //          20      30
        //         /       /   \
        //       40     50      60
        TreeNode root = new TreeNode(10);//创建根节点
        root.left = new TreeNode(20);//创建左子节点
        root.right = new TreeNode(30);//创建右子节点
        root.left.left = new TreeNode(40);
        root.right.left = new TreeNode(50);
        root.right.right = new TreeNode(60);
        System.out.println();
        System.out.println("前序遍历：");
        preOrder(root);   // 10 20 40 30 50 60
        System.out.println();
    }
}

3、中序遍历

class TreeNode {
    int value;      //数据域
    TreeNode left;  //指针域（左子节点）
    TreeNode right; //指针域（右子节点）
    //实例化
    public TreeNode(int value) {
        this.value = value;
        this.left = null;
        this.right = null;
    }
}
public class BinaryTree {
    //中序遍历
    public static void inOrder(TreeNode root) {
        if(root == null){
            return;
        }
        inOrder(root.left);
        System.out.println(root.value);
        inOrder(root.right);
    }
    static void main(String[] args) {
        System.out.println("1.手动创建二叉树");
        //             10
        //            /   \
        //          20      30
        //         /       /   \
        //       40     50      60
        TreeNode root = new TreeNode(10);//创建根节点
        root.left = new TreeNode(20);//创建左子节点
        root.right = new TreeNode(30);//创建右子节点
        root.left.left = new TreeNode(40);
        root.right.left = new TreeNode(50);
        root.right.right = new TreeNode(60);
        System.out.println();
        System.out.println("中序遍历：");
        inOrder(root);//40 20 10 50 30 60
        System.out.println();
    }
}

4、后序遍历

class TreeNode {
    int value;      //数据域
    TreeNode left;  //指针域（左子节点）
    TreeNode right; //指针域（右子节点）
    //实例化
    public TreeNode(int value) {
        this.value = value;
        this.left = null;
        this.right = null;
    }
}
public class BinaryTree {
    //后序遍历
    public static void postOrder(TreeNode root) {
        if(root == null){
            return;
        }
        postOrder(root.left);
        postOrder(root.right);
        System.out.println(root.value);
    }
    static void main(String[] args) {
        System.out.println("1.手动创建二叉树");
        //             10
        //            /   \
        //          20      30
        //         /       /   \
        //       40     50      60
        TreeNode root = new TreeNode(10);//创建根节点
        root.left = new TreeNode(20);//创建左子节点
        root.right = new TreeNode(30);//创建右子节点
        root.left.left = new TreeNode(40);
        root.right.left = new TreeNode(50);
        root.right.right = new TreeNode(60);
        System.out.println();
        System.out.println("后序遍历：");
        postOrder(root);//40 20 50 60 30 10
        System.out.println();
    }
}

5、力扣真题

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
       if(p == null && q == null ) return true;
       if(p == null || q == null || p.val != q.val ) return false;
       return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
    }
}

参考博客：https://blog.csdn.net/lquarius/article/details/109528051