Java - 双链表中公共 int indexOf(T element) 的编写方法

Question

下面我有一个双链表的 int indexOf(T element) 方法。我需要有关代码的帮助以确保其正常运行。该方法应返回列表中第一次出现的元素，如果元素不在列表中，则返回 -1。下面是它使用的节点类。 IUDoubleLinkedList.java 类实现了 IndexedUnsortedList.java，这是 indexOf 方法的来源。我尝试使用我的单链表类中的 indexOf 方法，但它不一样，所以我希望了解它为什么会有所不同以及使用的代码在单链表和双链表之间是不同的。

public class IUDoubleLinkedList<T> implements IndexedUnsortedList<T> {
private Node<T> head, tail;
private int size;
private int modCount;

public IUDoubleLinkedList() {
    head = tail = null;
    size = 0;
    modCount = 0;

这是 indexOf(T element) 方法

    @Override
public int indexOf(T element) {
    // TODO Auto-generated method stub
    return 0;
}

下面是它使用的 Node.java 类

public class Node<T> {
private Node<T> nextNode;
private T element;
private Node<T> prevNode;

/**
 * Creates an empty node.
 */
public Node() {
    nextNode = null;
    element = null;
}

/**
 * Creates a node storing the specified element.
 *
 * @param elem
 *            the element to be stored within the new node
 */
public Node(T element) {
    nextNode = null;
    this.element = element;
    setPrevNode(null);
}

/**
 * Returns the node that follows this one.
 *
 * @return the node that follows the current one
 */
public Node<T> getNextNode() {
    return nextNode;
}

/**
 * Sets the node that follows this one.
 *
 * @param node
 *            the node to be set to follow the current one
 */
public void setNextNode(Node<T> nextNode) {
    this.nextNode = nextNode;
}

/**
 * Returns the element stored in this node.
 *
 * @return the element stored in this node
 */
public T getElement() {
    return element;
}

/**
 * Sets the element stored in this node.
 *
 * @param elem
 *            the element to be stored in this node
 */
public void setElement(T element) {
    this.element = element;
}

@Override
public String toString() {
    return "Element: " + element.toString() + " Has next: " + (nextNode != null);
}

public Node<T> getPrevNode() {
    return prevNode;
}

public void setPrevNode(Node<T> prevNode) {
    this.prevNode = prevNode;
}

}

Answer 1

查看以下代码，希望对你有所帮助！

在头部和尾部插入项目

public void insertItem(T elem) {
    /* if head and tail both are null*/
    if(head == null || tail == null) {
        head = new Node<T>(elem);   
        tail = new Node<T>(elem);
    }else {         
        Node<T> tempItem = new Node<T>();
        tempItem.setElement(elem);  
        /* insert at head end /*                    
        tempItem.setNextNode(head);
        head.setPrevNode(tempItem);
        head = tempItem;
        
        Node<T> tempItem1 = new Node<T>();
        tempItem1.setElement(elem);         
        /* append at tail end */
        tail.setNextNode(tempItem1);
        tempItem1.setPrevNode(tail);
        tail = tempItem1;
                
    }       
    
    size += 1;
}   

从头端打印项目

    public void printItemsFromHead() {
    while(head != null) {
        System.out.print(head.getElement()+" --> ");
        head = head.getNextNode();
    }
   }

从尾部打印项目

public void printItemsFromTail() {
    Node<T> temp = null;
    while(tail != null) {
        temp = tail;
        System.out.print(tail.getElement()+" --> ");
        tail = tail.getPrevNode();
    }
    /*System.out.println();
    while(temp != null) {
        System.out.print(temp.getElement()+" --> ");
        temp = temp.getNextNode();
    }*/
  }

indexOf函数的实现

  @Override
   public int indexOf(T element) {
    int result = -1;
    int headIndex = 0;
    int tailIndex = size;
    while(head != null && tail != null) {
        if(head.getElement().equals(element)) {
            result = headIndex;
            break;
        }
        /*
        if(tail.getElement().equals(element)) {
            result = tailIndex;
            break;
        } */
        head = head.getNextNode();
        tail = tail.getPrevNode();
        
        headIndex += 1;
        tailIndex -= 1;
    }
    return result;
  }

驱动类

public class Driver {
@SuppressWarnings({ "rawtypes", "unchecked" })
public static <T> void main(String[] args) {
    UDoubleLinkedList uDoubleLinkedList = new UDoubleLinkedList();
    
    
    uDoubleLinkedList.insertItem(1);
    
    uDoubleLinkedList.insertItem(2);
    
    uDoubleLinkedList.insertItem(3);
    uDoubleLinkedList.insertItem(4);
    
    uDoubleLinkedList.insertItem(5);        
    
    System.out.println(uDoubleLinkedList.indexOf(1));
    
  }
 }