• 反转二叉树【Java】


    概述

      所谓的反转二叉树就是把二叉树的左子树变成右子树,把右子树变成左子树。

    思路

      这个我觉得相对于求二叉树的高度或者判断二叉树是不是完全二叉树来说,容易很多。其基本思路就是,只要可以遍历这颗二叉树就可以实现这个反转。

    代码

    二叉树构成代码:

    package com.example.demo.tree;
    
    import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;
    import org.omg.PortableInterceptor.INACTIVE;
    
    import java.util.Comparator;
    
    /**
     * @author steve
     * @date 2020/4/16 10:03 上午
     */
    public class BinaryTree<E> {
    
        private int size;
        public Node<E> root;
        private Comparator<E> comparator;
    
        public BinaryTree(Comparator<E> comparator){
            this.comparator = comparator;
        }
    
        public BinaryTree(){
            this(null);
        }
    
        public void add(E element){
            if (root == null){
                Node node = new Node(element);
                root = node;
            }else {
                Node<E> parent = root;
                Node<E> node = root;
                int com = 0;
                while (node != null){
                    parent = node;
                    if (comparator == null){
                        com = ((Comparable)node.element).compareTo(element);
                    }else {
                        System.out.println("-------------");
                        com = comparator.compare(node.element,element);
                    }
                    if (com > 0){
                        node = node.left;
                    }else if (com < 0){
                        node = node.right;
                    }else {
                        node.element = element;
                        return;
                    }
                }
                Node<E> newNode = new Node(element);
                if (com > 0){
                    parent.left = newNode;
                    newNode.parent = parent.left;
                }else{
                    parent.right = newNode;
                    newNode.parent = parent.right;
                }
            }
            size ++;
        }
        public boolean isEmpty(){
            return size == 0;
        }
        public int size(){
            return size;
        }
    
        public String toString() {
            String d = root == null ? null : root.element + "";
            if (root == null){
                return "root:"+d;
            }else {
                String b = root.left == null ? null : root.left.element + "";
                String c = root.right == null ? null : root.right.element + "";
                return "root:"+d + ", left:" + b + ", right:"+ c;
            }
    
        }
    
    
        public static void main(String[] args) {
            //这种方式就是匿名内部类,通过给一个类传一个接口作为参数,然后这个通过一个匿名内部类是实现这个接口来传入实现。
            BinaryTree<Integer> binaryTree = new BinaryTree<>(new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    return o1 - o2;
                }
            });
    
            BinaryTree<Integer> binaryTree1 = new BinaryTree<>();
            binaryTree1.add(1);
            binaryTree1.add(2);
            binaryTree1.add(0);
            System.out.println(binaryTree1.size());
            System.out.println(binaryTree.toString());
        }
    }
    View Code

    节点代码

    package com.example.demo.tree;
    
    /**
     * @author steve
     * @date 2020/4/18 3:16 下午
     */
    public class Node<E> {
        public Node<E> left;
        public Node<E> right;
        public Node<E> parent;
        public E element;
        public Node(E element){
            this.element = element;
        }
    }
    View Code

    反转二叉树代码

    package com.example.demo.tree;
    
    import java.util.LinkedList;
    import java.util.Queue;
    
    /**
     * @author steve
     * @date 2020/4/20 9:28 下午
     * 反转二叉树
     */
    public class ReverseBinaryTree {
    
        /**
         * 反转二叉树
         * 这里采用层序遍历的方式来反转,其实采用哪一种遍历方式都可以,但是要通过迭代的方式,不通过递归的方式不好实现
         * @param node
         */
        public static void reverseBinaryTree(Node<Integer> node){
            Queue<Node<Integer>> queue = new LinkedList<>();
            queue.add(node);
    
            Node<Integer> tempNode = null;
            while(!queue.isEmpty()){
                //这里要注意从队列中拿出来的其实就是二叉树中的节点,并不是新生成的节点,所以每次拿出一个节点都把这个节点的左右
                //孩子进行反转,那当一颗二叉树遍历完之后所有的节点都会反转
                Node<Integer> node1 = queue.poll();
                System.out.println(node1.element);
                tempNode = node1.left;
                node1.left = node1.right;
                node1.right = tempNode;
    
                if (node1.left != null){
                    queue.add(node1.left);
                }
                if (node1.right != null){
                    queue.add(node1.right);
                }
            }
        }
    
        public static void main(String[] args) {
            BinaryTree<Integer> binaryTree = new BinaryTree();
            binaryTree.add(7);
            binaryTree.add(4);
            binaryTree.add(10);
            binaryTree.add(9);
            binaryTree.add(11);
            binaryTree.add(5);
            binaryTree.add(3);
            binaryTree.add(1);
            binaryTree.add(0);
            reverseBinaryTree(binaryTree.root);
        }
    
    }
  • 相关阅读:
    Show me the Template
    WPF中的Style(风格,样式)
    像苹果工具条一样平滑连续地缩放
    为窗体添加 "最大化","最小化","还原"等 事件
    [CHM]果壳中的XAML(XAML in a Nutshell)
    我的简约播放器
    很好玩的滚动效果
    项目经验分享(上)
    通过mongodb客户端samus代码研究解决问题
    记录数据库执行情况来分析数据库查询性能问题
  • 原文地址:https://www.cnblogs.com/gunduzi/p/12740984.html
Copyright © 2020-2023  润新知