0037数据结构之Set和Map

基于链表和二分搜索树实现Set，基于二分搜索树实现Map。

---------------------集合Set-----------------------------

Set<E>

void add<E>

void remove<E>

boolean contains<E>

int getSize()

boolean isEmpty()

1、使用二分搜索树实现Set集合：

package set;

import tree.BST;

/*
* 欲使集合中存放的元素具有可比性，需使E extends Comparable<E>
* */
public class BSTSet<E extends Comparable<E>> implements Set<E> {
    BST<E> bst = new BST<>();
    @Override
    public int getSize() {
        return bst.getSize();
    }

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

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

    @Override
    public void add(E e) {
        //由于自己实现的BST类中的add方法不包含重复元素，所以可以直接调用
        bst.add(e);
    }

    @Override
    public void remove(E e) {
        bst.removeElement(e);
    }

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

2、使用链表实现集合Set:

package set;

import linked.LinkedList;

/*
* 链表实现的Set包含的元素不用实现Comparable接口
* */
public class LinkedListSet<E> implements Set<E>{
    private LinkedList linkedList;

    public LinkedListSet(){
        linkedList = new LinkedList();
    }

    @Override
    public int getSize() {
        return linkedList.getSize();
    }

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

    @Override
    public boolean contains(E e) {
        return linkedList.contains(e);
    }

    @Override
    public void add(E e) {
        //由于链表中没有限制元素不能重复，所以此处需要加上判断
        if(!linkedList.contains(e)){
            //在链表头加新的元素，时间复杂度最低
            linkedList.addFirst(e);
        }
    }

    @Override
    public void remove(E e) {
        linkedList.removeElement(e);
    }

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

总结：基于链表实现的Set效率慢于基于二分搜索树实现的Set，原因是基于二分搜索树实现的链表的add、remove、contains都是O(h)级别的，h是二分搜索树的高度，对于满二分搜索树，其中h=log2n代表log以2为底n的对数，所以时间复杂度也可以看成是O(log2n)，不管是2是底数或者10是底数、100是底数，都可以写成O(logn)，而最坏形式的二分搜索树就是只有一个分支，即链表形式的二分搜索树，那么时间复杂度也就成了O(n)了；而基于链表实现的Set，add（调用了链表的contains进行判断）、remove、contains的时间复杂度都是O(n)的

比如：n=100万的时候，logn是20，两者相差5万倍，即如果logn用时1秒的话，n就要用时14个小时，这样看来两者的差距是非常大的。且随着n的增大，差距会越来越大。

nlogn和n2之间的差距相当于logn和n之间的差距。

logn的效率是非常高的。

有序集合最好基于搜索树实现，无序集合最好基于hash表实现（比如无序集合基于链表实现效率是极低的）

--------------------------映射Map----------------------

链表实现：

class Node{

K key;

V value;

Node next;

}

二分搜索树实现：

class Node{

K key;

V value;

Node left;

Node right;

}

Map接口定义：

int getSize()

boolean isEmpty()

Map<K,V>

void add(K,V)

V remove(K)

boolean contains(K)

V get(K)

void set(K,V)

1、基于二分搜索树实现Map

package map;



public class BSTMap<K extends Comparable<K>,V> implements Map<K,V> {

    private class Node{

        public K key;

        public V value;

        public Node left;

        public Node right;



        public Node(K key,V value,Node left,Node right){

            this.key = key;

            this.value = value;

            this.left = left;

            this.right = right;

        }



        public Node(K key,V value){

            this.key = key;

            this.value = value;

            this.left = null;

            this.right = null;

        }



        public Node(){

            this.key = null;

            this.value = null;

            this.left = null;

            this.right = null;

        }

    }



    private int size;

    private Node root;



    public BSTMap(){

        root = null;

        size = 0;

    }



    @Override

    public int getSize() {

        //此处不初始化root，是为了下边其他方法判断node == null方便

        return size;

    }



    @Override

    public boolean isEmpty() {

        return size == 0;

    }



    @Override

    public void add(K k, V v) {

        root = add(root,k,v);

    }



    //内容递归调用，返回原node树的基础上增加新node后的node树

    private Node add(Node node,K k,V v){

        if(k == null){

            return null;

        }

        //1终止条件

        if(node == null){

            //创建新的节点

            size++;

            return new Node(k,v);

        }

        //2递归调用

        if(k.compareTo(node.key) == 0){

            //返回当前节点

            return node;

        }else if(k.compareTo(node.key) < 0){

            node.left = add(node.left,k,v);

            return node;

        }else{

            node.right = add(node.right,k,v);

            return node;

        }

    }

    @Override

    public V remove(K k) {

        V v = get(k);

        root = remove(root,k);

        return v;

    }



    //内部递归调用

    public Node remove(Node node,K k){

        //1终止条件

        if(node == null){

            return null;

        }

        //2递归调用

        if(k.compareTo(node.key) == 0){

            //如果右子树为null，则返回左子树

            if(node.right == null){

                Node leftNode = node.left;

                node.left = null;

                size--;

                return leftNode;

            }else if(node.left == null){

                //如果左子树为null，则返回右子树

                Node rightNode = node.right;

                node.right = null;

                size--;

                return rightNode;

            }else{

                //否则左右子树都不为空

                //需要调用getMin方法，removeMin方法，然后拼接出新的node树返回

                Node rightNode = node.right;

                Node min = minumum(rightNode);

                Node newRightNode = removeMin(rightNode);

                min.left = node.left;

                min.right = newRightNode;

                node.left = node.right = null;

                return min;



            }

        }else if(k.compareTo(node.key) < 0){

            node.left = remove(node.left,k);

        }else{

            node.right = remove(node.right,k);

        }

        return node;

    }



    //私有的内部递归调用的的方法

    private Node minumum(Node node){

        //终止条件

        if(node.left == null){

            return  node;

        }

        return minumum(node.left);

    }



    //返回删除最小节点后的node

    public Node removeMin(Node node){

        //终止条件

        if(node.left == null){

            Node rightNode = node.right;

            node.right = null;

            size--;

            return rightNode;

        }

        //相当于如果node.left是最小的节点，

        //使node.left = node.left.right

        node.left = removeMin(node.left);

        return node;

    }



    @Override

    public V get(K k) {

        return get(root,k);

    }



    //内部递归调用

    private V get(Node node,K k){

        //1终止条件

        if(node == null || k == null){

            return null;

        }

        //2递归调用

        if(k.compareTo(node.key) == 0){

            //返回当前节点

            return node.value;

        }else if(k.compareTo(node.key) < 0){

            return get(node.left,k);

        }else{

            return get(node.right,k);

        }

    }



    @Override

    public void set(K k, V v) {

        root = set(root,k,v);

    }



    //内部递归调用,返回原node树的基础上更改值后的node树

    public Node set(Node node,K k,V v){

        if(k == null){

            return null;

        }

        //1终止条件

        if(node == null){

            //创建新的节点

            size++;

            return new Node(k,v);

        }

        //2递归调用

        if(k.compareTo(node.key) == 0){

            //返回当前节点,与add方法的区别是add不会改值

            node.value = v;

            return node;

        }else if(k.compareTo(node.key) < 0){

            node.left = add(node.left,k,v);

            return node;

        }else{

            node.right = add(node.right,k,v);

            return node;

        }

    }

    @Override

    public boolean contains(K k){

        return contains(root,k);

    }



    public boolean contains(Node node,K k) {

       /* if(k == null){

            return false;

        }

        //1终止条件

        if(node == null){

            return false;

        }

        //2递归调用

        if(k.compareTo(node.key) == 0){

            return true;

        }else if(k.compareTo(node.key) < 0){

            return contains(node.left,k);

        }else{

            return contains(node.right,k);

        }*/

       //调用get(root,k)方法

       return get(root,k) != null;

    }

}

2、BSTMap的测试代码如下：

package map;

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        Map<Integer,Integer> map = new BSTMap();
        System.out.println("isEmpty:" + map.isEmpty());
        int[] arr = {13,6,9,2,7,3,1,8,2,6,4,5,8};
        for(int i=0;i<arr.length;i++){
            map.add(arr[i],arr[i]);
        }
        System.out.println("size:" + map.getSize());
        System.out.println("isEmpty:" + map.isEmpty());
        System.out.println("contains5:" + map.contains(5));
        System.out.println("contains1:" + map.contains(5));
        System.out.println("contains12:" + map.contains(12));
        System.out.println("get6:" + map.get(6));
        map.set(12,12);
        map.set(13,14);
        System.out.println("size:" + map.getSize());
        System.out.println("get12:" + map.get(12));
        System.out.println("get13:" + map.get(13));

    }
}


如有理解不到之处，望指正！

0037数据结构之Set和Map

猜你喜欢