数据结构和算法——旋转二叉树

package com.demo.calculate;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;

import com.demo.calculate.bean.BinaryTree;
import com.demo.calculate.bean.TreeNode;

/**
 * @author xjz
 */
public class BinarySortATreectivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_binary_sort_tree);
        findViewById(R.id.btn_binarySortTree).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                createTree();
            }
        });
    }

    private void createTree() {
        BinaryTree binaryTree = new BinaryTree();
        int[] arr = new int[]{1,2,3,4,5,6,7,8};
        for (int i = 0; i < arr.length; i++) {
            binaryTree.add(new TreeNode(arr[i]));
        }
        binaryTree.midShow();
        binaryTree.rightRotate();
        binaryTree.midShow();
        binaryTree.boubleRatate();

    }
}

package com.demo.calculate.bean;

public class BinaryTree {
    private int value;
    private TreeNode root;
    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public TreeNode getRoot() {
        return root;
    }

    public void setRoot(TreeNode root) {
        this.root = root;
    }

    public void frontShow() {
        if (root!=null){
            root.frontShow();
        }
    }

    public void midShow() {
        if (root!=null){
            root.midShow();
        }

    }

    public void afterShow() {
        if (root!=null){
            root.afterShow();
        }
    }

    public TreeNode frontSearch(int i) {
        if (root!=null){
            return root.frontSearch(i);
        }
        return  null;
    }

    public void deleteNode(int i) {
        if (root!=null){
            root.deleteNode(i);
        }
    }
    public void add(TreeNode node){
        if (root == null){
            root = node;
        }else{
            root.add(node);
        }
    }


    public int height() {
        if (root == null){
            return 0;
        }
        return root.height();
    }

    public void rightRotate() {
        if (root == null){
            return;
        }
        root.rightRotate();
    }

    public void boubleRatate() {
        if (root == null){
            return;
        }
        root.doubleRotate();
    }
}

package com.demo.calculate.bean;

import android.support.annotation.NonNull;
import android.util.Log;

/**
 * @author xjz
 */
public class TreeNode implements Comparable<TreeNode> {
    private int value;
    private TreeNode nodeLeft;
    private TreeNode nodeRight;

    public void setNodeLeft(TreeNode nodeLeft) {
        this.nodeLeft = nodeLeft;
    }

    public void setNodeRight(TreeNode nodeRight) {
        this.nodeRight = nodeRight;
    }

    public TreeNode(int value) {
        this.value = value;
    }

    public void frontShow() {
        Log.i("tag", value + "");
        if (nodeLeft != null) {
            nodeLeft.frontShow();
        }
        if (nodeRight != null) {
            nodeRight.frontShow();
        }
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public void midShow() {
        /**
         * 4  2  5  1  6  3 7
         * 1 根据点是1  左节点是2  右节点是3  midShow();
         * 2 根据点是2  左节点是4  右节点是5  midShow();
         */
        if (nodeLeft != null) {
            nodeLeft.midShow();
        }
        Log.i("tag", value + "");
        //根节点是2 第一次的时候value是4
        if (nodeRight != null) {
            nodeRight.midShow();
        }
    }

    public void afterShow() {
        if (nodeLeft != null) {
            nodeLeft.afterShow();
        }
        if (nodeRight != null) {
            nodeRight.afterShow();
        }
        Log.i("tag", value + "");
    }

    //前序查找
    public TreeNode frontSearch(int i) {
        TreeNode target = null;
        if (this.value == i) {
            return this;
        } else {
            if (nodeLeft != null) {
                target = nodeLeft.frontSearch(i);
            }
            if (target != null) {
                return target;
            }
            if (nodeRight != null) {
                target = nodeRight.frontSearch(i);
            }
        }
        return target;
    }

    public void deleteNode(int i) {
        TreeNode parent = this;
        if (this.value == i) {
            parent = null;
        }
        //判断左儿子
        if (parent != null && parent.nodeLeft != null && parent.nodeLeft.value == i) {
            parent.nodeLeft = null;
            return;
        }
        //判断右儿子
        if (parent != null && parent.nodeRight != null && parent.nodeRight.value == i) {
            parent.nodeRight = null;
            return;
        }
        //递归删除左面的儿子
        parent = nodeLeft;
        if (parent != null) {
            parent.deleteNode(i);
        }
        //递归删除右面的儿子
        parent = nodeRight;
        if (parent != null) {
            parent.deleteNode(i);
        }
    }

    @Override
    public int compareTo(@NonNull TreeNode o) {
        return value - o.value;
    }

    public void add(TreeNode node) {
        if (node == null) {
            return;
        }
        //判断要插入的节点的值是不是比当前节点的值小，小的话就作为左子节点
        if (node.value < value) {
            if (nodeLeft == null) {
                nodeLeft = node;
            } else {
                nodeLeft.add(node);
            }
            //判断要插入的节点的值是不是比当前节点的值大，小的话就作为右子节点
        } else {
            if (nodeRight == null) {
                nodeRight = node;
            } else {
                nodeRight.add(node);
            }
        }
    }

    public int height() {
        return Math.max(getLeftHeight(), getRightHeight()) + 1;
    }

    /**
     * 获取左子数的高度
     */
    public int getLeftHeight() {
        if (nodeLeft == null) {
            return 0;
        }
        return nodeLeft.height();
    }

    /**
     * 获取右子数的高度
     *
     * @return
     */
    public int getRightHeight() {
        if (nodeRight == null) {
            return 0;
        }
        return nodeRight.height();
    }
    /**
     * 二叉树的右旋转
     */
    public void rightRotate() {
       //创建一个新的节点
        TreeNode newRight = new TreeNode(value);
        //把当前节点的右子树设置为新节点的右子树
        newRight.nodeRight = nodeRight;
       //把当前节点的左子树的右子树设置为新节点的左子树
        newRight.nodeLeft = nodeLeft.nodeRight;
        //把当前节点的值设置为左子树的值
        value = nodeLeft.value;
        //把当前节点的左子树设置为左子树的左子树
        nodeLeft = nodeLeft.nodeLeft;
        //把新节点设置为当前节点的右子树
        nodeRight = newRight;

    }
    /**
     * 二叉树的左旋转旋转
     */
    public void leftRotate() {
        TreeNode newLeft = new TreeNode(value);
        newLeft.nodeLeft = nodeLeft;
        newLeft.nodeRight = nodeRight.nodeLeft;
        value = nodeRight.value;
        nodeRight = nodeRight.nodeRight;
        nodeLeft = newLeft;
    }

    /**
     * 二叉树的双向旋转
     */
    public void doubleRotate(){
        //进行右旋转
        if (getLeftHeight()-getRightHeight()>=2){
            //判断左子树是不是首先需要左旋转
            if (nodeLeft!=null && nodeLeft.getRightHeight()-nodeLeft.getLeftHeight()>=2){
                nodeLeft.leftRotate();
                rightRotate();
            }else{
                rightRotate();
            }
        }
        //进行左旋转
        if (getRightHeight()-getLeftHeight()>=2){
            //判断左子树是不是首先需要左旋转
            if (nodeRight!=null && nodeRight.getRightHeight()-nodeRight.getLeftHeight()>=2){
                nodeRight.rightRotate();
                leftRotate();
            }else{
                leftRotate();
            }
        }
    }
}