二十一 集合与映射及其实现

集合：

 

映射：

 

 

Map接口：

 

映射的两种结构复杂度分析：

 

 集合的实现：

1 基于链表实现Set

package com.lt.datastructure.Set;

import com.lt.datastructure.LinkedList.LinkedList;

public class LinkedListSet<E> implements Set<E>{
    //基于链表 
    private LinkedList<E> list;
    //构造
    public LinkedListSet(){
        list = new LinkedList<>();
    }
    
    @Override
    public int getSize() {
        return list.getSize();
    }
    
    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }
    
    @Override
    public boolean contains(E e) {
        return list.contains(e);
    }
    
    @Override
    public void add(E e) {    
       if(!list.contains(e)){
           list.addFirst(e);
       }    
    }

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

 

2 基于链表实现Map:

package com.lt.datastructure.Set;

import java.util.ArrayList;

/**
 *  链表实现映射
 */
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){
            this(key,null,null);
        }
        
        public Node(){
            this(null,null,null);
        }
        
        @Override
        public String toString() {
            return key.toString()+" : "+value.toString();
        }
        
    } 
    private Node dummyhead;
    private int size;
    
    public LinkedListMap() {
      dummyhead = new Node();
      size = 0;
    }
    
    @Override
    public int getSize() {
        return size;
    }
    
    @Override
    public boolean isEmpty() {
        return size==0;
    }
    
    //根据key找到结点
    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 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 add(K key, V value) {
        
        Node node = getNode(key);
        if(node==null){
            dummyhead.next = new Node(key,value,dummyhead.next);
            size++;
        }
        else//重复的结点，可以抛异常，亦可以改变原映射的值
            node.value = value;
    }
    
    @Override
    public void set(K key, V value) {
          Node node = getNode(key);
        if(node == null){
            throw new IllegalArgumentException("node doesnt exsist!");
        }
        node.value = value;
     } 
    
    @Override
    public V remove(K key) {
        
        Node prev = 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;
    }

}

 

 

 

3 基于二分搜索树实现Set：

package com.lt.datastructure.Set;
/**
 *  基于二分搜索树的集合实现 
 *@param <E>
 */
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);    
    }
}

 

4 基于二分搜索树的map的实现：

package com.lt.datastructure.Set;
/*
 * 树实现映射
 */
public class BSTMap<K extends Comparable<K> , V> implements Map<K, V> {
   
    public 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;
    }
    
    @Override
    public int getSize() {
        return size;
    }
    
    @Override
    public boolean isEmpty() {
        return size==0;
    }
    
    @Override
    public void add(K key, V value) {
      add(root,key,value);    
    }
    
    //向以node为根的二叉树中插入元素(key,value)，递归算法
    //返回插入新结点后二叉树的根
    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{
            node.value = value;
        }
        //二叉树不允许重复,但映射的值可以改变
        return node;
    }
    //返回以node为根节点的二叉树中，key所在的结点,递归实现
    private Node getNode(Node node , K key){
        if(node==null){
            return null;
        }
        
        if(key.compareTo(node.key)==0){
            return node;
        }
        else if(key.compareTo(node.key)<0){
            return getNode(node.left,key);
        }
        else{ //if(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) {
        Node node = getNode(root, key);
        return node==null? null:node.value;
    }
    
    @Override
    public void set(K key, V newvalue) {
        Node node = getNode(root,key);
        if(node==null){
            throw new IllegalArgumentException(key+" doesnt exsisit ! ");
        }
        node.value = newvalue;
    }
    //返回以node为根的二分搜索树最小值所在结点
    private Node minimum(Node node){
        if(node.left == null){
            return node;
        }
        return minimum(node.left);
    }
    
    //删掉以node为根的二分搜索树的最小节点
    //返回删除节点后新的二分搜索树的根
    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;
    }
    
    //在二分搜树中删除元素为e的结点
    @Override
    public V remove(K key) {
        Node node = getNode(root,key);
        if(node != null){
            root = remove(root,key);
            return node.value;
        }
        return null;
    }
    //删除二分搜索树中node为根，键为key的结点
    //返回删除结点后新的二分搜索树的根
    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{//key.compareTo(node.key)=0
            //待删除节点左子树为空的情况，删除后将节点的右子树取代它的位置
            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;
            }
           //左右子树都不为空，则将该结点右子树的最小值替代该结点
           //操作后的右子树：removeMin(node.right);左子树：node.left;
           Node successor = minimum(node.right);
           successor.right = removeMin(node.right);
           successor.left  = node.left;
           node.left = node.right = null;
           return successor;
        }
        
    }
    
    public static void main(String[] args) {
           BSTMap<String, Integer> bst = new BSTMap<>();
           bst.add("1+1", 2);
           bst.add("2+2", 4);        
           
    }
}
    
    

 

转载于:https://www.cnblogs.com/ltfxy/p/10010165.html