数据结构06-优快云博客

本文链接：https://blog.youkuaiyun.com/MZdzt/article/details/122944062

本文介绍了二分搜索树（BinarySearchTree）的实现，包括添加、查找和遍历操作。此外，还展示了如何使用二分搜索树实现Set数据结构的TreeSet类。接着，讨论了底层由链表实现的LinkedSet类，以及由二分搜索树实现的TreeSet类在性能上的差异。最后，引入了AVL树作为平衡二分搜索树的示例，展示其保持平衡的特性以及如何实现插入、删除和查找操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

树

二分搜索树

package p6.二分搜索树;

import java.util.Iterator;

//二分搜索树
public class BinarySearchTree<E extends Comparable<E>> implements Iterable<E>{

    //定义二分搜索树的结点信息
    private class Node {
        public E e; //数据域
        public Node left;   //左孩子（当前Node结点左子树的根）
        public Node right;  //右孩子（当前Node结点右子树的根）
        public Node(E e) {
            this.e = e;
            left = null;
            right = null;
        }
        @Override
        public String toString() {
            return e.toString();
        }
    }
    private Node root;  //根节点的指针 根指针 采用真实根节点 如果二分搜索树为空 root == null
    private int size;   //二分搜索树中元素的个数（结点的个数）

    public BinarySearchTree(){
        root = null;
        size = 0;
    }

    //添加元素的方法
    public void add(E e) {
        /*
        //添加的迭代思路
        Node node = new Node(e);
        if (isEmpty()) {
            root = node;
            size++;
        }
        Node cur = root;
        while (true) {
            //新元素比当前大 往右走
            if (node.e.compareTo(cur.e) > 0) {
                if (cur.right == null) {
                    cur.right = node;
                    size++;
                    break;
                } else {
                    cur = cur.right;
                }
            //新元素比当前小 往左走
            } else if (node.e.compareTo(cur.e) < 0) {
                if (cur.left == null) {
                    cur.left = node;
                    size++;
                    break;
                } else {
                    cur = cur.left;
                }
            } else {
                break;
            }
        }
        */
        //递归的思路
        root = add(root, e);
    }

    //在以node为根的树中 插入元素e 并返回新树的根
    private Node add(Node node, E e) {
        //从下一层向上一层
        if (node == null) {
            size++;
            return new Node(e);
        }
        //当前层向下一层
        if (e.compareTo(node.e) < 0) {
            node.left = add(node.left, e);
        } else if (e.compareTo(node.e) > 0) {
            node.right = add(node.right, e);
        }
        //当前层向上一层
        return node;
    }

    public boolean contains(E e) {
        //迭代思路
        /*
        Node cur = root;
        while (true) {
            if (e.compareTo(cur.e) < 0) {
                if (cur.left == null) {
                    return false;
                }
                cur = cur.left;
            } else if (e.compareTo(cur.e) > 0) {
                if (cur.right == null) {
                    return false;
                }
                cur = cur.right;
            } else {
                return true;
            }
        }
        */
        return contains(root,e);
    }

    //查看以node为根的二分搜索树中是否包含元素e
    private boolean contains(Node node, E e) {
        if (node == null) {
            return false;
        }
        if (e.compareTo(node.e) < 0) {
            return contains(node.left, e);
        } else if (e.compareTo(node.e) > 0) {
            return contains(node.right, e);
        } else {
            return true;
        }
    }

    //前序遍历
    public void preOrder() {
        preOrder(root);
    }
    //前序遍历-递归方式 以node为根节点 前序遍历DLR
    private void preOrder(Node node) {
        if (node == null) {
            return;
        }
        System.out.println(node.e);
        preOrder(node.left);
        preOrder(node.right);
    }

    //中序遍历
    public void inOrder() {
        inOrder(root);
    }
    //中序遍历-递归方式 以node为根节点 中序遍历LDR
    private void inOrder(Node node) {
        if (node == null) {
            return;
        }
        inOrder(node.left);
        System.out.println(node.e);
        inOrder(node.right);
    }

    //后序遍历
    public void postOrder() {
        postOrder(root);
    }
    //后序遍历-递归方式 以node为根节点 后序遍历LRD
    private void postOrder(Node node) {
        if (node == null) {
            return;
        }
        postOrder(node.left);
        postOrder(node.right);
        System.out.println(node.e);
    }


    public int size() {
        return size;
    }

    public boolean isEmpty() {
        return root == null && size == 0;
    }

    @Override
    public Iterator<E> iterator() {
        return null;
    }
}

测试

package p6.二分搜索树;

public class TestBST {
    public static void main(String[] args) {
        BinarySearchTree<Integer> bst = new BinarySearchTree<>();
        bst.add(1);
        bst.add(4);
        bst.add(3);
        bst.add(5);
        bst.add(2);
        bst.add(6);

        System.out.println(bst.contains(3));
        System.out.println(bst.contains(7));
        System.out.println("==========");
        bst.preOrder();
        System.out.println("==========");
        bst.inOrder();
        System.out.println("==========");
        bst.postOrder();

    }
}

Set树

package p6.树与哈希表;

import p1.接口.Set;
import p3.链式结构.LinkedList;

import java.util.Iterator;


//底层由链表来实现的集合
public class LinkedSet<E> implements Set<E> {
    private LinkedList<E> list;

    public LinkedSet() {
        list = new LinkedList<>();
    }

    @Override
    public void add(E e) {      //O(n)
        if (!list.contains(e)) {
            list.add(e);
        }
    }

    @Override
    public void remove(E e) {   //O(n)
        list.remove(e);
    }

    @Override
    public boolean contains(E e) { //O(n)
        return list.contains(e);
    }

    @Override
    public int size() {
        return list.size();
    }

    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }

    @Override
    public String toString() {
        return list.toString();
    }

    @Override
    public Iterator<E> iterator() {
        return list.iterator();
    }
}

package p6.树与哈希表;

import p1.接口.Set;

import java.util.Iterator;

//底层由二分搜索树BinarySearchTree(BST)实现的集合
public class TreeSet<E extends Comparable<E>> implements Set<E> {
    private BinarySearchTree<E> bst;

    public TreeSet() {
        bst = new BinarySearchTree<>();
    }


    @Override
    public void add(E e) {  //O(logn)
        bst.add(e);
    }

    @Override
    public void remove(E e) { //O(logn)
        bst.remove(e);
    }

    @Override
    public boolean contains(E e) { //O(logn)
        return bst.contains(e);
    }

    @Override
    public int size() {
        return bst.size();
    }

    @Override
    public boolean isEmpty() {
        return bst.isEmpty();
    }

    @Override
    public String toString() {
        return bst.toString();
    }

    @Override
    public Iterator<E> iterator() {
        return bst.iterator();
    }
}

package p6.树与哈希表;

import java.util.ArrayList;
import java.util.Scanner;
import java.util.Locale;
import java.io.File;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class FileOperation {

    public static boolean readFile(String filename, ArrayList<String> words) {

        if (filename == null || words == null) {
            System.out.println("filename is null or words is null");
            return false;
        }

        Scanner scanner;

        try {
            File file = new File(filename);
            if (file.exists()) {
                FileInputStream fis = new FileInputStream(file);
                scanner = new Scanner(new BufferedInputStream(fis), "UTF-8");
                scanner.useLocale(Locale.ENGLISH);
            } else
                return false;
        } catch (IOException ioe) {
            System.out.println("Cannot open " + filename);
            return false;
        }

        if (scanner.hasNextLine()) {

            String contents = scanner.useDelimiter("\\A").next();

            int start = firstCharacterIndex(contents, 0);
            for (int i = start + 1; i <= contents.length(); )
                if (i == contents.length() || !Character.isLetter(contents.charAt(i))) {
                    String word = contents.substring(start, i).toLowerCase();
                    words.add(word);
                    start = firstCharacterIndex(contents, i);
                    i = start + 1;
                } else
                    i++;
        }

        return true;
    }

    private static int firstCharacterIndex(String s, int start) {

        for (int i = start; i < s.length(); i++)
            if (Character.isLetter(s.charAt(i)))
                return i;
        return s.length();
    }
}

package p0.测试;

import p6.树与哈希表.TreeSet;

public class TestTreeSet {
    public static void main(String[] args) {
        TreeSet<Person> set = new TreeSet<Person>();
        set.add(new Person(18,"momo"));
        set.add(new Person(10,"xixi"));
        set.add(new Person(12,"lala"));
        set.add(new Person(19,"haha"));
        set.add(new Person(17,"kaka"));
        System.out.println(set.toString());
    }
}

package p0.测试;

import p6.树与哈希表.FileOperation;
import p6.树与哈希表.LinkedSet;
import p6.树与哈希表.TreeSet;

import java.util.ArrayList;

public class TestTreeSetAndLinkedSet {
    public static void main(String[] args) {
        ArrayList<String> words = new ArrayList<>();
        //把文本文件中所有的英文单词统计在words这个线性表中（所有单词 包含重复）
        FileOperation.readFile("a-tale-of-two-cities.txt", words);

        testTreeSet(words);
        testLinkedSet(words);

    }

    private static void testLinkedSet(ArrayList<String> words) {
        Long startTime = System.currentTimeMillis();
        LinkedSet<String> set = new LinkedSet<>();
        for (String word : words) {
            set.add(word);  //把所有单词统计到集合中 每个单词只出现一次
        }
        Long endTime = System.currentTimeMillis();
        System.out.println(set.size());
        System.out.println(endTime - startTime + "ms");
    }

    private static void testTreeSet(ArrayList<String> words) {
        Long startTime = System.currentTimeMillis();
        TreeSet<String> set = new TreeSet<>();
        for (String word : words) {
            set.add(word);  //把所有单词统计到集合中 每个单词只出现一次
        }
        Long endTime = System.currentTimeMillis();
        System.out.println(set.size());
        System.out.println(endTime - startTime + "ms");
    }
}

Map树

package p6.树与哈希表;

import p1.接口.List;
import p1.接口.Map;
import p1.接口.Set;
import p3.链式结构.LinkedList;

import java.util.Iterator;

public class TreeMap<K extends Comparable<K>,V> implements Map<K,V>,Iterable<Map.Entry<K,V>> {
    //定义二分搜索树的结点信息
    private class Node {
        public K key;   //键
        public V value; //值
        public Node left;
        public Node right;
        public Node() {}
        public Node(K key, V value) {
            this.key = key;
            this.value = value;
        }
    }
    private Node root;
    private int size;

    public TreeMap() {
        root = null;
        size = 0;
    }

    //辅助函数 获取指定key所在的结点
    //以node为根的二分搜索树中 查找key所在的结点 - 递归
    private Node getNode(Node node, K key) {
        if (node == null) {
            return null;
        }
        if (key.compareTo(node.key) < 0) {
            return getNode(node.left, key);
        } else if (key.compareTo(node.key) > 0) {
            return getNode(node.right, key);
        } else {
            return node;
        }
    }

    @Override
    public void put(K key, V value) {
        root = put(root, key, value);
    }

    private Node put(Node node, K key, V value) {
        if (node == null) {
            size++;
            return new Node(key,value);
        }
        if (key.compareTo(node.key) < 0) {
            node.left = put(node.left, key,value);
        } else if (key.compareTo(node.key) > 0) {
            node.right = put(node.right, key,value);
        } else {    //如果已经存在 则put为修改
            node.value = value;
        }
        return node;
    }

    @Override
    public V remove(K key) {
        Node delNode = getNode(root,key);
        if (delNode != null) {
            root = remove(root,key);
            return delNode.value;
        }
        return null;
    }

    private Node remove(Node node, K key) {
        if (node == null) {
            return null;
        }
        if (key.compareTo(node.key) < 0) {
            node.left = remove(node.left, key);
            return node;
        } else if (key.compareTo(node.key) > 0) {
            node.right = remove(node.right, key);
            return node;
        } else {
            if (node.left == null) {
                Node rightNode = node.right;
                node.right = null;
                size--;
                return rightNode;
            }
            if (node.right == null) {
                Node leftNode = node.left;
                node.left = null;
                size--;
                return leftNode;
            }
            Node successor = minimum(node.right);
            successor.right = removeMin(node.right);
            successor.left = node.left;
            node.left = node.right = null;
            return successor;
        }
    }

    private Node removeMin(Node node) {
        if (node.left == null) {
            Node rightNode = node.right;
            node.right = null;
            size--;
            return rightNode;
        }
        node.left = removeMin(node.left);
        return node;
    }

    private Node minimum(Node node) {
        if (isEmpty()) {
            return null;
        }
        if (node.left == null) {
            return node;
        }
        return minimum(node.left);
    }



    @Override
    public boolean contains(K key) {

        return getNode(root,key) != null;
    }

    @Override
    public V get(K key) {
        Node node = getNode(root,key);
        if (node != null) {
            return node.value;
        }
        return null;
    }

    @Override
    public void set(K key, V value) {
        Node node = getNode(root,key);
        if (node == null) {
            throw new IllegalArgumentException("key-value is not exist");
        }
        node.value = value;
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public boolean isEmpty() {

        return size == 0 && root == null;
    }

    //获取所有键的Set
    @Override
    public Set<K> keySet() {
        TreeSet<K> set = new TreeSet<>();
        inOrderKetSet(root, set);
        return set;
    }
    private void inOrderKetSet(Node node, TreeSet<K> set) {
        if (node == null) {
            return;
        }
        inOrderKetSet(node.left,set);
        set.add(node.key);
        inOrderKetSet(node.right,set);
    }

    //获取所有值的List
    @Override
    public List<V> values() {
        LinkedList<V> list = new LinkedList<>();
        inOrderValues(root, list);
        return list;
    }

    private void inOrderValues(Node node, LinkedList<V> list) {
        if (node == null) {
            return;
        }
        inOrderValues(node.left, list);
        list.add(node.value);
        inOrderValues(node.right, list);
    }

    @Override
    public Set<Entry<K, V>> entrySet() {
        TreeSet<Entry<K,V>> entries = new TreeSet<>();
        inOrderEntrys(root,entries);
        return entries;
    }

    private void inOrderEntrys(Node node, TreeSet<Entry<K,V>> entries) {
        if (node == null) {
            return;
        }
        inOrderEntrys(node.left,entries);
        entries.add(new BSTEntry<>(node.key, node.value));

        inOrderEntrys(node.right,entries);
    }


    //自己实现
    @Override
    public String toString() {
        return null;
    }
    //自己实现
    @Override
    public Iterator<Entry<K, V>> iterator() {
        return null;
    }



    //键值对对象
    private class BSTEntry<K extends Comparable<K>,V> implements Entry<K,V> {

        private K key;
        private V value;
        public BSTEntry(K key, V value) {
            this.key = key;
            this.value = value;
        }

        @Override
        public K getKey() {
            return key;
        }

        @Override
        public V getValue() {
            return value;
        }

        @Override
        public String toString() {
            return key + ":" + value;
        }

        @Override
        public int compareTo(Entry<K, V> o) {
            return this.getKey().compareTo(o.getKey()) ;
        }
    }
}

package p0.测试;

import p6.树与哈希表.FileOperation;
import p6.树与哈希表.TreeMap;

import java.util.ArrayList;

public class TestTreeMap {
    public static void main(String[] args) {
        TreeMap<Integer,String> map = new TreeMap<>();
        map.put(12,"xixi");
        map.put(10,"haha");
        map.put(9,"baba");
        map.put(13,"lala");
        System.out.println(map.keySet());
        System.out.println(map.values());
        System.out.println(map.entrySet());

        TreeMap<String,Integer> map2 = new TreeMap<>();
        ArrayList<String> words = new ArrayList<>();
        FileOperation.readFile("a-tale-of-two-cities.txt",words);
        for (String word : words) {
            if (map2.contains(word)) {
                map2.set(word,map2.get(word) + 1);
            } else {
                map2.put(word,1);
            }
        }
        System.out.println(map2.size());
        System.out.println(map2.get("the"));
        System.out.println(map2.get("if"));
    }
}

平衡二分搜索树

package p6.树与哈希表;

import p1.接口.List;
import p1.接口.Map;
import p1.接口.Set;
import p2.线性结构.ArrayList;
import p3.链式结构.LinkedList;

//AVL平衡二分搜索树实现的映射
public class AVLTreeMap<K extends Comparable<K>,V> implements Map<K,V> {
    private class Node {
        public K key;   //键
        public V value; //值
        public int height;  //高度
        public Node left;
        public Node right;

        public Node (K key, V value) {
            this.key = key;
            this.value = value;
            left = null;
            right = null;
            height = 1; //新结点的高度默认都是1
        }
    }

    private Node root;
    private int size;

    public AVLTreeMap() {
        root = null;
        size = 0;
    }

    //以node为根的子树中 查找key所在的结点
    private Node getNode(Node node, K key) {
        if(node == null) {
            return null;
        }
        if (key.compareTo(node.key) < 0) {
            return getNode(node.left, key);
        } else if (key.compareTo(node.key) > 0) {
            return getNode(node.right, key);
        } else {
            return node;
        }
    }

    //获取某一个结点的高度 如果该结点为空 则高度为0
    private int getHeight(Node node) {
        if (node == null) {
            return 0;
        }
        return node.height;
    }

    //计算某一个结点的平衡因子（左右子树的高度差） >0左边高 ==0左右同高 <0右边高
    private int getBalanceFactor(Node node) {
        if (node == null) {
            return 0;
        }
        return getHeight(node.left) - getHeight(node.right);
    }

    //验证是否是二分搜索树
    public boolean isBST() {
        ArrayList<K> list = new ArrayList<>();
        inOrderKeys(root, list);
        for (int i = 1; i < list.size(); i++) {
            if (list.get(i - 1).compareTo(list.get(i)) > 0) {
                return false;
            }
        }
        return true;
    }

    private void inOrderKeys(Node node, ArrayList<K> list) {
        if (node == null) {
            return;
        }
        inOrderKeys(node.left, list);
        list.add(node.key);
        inOrderKeys(node.right,list);
    }

    //验证得是一颗平衡树
    public boolean isBalanced() {
        return isBalanced(root);
    }

    private boolean isBalanced(Node node) {
        if (node == null) {
            return true;
        }
        int balancedFactor = getBalanceFactor(node);
        if (Math.abs(balancedFactor) > 1) {
            return false;
        }
        return isBalanced(node.left) && isBalanced(node.right);
    }

    //左旋转(右侧的右侧) 将y结点进行左旋转 并返回新的根
    private Node leftRotate(Node y) {
        Node x = y.right;
        Node T3 = x.left;
        x.left = y;
        y.right = T3;
        y.height = Math.max(getHeight(y.left),getHeight(y.right)) + 1;
        x.height = Math.max(getHeight(x.left),getHeight(x.right)) + 1;
        return x;
    }
    //右旋转(左侧的左侧) 将y结点进行右旋转 并返回新的根
    private Node rightRotate(Node y) {
        Node x = y.left;
        Node T3 = x.right;
        x.right = y;
        y.left = T3;
        y.height = Math.max(getHeight(y.left),getHeight(y.right)) + 1;
        x.height = Math.max(getHeight(x.left),getHeight(x.right)) + 1;
        return x;
    }

    @Override
    public void put(K key, V value) {
        root = put(root,key, value);
    }

    private Node put(Node node, K key, V value) {
        if (node == null) {
            size++;
            return new Node(key, value);
        }
        if (key.compareTo(node.key) < 0) {
            node.left = put(node.left, key, value);
        } else if (key.compareTo(node.key) > 0) {
            node.right = put(node.right, key,value);
        } else {
            node.value = value;
        }

        //当前结点的高度需要更新
        node.height = Math.max(getHeight(node.left),getHeight(node.right)) + 1;
        //判断当前结点是否是平衡的
        int balanceFactor = getBalanceFactor(node);

        // >1说明当前结点左侧不平衡 node.left >= 0 左侧的左侧不平衡
        if (balanceFactor > 1 && getBalanceFactor(node.left) >= 0) {
            return rightRotate(node);
        }
        // >1说明当前结点左侧不平衡 node.left < 0 左侧的右侧不平衡
        if (balanceFactor > 1 && getBalanceFactor(node.left) < 0) {
            node.left = leftRotate(node.left);
            return rightRotate(node);
        }
        // <-1说明当前结点右侧不平衡 node.right >= 0 右侧的左侧不平衡
        if (balanceFactor < -1 && getBalanceFactor(node.right) >= 0) {
            node.right = rightRotate(node.right);
            return leftRotate(node);
        }
        // <-1说明当前结点右侧不平衡 node.right < 0 右侧的右侧不平衡
        if (balanceFactor < -1 && getBalanceFactor(node.right) < 0) {
            return leftRotate(node);
        }

        return node;
    }

    @Override
    public V remove(K key) {
        Node delNode = getNode(root,key);
        if (delNode != null) {
            root = remove(root,key);
            return delNode.value;
        }
        return null;
    }

    private Node remove(Node node, K key) {
        if (node == null) {
            return null;
        }
        Node retNode = null;
        if (key.compareTo(node.key) < 0) {
            node.left = remove(node.left, key);
            retNode = node;
        } else if (key.compareTo(node.key) > 0) {
            node.right = remove(node.right, key);
            retNode = node;
        } else {    //找到了要删除的结点
            if (node.left == null) {
                Node rightNode = node.right;
                node.right = null;
                size--;
                retNode = rightNode;
            } else if (node.right == null) {
                Node leftNode = node.left;
                node.left = null;
                retNode = leftNode;
            } else {
                Node successor = minmum(node.right);
                successor.right = remove(node.right,successor.key);
                successor.left = node.left;
                node.left = node.right = null;
                retNode = successor;
            }
        }
        if (retNode == null) {
            return retNode;
        }
        //更新高度
        retNode.height = Math.max(getHeight(retNode.left), getHeight(retNode.right)) + 1;
        //获取平衡因子判断是否需要自平衡
        int balanceFactor = getBalanceFactor(retNode);

        // >1说明当前结点左侧不平衡 node.left >= 0 左侧的左侧不平衡
        if (balanceFactor > 1 && getBalanceFactor(retNode.left) >= 0) {
            return rightRotate(retNode);
        }
        // >1说明当前结点左侧不平衡 node.left < 0 左侧的右侧不平衡
        if (balanceFactor > 1 && getBalanceFactor(retNode.left) < 0) {
            retNode.left = leftRotate(retNode.left);
            return rightRotate(retNode);
        }
        // <-1说明当前结点右侧不平衡 node.right >= 0 右侧的左侧不平衡
        if (balanceFactor < -1 && getBalanceFactor(retNode.right) >= 0) {
            retNode.right = rightRotate(retNode.right);
            return leftRotate(retNode);
        }
        // <-1说明当前结点右侧不平衡 node.right < 0 右侧的右侧不平衡
        if (balanceFactor < -1 && getBalanceFactor(retNode.right) < 0) {
            return leftRotate(retNode);
        }
        return retNode;
    }

    private Node minmum(Node node) {
        if (node.left == null) {
            return node;
        } else {
            return minmum(node.left);
        }
    }

    @Override
    public boolean contains(K key) {
        return getNode(root,key) != null;
    }

    @Override
    public V get(K key) {
        Node node = getNode(root,key);
        if (node != null) {
            return node.value;
        }
        return null;
    }

    @Override
    public void set(K key, V value) {
        Node node = getNode(root,key);
        if (node == null) {
            throw new IllegalArgumentException("key-value is not exist");
        }
        node.value = value;
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size == 0 && root == null;
    }

    @Override
    public Set<K> keySet() {
        TreeSet<K> set = new TreeSet<>();
        inOrderKeySet(root, set);
        return set;
    }
    private void inOrderKeySet(Node node, TreeSet<K> set) {
        if (node == null) {
            return;
        }
        inOrderKeySet(node.left,set);
        set.add(node.key);
        inOrderKeySet(node.right,set);
    }

    @Override
    public List<V> values() {
        LinkedList<V> list = new LinkedList<>();
        inOrderValues(root, list);
        return list;
    }
    private void inOrderValues(Node node, LinkedList<V> list) {
        if (node == null) {
            return;
        }
        inOrderValues(node.left, list);
        list.add(node.value);
        inOrderValues(node.right, list);
    }

    @Override
    public Set<Entry<K, V>> entrySet() {
        TreeSet<Entry<K,V>> entries = new TreeSet<>();
        inOrderEntrys(root,entries);
        return entries;
    }
    private void inOrderEntrys(Node node, TreeSet<Entry<K,V>> entries) {
        if (node == null) {
            return;
        }
        inOrderEntrys(node.left, entries);
        entries.add(new BSTEntry<>(node.key, node.value));

        inOrderEntrys(node.right, entries);
    }
    //键值对对象
    private class BSTEntry<K extends Comparable<K>,V> implements Entry<K,V> {

        private K key;
        private V value;
        public BSTEntry(K key, V value) {
            this.key = key;
            this.value = value;
        }

        @Override
        public K getKey() {
            return key;
        }

        @Override
        public V getValue() {
            return value;
        }

        @Override
        public String toString() {
            return key + ":" + value;
        }

        @Override
        public int compareTo(Entry<K, V> o) {
            return this.getKey().compareTo(o.getKey()) ;
        }
    }

    //前序遍历
    public void preOrder() {
        preOrder(root);
    }
    //前序遍历-递归方式 以node为根节点 前序遍历DLR
    private void preOrder(Node node) {
        if (node == null) {
            return;
        }
        System.out.println(node.key);
        preOrder(node.left);
        preOrder(node.right);
    }
}

package p0.测试;


import p6.树与哈希表.AVLTreeMap;
import p6.树与哈希表.FileOperation;
import p6.树与哈希表.TreeMap;

import java.util.ArrayList;
import java.util.Collections;

public class TestAVLTreeMap {
    public static void main(String[] args) {
        AVLTreeMap<Integer,String> map = new AVLTreeMap<>();
        map.put(6,"666");
        map.put(4,"444");
        map.put(3,"333");
        map.put(7,"777");
        map.put(5,"555");
        map.put(9,"999");
        map.put(8,"888");
        map.put(1,"111");
        map.put(2,"222");
        map.remove(6);
        System.out.println(map.keySet());
        System.out.println(map.isBST());
        System.out.println(map.isBalanced());
        map.preOrder();

        System.out.println("=============================");
        ArrayList<String> words = new ArrayList<>();
        FileOperation.readFile("a-tale-of-two-cities.txt",words);
//        Collections.sort(words);
        test01(words);
        test02(words);
    }

    private static void test02(ArrayList<String> words) {
        TreeMap<String,Integer> map = new TreeMap<>();
        long startTime = System.currentTimeMillis();
        for (String word : words) {
            if (map.contains(word)) {
                map.set(word,map.get(word) + 1);
            } else {
                map.put(word,1);
            }
        }
        System.out.println(map.get("the"));
        System.out.println(map.get("he"));
        System.out.println(map.get("she"));
        System.out.println(map.get("fuck"));
        System.out.println(map.get("is"));
        long endTime = System.currentTimeMillis();
        System.out.println(endTime - startTime + "ms");
    }

    private static void test01(ArrayList<String> words) {
        AVLTreeMap<String,Integer> map = new AVLTreeMap<>();
        long startTime = System.currentTimeMillis();
        for (String word : words) {
            if (map.contains(word)) {
                map.set(word,map.get(word) + 1);
            } else {
                map.put(word,1);
            }
        }
        System.out.println(map.get("the"));
        System.out.println(map.get("he"));
        System.out.println(map.get("she"));
        System.out.println(map.get("fuck"));
        System.out.println(map.get("is"));
        long endTime = System.currentTimeMillis();
        System.out.println(endTime - startTime + "ms");
    }
}