数据结构入门-7-集合和映射

一.Set集合

每个元素出现一次，天然去重

因为BST也是天然不支持重复元素，所以BST视线Set也是非常好的

二.Set 的实现

public interface Set<E> {
    void add(E e);
    void remove(E e);
    boolean contains(E e);
    int getSize();
    boolean isEmpty();
}

2.1 用BST实现Set

package gSetAndMap.base;


public class BSTSet<E extends Comparable<E>> implements Set<E> {

    private BST<E> bst;

    public BSTSet(){
        bst = new BST<>();
    }

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

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


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

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

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

2.2 用LinkedList实现Set

public class LinkedListSet<E> implements Set<E> {

    private LinkedList<E> list;

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

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

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

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

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

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

2.4 Set 用BST & LinkedeList对比

2.4.2 时间复杂度分析

h：BST的层数

2.4.3 h n之间的对比

log(n) & n 之间的差距

2.4.4 不同的BST

取决于进入BST的顺序

顺序插入BST，BST便退化成List 最差的情况，h == n

最差的情况，后续会用平衡二叉树来解决

三. Map

key value 的形式，Python中称为 dict 字典

可以通过key 容易找到 value即可

 public interface Map<K, V> {

    void add(K key, V value);
    V remove(K key);
    boolean contains(K key);
    V get(K key);
    void set(K key, V newValue);
    int getSize();
    boolean isEmpty();
}

3.1 LinkedList 实现 Map

package gSetAndMap.MapBase;

public class LinkedListMap<k,v> implements Map<k,v> {

    private class Node{
        public k key;
        public v value;
        public Node next;

        public Node(k key,v value,Node next){
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public Node(k key,v value){
            this.key = key;
            this.value = value;
            this.next = null;
        }

        public Node(){
            this.key = null;
            this.value = null;
            this.next = null;
        }

        @Override
        public String toString() {
            return "Node{" +
                    "key=" + key.toString() +
                    ", value=" + value.toString() +
                    '}';
        }
    }

    private Node dummyHead;
    private int size;

    public LinkedListMap(){
        dummyHead = new Node();
        size = 0;
    }
    
    private Node getNode(k key){
        Node cur = dummyHead.next;
        while (cur != null) {
            if(cur.key.equals(key)){
                return cur;
            }
            cur = cur.next;
        }
        return null;
    }

    @Override
    public void add(k key, v value) {
        Node node = getNode(key);
        if (node == null) {
            dummyHead.next = new Node(key,value,dummyHead.next);
            size ++;
        }else { // 已经存在key
            node.value = value;
        }
    }

    @Override
    public v remove(k key) {
        Node prev = this.dummyHead;
        while (prev.next != null) {
            if(prev.next.key.equals(key)){
                break;
            }
            prev = prev.next;
        }
        if(prev.next != null){
            Node delNode = prev.next;
            prev.next = delNode.next;
            delNode.next = null;
            size--;
            return delNode.value;
        }
        
        return null;
    }

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

    @Override
    public v get(k key) {
        Node node = getNode(key);
        return node == null ? null:node.value;
    }

    @Override
    public void set(k key, v newValue) {
        Node node = getNode(key);
        if (node == null) {
            throw new IllegalArgumentException(key + "doesn't exist!");
        }
        node.value = newValue;
    }

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

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

3.2 BST 实现Map

package gSetAndMap.MapBase;

public class BSTMap<k extends Comparable<k>,v> implements Map<k,v> {

    private class Node{
        public k key;
        public v value;
        public Node left,right;

        public Node(k key,v value){
            this.key = key;
            this.value = value;
            left = null;
            right = null;
        }
    }

    private Node root;
    private int size;

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

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

    private Node maxmum(Node node){
        if (node.right == null) {
            return node;
        }
        return maxmum(node.right);
    }

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




    @Override
    public void add(k key, v value) {
        root = add(root,key,value);
    }

    //向以node为根的二分搜索树插入元素(k,v) Recursion
    private Node add(Node node, k key, v value){

        if(node == null){
            size ++;
            return new Node(key, value);
        }

        if(key.compareTo(node.key) < 0)
            node.left = add(node.left, key, value);
        else if(key.compareTo(node.key) > 0)
            node.right = add(node.right, key, value);
        else // key.compareTo(node.key) == 0
            node.value = value;

        return node;
    }


    @Override
    public v remove(k key) {
        return null;
    }

    private Node remove(Node node,k key,v value){
        if (node == null) {
            return null;
        }
        if(key.compareTo(node.key) > 0){
            node.right = remove(node.right,key,value);
            return node;
        } else if (key.compareTo(node.key) < 0) {
            node.left = remove(node.left,key,value);
            return node;
        }else { //==
            //left is null
            if (node.left == null) {
                Node right = node.right;
                node.right = null;
                size--;
                return right;
            }
            //right is null
            if (node.right == null) {
                Node left = node.left;
                node.left = null;
                size--;
                return left;
            }
            //left or right aren,t null
            Node maxmum = maxmum(node.left);
            maxmum.left = removemax(node.left);
            node.left = node.right = null;
            return maxmum;

        }
    }
    
    private Node getNode(Node node,k key){
        if (node == null) {
            return node;
        }
        if(key.equals(node.key)){
            return node;
        }
        else if(key.compareTo(node.key) > 0){
            return getNode(node.left,key);
        } else {//(key.compareTo(node.key) < 0) 
            return getNode(node.right,key);
        }
    }

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

    @Override
    public v get(k key) {
        return getNode(root,key).value;
    }

    @Override
    public void set(k key, v newValue) {
        Node node = getNode(root, key);
        if (node == null) {
            throw new IllegalArgumentException("key is over the size");
        }
        node.value = newValue;
    }

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

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