java链表list_数据结构-List：使用Java实现双向链表LinkedList

JDK中的LinkedList属于双向循环链表.

下面是使用Java来实现一个双向非循环链表.

package org.cgz.practice2;

import java.util.NoSuchElementException;

/**

* 双向非循环链表

* @author cgz

* @param

*/

public class MyLinkedList {

/**

* 定义一个结点类

* @author cgz

* @param

*/

private static class Node {

private Node prev;

private Node next;

private E data;

public Node(E data, Node prev, Node next) {

this.data = data;

this.prev = prev;

this.next = next;

}

}

private Node head;

private Node tail;

private transient int size = 0;

public MyLinkedList() {

head = tail = null;

}

/** ------------------添加------------------ **/

public void add(E e) {

addLast(e);

}

/**

* 在index处插入一个元素

*

* @param index

* @param e

*/

public void add(int index, E e) {

if (index < 0 || index > size) {

throw new IndexOutOfBoundsException("index:" + index + ",size:"+ size);

}

if (head == null) {// 当链表为空时,添加一个新结点

head = new Node(e, null, null);

tail = head;

} else {

if (index == 0) {// 在链表头部插入元素

Node newNode = new Node(e, null, head);

head.prev = newNode;

head = newNode;

} else if (index == size) { // 在链表尾部插入

Node newNode = new Node(e, tail, null);

tail.next = newNode;

tail = newNode;

} else {

Node newNode = new Node(e, null, null);

Node current = getNodeByIndex(index);

current.prev.next = newNode;

newNode.prev = current.prev;

current.prev = newNode;

newNode.next = current;

}

}

size++;

}

/**

* 在链表头添加元素

*

* @param e

*/

public void addFirst(E e) {

add(0, e);

}

/**

* 在链表末尾添加元素

*

* @param e

*/

public void addLast(E e) {

add(size, e);

}

/**

* 根据index获取所在位置的元素

* @param index

* @return

*/

private Node getNodeByIndex(int index) {

if (index < 0 || index >= size) {

throw new IndexOutOfBoundsException("index:" + index + ",size:"+ size);

}

if(size==0) {

throw new NoSuchElementException();

}

Node current;

// 如果index在链表前半段,则从表头开始查找

if (index <= size / 2) {

current = head;

for (int i = 1; i <= index; i++) {

current = current.next;

}

} else {

// 如果index在链表后半段,则从尾部查找

current = tail;

for (int i = size-1; i >= index+1; i--) {

current = current.prev;

}

}

return current;

}

/** ------------------删除------------------ **/

public boolean remove(E e) {

int index = indexOf(e);

if(index!=-1) {

remove(index);

return true;

}

return false;

}

/**

* 根据index删除元素

* @param index

* @return

*/

public E remove(int index) {

Node node = getNodeByIndex(index);

E old = null;

//删除链表头

if (index == 0) {

old = head.data;

head.next.prev = null;

head = head.next;

//删除链表尾

} else if (index == size-1) {

old = tail.data;

tail.prev.next = null;

tail = tail.prev;

} else {

old = node.data;

node.prev.next = node.next;

node.next.prev = node.prev;

}

size--;

return old;

}

/**

* 删除首元素

* @return

*/

public E removeFirst() {

return remove(0);

}

/**

* 删除尾元素

* @return

*/

public E removeLast() {

return remove(size-1);

}

/**

* 清空链表

*/

public void clear() {

Node current = head;

while(current!=null) {

Node next = current.next;

current.prev = current.next = null;

current.data = null;

current = next;

}

size = 0;

}

/** ------------------修改------------------ **/

public E set(int index, E e) {

Node oldNode = getNodeByIndex(index);

E oldData = oldNode.data;

oldNode.data = e;

return oldData;

}

/** ------------------查询------------------ **/

/**

* 返回index处的元素

* @param index

* @return

*/

public E get(int index) {

return getNodeByIndex(index).data;

}

/**

* 返回首元素

* @return

*/

public E getFirst() {

return get(0);

}

/**

* 返回最后一个元素

* @return

*/

public E getLast() {

return get(size-1);

}

/**

* 返回元素在链表中的位置

* @param e

* @return

*/

public int indexOf(E e) {

Node current = head;

int count = 0;

while(current!=null) {

if(current.data.equals(e)) {

return count;

}

current = current.next;

count++;

}

return -1;

}

/**

* 是否包含元素e

* @param e

* @return

*/

public boolean contains(E e) {

return indexOf(e)!=-1;

}

/**

* 链表是否为空

* @return

*/

public boolean isEmpty() {

return size == 0;

}

/**

* 链表长度

* @return

*/

public int size() {

return size;

}

/**

* 输出链表中的所有元素

*/

public void print() {

System.out.print(this.getClass().getSimpleName() + "：[");

Node current = head;

while(current!=null) {

System.out.print(current.data + " ");

current = current.next;

}

System.out.print("]");

}

}