初始数据结构之符号表_Java（无序符号表、有序符号表）

符号表

• 结构

键值对，仅此而已，一个key一个value组成，下边演示的是通过链表形式实现的符号表。并且符号表要求key唯一。

• 自己实现符号表抽象类

/**
 * 符号表（基于链表）：符号表最主要的目的就是将一个key和一个value联系起来，共同组成一个键值对数据，允许我们根据key来查找value，并且key具有唯一性
 * @author : LiangJie
 * @date : 2022/5/2 22:56
 */
public abstract class SymbolTable<K, V> {

    // 头部节点
    protected Node<K, V> headNode;
    // 符号表元素个数
    protected int size;

    public SymbolTable() {
        this.headNode = new Node<>(null, null, null);
        this.size = 0;
    }

    /**
     * 获取符号表中键值对的个数
     * @return
     */
    public int size() {
        return this.size;
    }

    /**
     * 根据key找到value
     * @param key 键
     * @return
     */
    public V get(K key) {
        Node<K, V> temp = this.headNode;
        while (temp.next != null) {
            temp = temp.next;
            if (temp.key.equals(key)) {
                return temp.value;
            }
        }
        return null;
    }

    /**
     * 向符号表中插入一个键值对
     * @param key 键
     * @param value 值
     */
    public abstract void put(K key, V value);

    /**
     * 根据key删除键值对
     * @param key
     */
    public void delete(K key) {
        Node<K, V> preNode = this.headNode;
        Node<K, V> currentNode;
        while (preNode.next != null) {
            currentNode = preNode.next;
            if (currentNode.key.equals(key)) {
                preNode.next = currentNode.next;
                this.size --;
                return ;
            }
            preNode = currentNode;
        }
    }


    /**
     * 内部节点类
     * @param <K> 键泛型
     * @param <V> 值泛型
     */
    class Node<K, V> {
        K key;
        V value;
        Node<K, V> next;

        public Node(K key, V value, Node<K, V> next) {
            this.key = key;
            this.value = value;
            this.next = next;
        }
    }
}

无序符号表

• 特点

元素的插入没有顺序，通常新增元素为直接插入在头节点之后。

• 自己实现无序符号表

/**
 * 普通符号表
 * @author : LiangJie
 * @date : 2022/5/1 21:44
 */
public class NormalSymbolTable<K, V> extends SymbolTable<K, V> {

    /**
     * 向符号表中插入一个键值对
     * @param key
     * @param value
     */
    public void put(K key, V value) {
        Node<K, V> temp = this.headNode;
        // 确定key的唯一性，key存在就进行值的替换
        while (temp.next != null) {
            temp = temp.next;
            if (temp.key.equals(key)) {
                temp.value = value;
                return ;
            }
        }
        // key不存在，就从头部新增一个节点
        temp = this.headNode.next;
        Node<K, V> currentNode = new Node<K, V>(key, value, temp);
        this.headNode.next = currentNode;
        this.size ++;
    }
}

有序符号表

• 特点

元素插入时是按照key的顺序进行放置的。

• 自己实现有序符号表

/**
 * 有序符号表：元素根据key进行排序
 * @author : LiangJie
 * @date : 2022/5/3 10:46
 */
public class OrderSymbolTable<K extends Comparable<K>, V> extends SymbolTable<K, V>{

    /**
     * 向符号表中有序的插入一个键值对
     * @param key
     * @param value
     */
    @Override
    public void put(K key, V value) {
        Node<K, V> preNode = this.headNode;
        Node<K, V> currentNode = this.headNode.next;
        while (currentNode != null) {
            if (key.compareTo(currentNode.key) < 0) break;
            if (currentNode.key.equals(key)) {
                currentNode.value = value;
                return;
            }
            preNode = currentNode;
            currentNode = currentNode.next;
        }
        Node<K, V> newNode = new Node<K, V>(key, value, currentNode);
        preNode.next = newNode;
        this.size ++;
    }
}