如何在Java中实现链接列表？ [重复]

Question

这个问题已经在这里有了答案：

• 如何在Java中创建链接列表数据结构？ [已关闭] 6个答案

我正在尝试用Java实现一个简单的HashTable，该哈希表使用链接列表来解决冲突，这在C语言中很容易实现，但是我不知道如何在Java中实现它，因为您不能使用指针。 。

首先，我知道这些结构已经在Java中实现，我不打算使用它，只是在这里进行培训...

所以我创建了一个元素，它是一个字符串和一个指向下一个元素的指针：

public class Element{
        private String s;
        private Element next;

        public Element(String s){
            this.s = s;
            this.next = null;
        }

        public void setNext(Element e){
            this.next = e;
        }

        public String getString(){
            return this.s;
        }

        public Element getNext(){
            return this.next;
        }

        @Override
        public String toString() {
            return "[" + s + "] => ";
        }
    }

当然，我的HashTable有一个Element数组来存储数据：

public class CustomHashTable {
    private Element[] data;

这是我的问题：

例如，我想实现一种在链接列表的末尾添加元素的方法（我知道将元素插入列表的开头会更简单，更有效，但这同样仅用于培训目的）。 没有指针我该怎么办？

这是我的代码（如果e是指针，则可以使用...）：

public void add(String s){
        int index = hash(s) % data.length;
        System.out.println("Adding at index: " + index);
        Element e = this.data[index];
        while(e != null){
            e = e.getNext();
        }
        e = new Element(s);
    }

谢谢！

Answer 1

public void add(String s){
    int index = hash(s) % data.length;
    System.out.println("Adding at index: " + index);
    Element curr = new Element(s);
    Element e = this.data[index];
    if (e == null) {
       this.data[index] = curr;
       return;
    }
    while(e.getNext() != null){
        e = e.getNext();
    }
    e.setNext(curr);
}

Answer 2

如果要编写自己的代码，请先使其实现java.util.List接口。

如果可以使用库类，请使用java.util.LinkedList。

现在，已经向我指出您正在“练习”，因此根据某些人的建议，一些好的建议可能是不可行的，但是您应该了解泛型。 我建议阅读它们，并将其构建到您的Element（节点？）和List实现中。 泛型就是以这种方式与集合一起使用的。 我从这里开始：

package list;

public class Node<T>
{
    private T value;
    private Node<T> prev;
    private Node<T> next;
    // You add the rest.
}

Answer 3

为了您的目的，这里使用的Java引用与使用C的指针没有区别。 实际上，C语言中的主要问题（或收益，取决于您问的是谁）不是指针可以指向某个东西，而是您可以使用它们进行数学运算。

仅出于指示目的，您可以在此处执行以下操作：

e.setNext(new Element(s));

代替

e = new Element(s);

（这只会让变量e指向新元素，而不会在旧元素上进行任何更改）。

你完成了

Answer 4

在方法末尾重新分配局部变量不会更改任何内容。 你需要这样的东西：

Element e = this.data[index];
while (e.getNext() != null) {
    e = e.getNext();
}

然后e引用列表末尾的元素。 创建一个新元素，并将其设置为下一个元素：

Element newElement = new Element(s);
e.setNext(newElement);

为了提高效率，我建议您考虑使用双链结节点和知道列表首尾的列表类型。 区分列表的整体（知道头，尾和计数），以及列表中的节点（知道下一个，上一个以及可能属于的列表）。

Answer 5

递归解决方案：

public class Element{
  /* ... */
  public void addTail(Element e){
    if (next == null)
      next = e; //we are at the end, add it
    else
      next.addTail(e);//let the next node take responsibility
  }
}

public void add(String s){

  int index = hash(s) % data.length;
  System.out.println("Adding at index: " + index);
  Element e = this.data[index];
  e.addTail(new Element(s));
}

Answer 6

Java中的LinkedList的工作原理如下：

有一个像这样的静态类：

private static class Entry<E> {
E element;
Entry<E> next;
Entry<E> previous;
Entry(E element, Entry<E> next, Entry<E> previous) {
    this.element = element;
    this.next = next;
    this.previous = previous;
}
}

LinkedList构造函数：

public LinkedList() {
    header.next = header.previous = header;
}

public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}

addAll方法：

public boolean addAll(Collection<? extends E> c) {
    return addAll(size, c);
}

您应该在这里检查：

private transient Entry<E> header = new Entry<E>(null, null, null);
private transient int size = 0;

private Entry<E> addBefore(E e, Entry<E> entry) {
Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
newEntry.previous.next = newEntry;
newEntry.next.previous = newEntry;
size++;
modCount++;
return newEntry;
}

private E remove(Entry<E> e) {
if (e == header)
    throw new NoSuchElementException();

    E result = e.element;
e.previous.next = e.next;
e.next.previous = e.previous;
    e.next = e.previous = null;
    e.element = null;
size--;
modCount++;
    return result;
}

private Entry<E> addBefore(E e, Entry<E> entry) {
Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
newEntry.previous.next = newEntry;
newEntry.next.previous = newEntry;
size++;
modCount++;
return newEntry;
}

public boolean add(E e) {
addBefore(e, header);
    return true;
}

Answer 7

//Single linked list implementation

public class Nodes {

    int data;
    Nodes next = null;

    public Nodes(int data) {
        this.data = data;
    }
}


public class Lists {

    static Nodes first = null;

    public static void insertBegin(int data) {
        Nodes temp = new Nodes(data);
        if(first == null) {
            first = temp;
        }
        else {
            temp.next = first;
            first = temp;           
        }
    }

    public static void insertEnd(int data) {
        Nodes temp = new Nodes(data);
        if(first == null) {
            first = temp;
        }
        else{
            Nodes n = first;
            while(n.next != null) {
                n = n.next;
            }
            n.next = temp;
        }
    }

    public static void insertPos(int pos, int data) {
        Nodes temp = new Nodes(data);
        if(first == null) {
            System.out.println("List empty. Cannot insert");
        }
        else {
            Nodes n = first;
            while(n.data != pos && n.next != null) {
                n = n.next;
            }
            if(n.data != pos){
                System.out.println("Position not found");
            }
            else {
                temp.next = n.next;
                n.next = temp;
            }
        }
    }

    public static void deleteBegin() {
        if(first == null) {
            System.out.println("List empty. Cannot delete");
        }
        else {
            first = first.next;
        }       
    }


    public static void deleteEnd() {
        if(first == null) {
            System.out.println("List empty. Cannot delete");
        }
        else {
            Nodes n = first;
            while(n.next.next != null) {
                n = n.next;
            }
            n.next = n.next.next;
        }
    }

    public static void deletePos(int pos) {
        if(first == null) {
            System.out.println("List empty. Cannot delete");
        }
        else {
            Nodes n = first;
            while(n.next.data != pos && n.next.next != null) {
                n = n.next;
            }
            if(n.next.data != pos) {
                System.out.println("Element not found. Deletion failed");
            }
            else{
                n.next = n.next.next;
            }
        }
    }

    public static void printAll() {
        System.out.println("Elements in link list");
        Nodes n = first;
        while(n != null) {
            System.out.print(n.data + "->");
            n = n.next;
        }
    }
}