Java数据结构--二叉树

Java数据结构–二叉树

二叉树类

package 二叉树;

import 队列.MyQueue;

public class BinaryTree<Key extends Comparable<Key>, Value> {
    private class Node {
        private Key key;
        private Value value;
        private Node left;
        private Node right;

        public Node(Key key, Value value, Node left, Node right) {
            this.key = key;
            this.value = value;
            this.left = left;
            this.right = right;
        }
    }

    private Node root;
    private int counts;

    public BinaryTree() {
        root = null;
        counts = 0;
    }

    public void put(Key key, Value value) {
        root = put(root, key, value);
    }

    public Node put(Node x, Key key, Value value) {
        if (x == null) {
            counts++;
            return new Node(key, value, null, null);
        }
        int cmp = key.compareTo(x.key);
        if (cmp > 0) {
            x.right = put(x.right, key, value);
        } else if (cmp < 0) {
            x.left = put(x.left, key, value);
        } else {
            x.value = value;
        }
        return x;
    }

    public Value get(Key key) {
        return get(root, key);
    }

    private Value get(Node x, Key key) {
        if (x == null) {
            return null;
        }
        int cmp = key.compareTo(x.key);
        if (cmp > 0) {
            return get(x.right, key);
        } else if (cmp < 0) {
            return get(x.left, key);
        } else {
            return x.value;
        }
    }

    public void delete(Key key) {
        delete(root, key);
    }

    public Node delete(Node x, Key key) {
        if (x == null) {
            return null;
        }
        int cmp = key.compareTo(x.key);
        if (cmp > 0) {
            x.right = delete(x.right, key);
        } else if (cmp < 0) {
            x.left = delete(x.left, key);
        } else {
            counts--;
            if (x.right == null) {
                return x.left;
            } else if (x.left == null) {
                return x.right;
            }
            Node minNode = x.right;
            while (minNode.left != null) {
                minNode = minNode.left;
            }
            Node deleteNode = x.right;
            while (deleteNode.left != null) {
                if (deleteNode.left.left == null) {
                    deleteNode.left = null;
                } else {
                    deleteNode = deleteNode.left;
                }
            }
            minNode.left = x.left;
            minNode.right = x.right;
            x = minNode;

        }
        return x;
    }

    public Key min() {
        return min(root).key;
    }

    public Node min(Node x) {
        if (x.left != null) {
            return min(x.left);
        } else {
            return x;
        }
    }

    public Key max() {
        return max(root).key;
    }

    public Node max(Node x) {
        if (x.right != null) {
            return max(x.right);
        } else {
            return x;
        }
    }

    /**
     * 前序遍历获取整个树的所有键
     *
     * @return
     */
    public MyQueue<Key> preEgodic() {
        MyQueue<Key> keys = new MyQueue<>();
        preErgodic(root, keys);
        return keys;
    }

    /**
     * 在指定的树x当中的所有键，并放到keys的队列中
     *
     * @param x
     */
    public void preErgodic(Node x, MyQueue<Key> keys) {
        if (x == null) {
            return;
        }
        keys.enqueue(x.key);
        if (x.left != null)
            preErgodic(x.left, keys);
        if (x.right != null)
            preErgodic(x.right, keys);
    }

    /**
     * 中序遍历获取整个树的所有键
     *
     * @return
     */
    public MyQueue<Key> ordEgodic() {
        MyQueue<Key> keys = new MyQueue<>();
        ordErgodic(root, keys);
        return keys;
    }

    /**
     * 在指定的树x当中的所有键，并放到keys的队列中
     *
     * @param x
     */
    public void ordErgodic(Node x, MyQueue<Key> keys) {
        if (x == null) {
            return;
        }
        if (x.left != null)
            preErgodic(x.left, keys);
        keys.enqueue(x.key);
        if (x.right != null)
            preErgodic(x.right, keys);
    }

    /**
     * 后序遍历获取整个树的所有键
     *
     * @return
     */
    public MyQueue<Key> postEgodic() {
        MyQueue<Key> keys = new MyQueue<>();
        postEgodic(root, keys);
        return keys;
    }

    /**
     * 在指定的树x当中的所有键，并放到keys的队列中
     *
     * @param x
     */
    public void postEgodic(Node x, MyQueue<Key> keys) {
        if (x == null) {
            return;
        }
        if (x.left != null)
            preErgodic(x.left, keys);
        if (x.right != null)
            preErgodic(x.right, keys);
        keys.enqueue(x.key);
    }

    /**
     * 层序遍历
     * @return
     */
    public MyQueue<Key> layerEgodic(){
        MyQueue<Key> keys = new MyQueue<>();
        MyQueue<Node> nodes = new MyQueue<>();
        nodes.enqueue(root);
        while(!nodes.isEmpty()){
            Node delNode=nodes.dequeue();
            keys.enqueue(delNode.key);
            if(delNode.left!=null){
                nodes.enqueue(delNode.left);
            }
            if(delNode.right!=null){
                nodes.enqueue(delNode.right);
            }
        }
        return keys;
    }

    public int MaxDepth(){
        return MaxDepth(root);
    }

    public int MaxDepth(Node x){
        if(x==null){
            return 0;
        }
        int max=0;
        int maxl=0;
        int maxr=0;
        //计算x结点左子树的最大深度
        if(x.left!=null){
            maxl=MaxDepth(x.left);
        }
        //计算x结点右子树的最大深度
        if(x.right!=null){
            maxr=MaxDepth(x.right);
        }
        //取较大的哪一个
        max=maxl>maxr?maxl+1:maxr+1;
        return max;
    }

    public int size() {
        return counts;
    }
}

队列类

import java.util.Iterator;

public class MyQueue<T> implements Iterable<T> {

    private class Node<T> {
        private T data;
        private Node<T> next;

        public Node(T data, Node<T> next) {
            this.data = data;
            this.next = next;
        }
    }

    private Node head;
    private Node last;
    private int length;

    public MyQueue() {
        head = new Node(null, null);
        last = null;
        length = 0;
    }

    public boolean isEmpty() {
        return length == 0;
    }

    public int size() {
        return length;
    }

    public void enqueue(T t) {
        if (last == null) {
            last = new Node(t, null);
            head.next = last;
        } else {
            Node<T> oldlast = last;
            last = new Node(t, null);
            oldlast.next = last;
        }
        length++;
    }

    public T dequeue() {
        Node<T> oldNode = null;
        if (isEmpty()) {
            throw new MyException("空队列");
        }
        /*
        自己写的，代码臃肿
        else{
            if(head.next==last){
                oldNode=last;
                last=null;
                head.next=null;
            }else{
                oldNode=head.next;
                head.next=head.next.next;
            }*/

        oldNode = head.next;
        head.next = oldNode.next;
        length--;
        if (isEmpty()) {
            last = null;
        }
        return oldNode.data;
    }

    @Override
    public Iterator<T> iterator() {
        return new Itr();
    }

    private class Itr implements Iterator {
        Node<T> tempNode = null;

        public Itr() {
            tempNode = head;
        }

        @Override
        public boolean hasNext() {
            return tempNode.next != null;
        }

        @Override
        public Object next() {
            tempNode = tempNode.next;
            return tempNode.data;
        }
    }
}

class MyException extends RuntimeException {
    private String message;

    public MyException(String message) {
        super(message);
        this.message = message;
    }
}

测试类

import 队列.MyQueue;

public class BinaryTreeTest {
    public static void main(String[] args) {
        BinaryTree<Integer,String> binaryTree=new BinaryTree<>();
        binaryTree.put(50,"jians");
        binaryTree.put(20,"jians2");
        binaryTree.put(10,"jians3");
        binaryTree.put(15,"jians4");
        binaryTree.put(70,"jians5");
        binaryTree.put(60,"jians6");
        binaryTree.put(80,"jians7");
        binaryTree.put(11,"jians8");
        binaryTree.put(12,"jians9");
        int i = binaryTree.MaxDepth();
        System.out.println(i);
        MyQueue<Integer> queue = binaryTree.layerEgodic();
        for (var queueele:queue) {
            System.out.println(queueele);
        }
    }
}