Question

如果我使用的几个对象都是由我编写的（而不是使用Java的库），我正在开发一些能让它变得更容易的东西。我目前正在使用我的ArrayList<ArrayList>类和我的MyHashTable类来实现LinkedList对象（我们可以调用Node）。这是我到目前为止正确实现的LinkedList课程：

public class LinkedList{
    Node start;
    int length;

    public LinkedList(){
        start = new Node();
        length= 0;
    }

    public void addNode(Node node){
        Node s= start;
        while (s.next != null){
            s= s.next;
        }
        s.next= node;
        length++;
    }

    public int getLength(){
        return length;
    }

    public boolean findNode(Node node){
        Node s= start;
        while(s.next != null){
            if (s == node){
                return true;
            }
            s.next= node;
        }
        return false;
    }

}

因此我无法修改此类以接受Java泛型（因此我可以创建链接列表的链接列表而不是简单的链接节点列表）。如果我应该提供Node课程的外观，请告诉我。

Answer 1

通用LinkedList只替换值的类型。您没有显示您的Node类，所以我不明白您是如何使用它的。这是一个通用链表：

class LinkedList<E> {
    static class Node<E> {
        E value;
        Node<E> next;

        Node(E value) {
            this.value = value;
        }
    }

    Node<E> head = new Node<E>(null);
    Node<E> tail = head;
    int size;

    void add(E value) {
        tail = tail.next = new Node<E>(value);
        size++;
    }

    E get(int index) {
        if(index < 0 || size <= index)
            throw new OutOfBoundsException(index);

        Node<E> node = head.next;
        while(index > 0) {
            node = node.next;
            index--;
        }

        return node.value;
    }
}

但是我不确定你的意思是把它放到ArrayList中。 ArrayList完全不同，它是一个自动调整大小的数组：

class ArrayList<E> {
    Object[] array = new Object[10];
    int size;

    void add(E value) {
        if(size >= array.length) {
            array = Arrays.copyOf(array, (int)(size * 3L / 2L));
        }

        array[size++] = value;
    }

    E get(int index) {
        return (E)array[index];
    }
}

虽然我想你可以通过使用多维数组来破解哈希表，但我不推荐它。您不能只使用2 ^ 32个元素来实例化数组，这意味着您必须管理交叉点。我没有看到一个ArrayList＆lt; ArrayList＆gt;可能是一个工作的哈希表。这是一个类似于Java的简单哈希表实现。该表是一系列链表。

class HashTable<K, V> {
    static class Entry<K, V> {
        K key;
        V value;

        Entry<K, V> next;

        Entry(K key, V value) {
           this.key = key;
           this.value = value;
        }
    }

    Entry[] table = new Entry[8];
    int size;

    void put(K key, V value) {
        Entry<K, V> entry = table[indexFor(key)];
        while(entry != null) {
            if(entry.key.equals(key)) {
                entry.value = value;
                return;
            }

            entry = entry.next;
        }

        resizeIfNeeded();

        addEntry(new Entry<K, V>(key, value));
        size++;
    }

    void addEntry(Entry<K, V> newEntry) {
        int index = indexFor(newEntry.key);
        Entry<K, V> entry = table[index];

        if(entry == null) {
            table[index] = newEntry;

        } else {
            while(entry.next != null)
                entry = entry.next;

            entry.next = newEntry;
        }
    }

    void resizeIfNeeded() {
        if(size < table.length)
            return;

        Entry[] old = table;
        table = new Entry[old.length << 1];

        for(Entry<K, V> entry : old) {
            while(entry != null) {
                addEntry(entry);
                Entry<K, V> next = entry.next;
                entry.next = null;
                entry = next;
            }
        }
    }

    V get(K key) {
        Entry<K, V> entry = table[indexFor(key)];
        while(entry != null) {
            if(entry.key.equals(key))
                return entry.value;

            entry = entry.next;
        }

        return null;
    }

    int indexFor(K key) {
        return key.hashCode() & table.length - 1;
    }
}

正如我在评论中提到的，这听起来像XY problem。我没有看到这比使用Java数据结构更容易。也许你有一个不同的问题要问。

如何在Java中实现我自己的LinkedList <linkedlist>数据结构？</linkedlist>

1 个答案: