• 反转二叉树【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);
        }
    
    }
  • 相关阅读:
    设计模式---对象创建模式之抽象工厂模式(Abstract Factory)
    设计模式---对象创建模式之工厂方法模式(Factory Method)
    设计模式---单一职责模式之桥模式(Bridge)
    设计模式---单一职责模式之装饰模式(Decorator)
    设计模式---组件协作模式之观察者模式(Observer)
    设计模式---组件协作模式之策略模式(Strategy)
    设计模式---组件协作模式之模板方法模式(Tempalte Method)
    设计模式---设计模式的分类
    考勤相关资料
    HR-人力资源管理系统(Human Resources Management System,HRMS)
  • 原文地址:https://www.cnblogs.com/gunduzi/p/12740984.html
Copyright © 2020-2023  润新知