LinkedList getFirstElement 和 getLastElement 方法

Question

我需要编写一个 Java 程序（class LinkedList），它应该在不使用 import List 的情况下完成所有工作，我已经尝试过，但我不确定它们是否有效.

有人可以帮助我吗？特别是 getFirstElement 和 getLastElement 方法。

这是我的 classes:

package main.java.a3;

public interface List<E> {
    public void add(E e); 
    public void add(int index, E e);
    public int size();
    public E get(int index);
    public boolean isEmpty();
}




package main.java.a3;

    import java.util.NoSuchElementException;

    public class LinkedList<E> implements List<E>{

        private ListNode head;

        @Override
        public void add(E e) {
            if(e == null){
                throw new NullPointerException("Element was null");
            }   
            if(head == null){
                head = new ListNode(e,null);
            }else{  
                    ListNode temp = head;
                    while(temp.next!=null){
                        temp=temp.next;
                    }
                    temp.setNext(new ListNode(e,null));
                }
        }

        @Override
        public void add(int index, E e) {
            if(e == null) {
                throw new NullPointerException("Element was null!");
            }
            else if(index<0){
                throw new IndexOutOfBoundsException("Index was negative");
            }
            else if(index>=size() + 1){
                throw new IndexOutOfBoundsException("Index was bigger than size");  
            } else {
                ListNode temp = head;
                while(temp.next != null) {
                    temp = temp.next;
                }
                temp.setNext(new ListNode(e, null));
            }

        }

        @Override
        public int size() {
            int size = 0;
            ListNode temp = head;
            while(temp != null) {
                size++;
                temp = temp.getNext();
            }  
               return size;
        }

        @Override
        public E get(int index) {
            if(index<0){
                throw new IndexOutOfBoundsException("Index was negative");
            }
            if(index>=size()){
                throw new IndexOutOfBoundsException("Index was bigger than size");  
            }
            ListNode temp = head;
            for (int i = 0; i<index;i++){
                temp = temp.next;
            }
            return temp.data;
        }

        @Override
        public boolean isEmpty() {
            if(head == null) {
                return true;
            } else {
                return false;
            }
        }

                // innere Klasse        
                        private class ListNode{
                            E data;
                            ListNode next;

                            public ListNode(E data, ListNode next){
                                setData(data);
                                setNext(next);
                            }

                            public void setData(E data){
                                this.data = data;
                            }

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

                            public E getData() {
                                return data;
                            }

                            public ListNode getNext() {
                                return next;
                            }

                        }
                // innere Klasse    

        public String toString() {
                return head.toString(); 
        }

        public void addFirst(E elem) {
            if(elem == null) {
                throw new NullPointerException("Element was null!");
            } else {
                ListNode temp = new ListNode(elem, head);
                if(head != null) {
                    temp.setNext(head);
                }
                head = temp;
            }
        }

        public void addLast(E elem) {
            if(elem == null) {
                throw new NullPointerException("Element was null!");
            } else {
                ListNode tail = new ListNode(elem, null);
                while(head != null) {
                    tail.getNext();
                    if(tail.getNext() == null) {
                        tail.setNext(head);
                    }
                } 
            }
        }

        public E getFirst() {
            if(head == null) {
                throw new NoSuchElementException("Element was null!");
            }else {
                return (E) head;
            }

        }

        public E getLast(){
            E elem = null;
            ListNode tail = new ListNode(elem, null);
            if(tail == null) {
                throw new NoSuchElementException("Element was null!");
            }
            return (E) tail;
        }


    }

Answer 1

在 getFirst 中，您将 head 元素转换为 E，并且 head 的类型为 ListNode。您需要 return head.data，而不是 head 本身。也就是说，如果你真的想要值，而不是元素，如果你想要元素，那么只需 return head 并将 return 类型更改为 ListNode.

我不明白你的 getLast 不过，你正在创建一个新元素，然后检查它是否为 null (?)，然后在它为 [=15= 时再次将其转换为 E ].您需要遍历整个列表以找到最后一个元素，然后 return 它，例如：

ListNode temp = head;
while(temp.next != null)
  temp = temp.next;
return temp.data;

然后就像我之前写的那样，您可以 return 元素或值。当然，您需要处理可能的空指针，例如 head 为空等，但您知道这一点。

Answer 2

有两个选项，迭代选项和恒定时间选项。

在Iterative中你有一个头指向第一个节点，所以获取第一个元素只是调用head.data()，但是对于最后一个元素您必须使用 while/for 循环进行迭代，直到 currentNode.next()!=null

在 Constant-time 选项中，您有两个指针，一个指向头部，另一个指向最后一个元素。要获取第一个元素，它与迭代方式相同，但要获取最后一个元素，您必须使用指向 return 值的 last 指针。这里复杂的事情是控制 adding/removing 个元素来更新 de last 节点。

一个非常基本的例子可以是：

public class LinkedList<E> implements List<E>{
    private ListNode<E> head;
    private ListNode<E> last;
    private int size;

    public E getFirst(){
        if(head!=null)
            return head.data();
        else
            return null;
    }

    public E getIterativeLast(){
        if(head!=null){
            ListNode<E> last =  head;
            for(;last.next()!=null; last=last.next());
            return last.data(());

        }else{
            return null;
        }
    }


    public E getConstantLast(){
        if(last != null){
            return last.data();
        }else{
            return null;
        }

    }

    public void add(E elem){
        LastNode<E> newElem = new LastNode(elem);
        if(head == null){
            head = last = newElem;
        }else{
            last.setNext(newElem);
            last = newElem:
        }
        size++;
    }

}

"Graphically" 可能是这样的：

head ---> n1|->n2|->null
               /
last ---------/


head ---> n1|->n2|->n3->null
                    /
last --------------/

Answer 3

getFirstElement() 和 getLastElement()

/* 假设 link 列表中的元素 存储在 变量 data 节点 class */

public E getFirst() {
            if(head == null) {
                throw new NoSuchElementException("Element was null!");
            }else {
                return (E) head.data;
            }

        }

        public E getLast(){
            if(head == null) {
                throw new NoSuchElementException("Element was null!");
            }
            else{
                for(Node iterate=head; iterate!=null; iterate=iterate.next){
                    return (E) iterate.data;
                }

            }
        }

LinkedList getFirstElement 和 getLastElement 方法

LinkedList getFirstElement and getLastElement Methods

java

interface

linked-list

inner-classes