数据结构与算法系列笔记四：符号表

符号表

符号表：即键值对

符号表中，键具有唯一性

符号表的实现

结点类：

符号表：

package com.example.algorithm.linear;

public class SymbolTable<Key, Value> {
          
   
  //记录首结点
  private Node head;
  //记录符号表中元素的个数
  private int N;

  private class Node {
          
   
    //键
    public Key key;
    //值
    public Value value;
    //下一个结点
    public Node next;

    public Node(Key key, Value value, Node next) {
          
   
      this.key = key;
      this.value = value;
      this.next = next;
    }
  }

  public SymbolTable() {
          
   
    this.head = new Node(null, null, null);
    this.N = 0;
  }

  public int size() {
          
   
    return N;
  }

  public void put(Key key, Value value) {
          
   
    Node n = head;
    while (n.next != null) {
          
   
      n = n.next;
      if (n.key.equals(key)) {
          
   
        n.value = value;
        return;
      }
    }

    Node newNode = new Node(key, value, null);
    Node oldFirst = head.next;
    head.next = newNode;
    newNode.next = oldFirst;
    N++;
  }

  public void delete(Key key) {
          
   
    Node n = head;
    while (n.next != null) {
          
   
      if (n.next.key.equals(key)) {
          
   
        n.next = n.next.next;
        N--;
        return;
      }
      n = n.next;
    }
  }

  public Value get(Key key) {
          
   
    Node n = head;
    while (n.next != null) {
          
   
      n = n.next;
      if (n.key.equals(key)) {
          
   
        return n.value;
      }
    }
    return null;
  }
}

有序符号表

public class SymbolTable<Key extends Comparable<Key>, Value> {
          
   
  public void put(Key key, Value value) {
          
   
    Node curr = head.next;
    Node pre = head;
    while (curr != null && key.compareTo(curr.key) > 0) {
          
   
      pre = curr;
      curr = curr.next;
    }

    if (curr != null && key.compareTo(curr.key) == 0) {
          
   
      curr.value = value;
      return;
    }
    Node newNode = new Node(key, value, curr);
    pre.next = newNode;
    N++;

  }
}