java 单链表和双_java实现双向循环链表和单链表

参照Java SE uitil LinkedList实现了一下简单化的LinkedList

/*

* To change this template, choose Tools | Templates

* and open the template in the editor.

*/

package linkedlisttest;

/**

*

* @author Lindily

*/

public class LinkedList {

int size = 0;

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

public LinkedList() {

head.next = head.previous = head;

}

public void add(E node) {

//核心 循环双向链表

Node newNode = new Node(head.previous, node, head);   //新节点的prev指向头结点的prev 新节点的next指向头结点

newNode.previous.next = newNode;    //调整，新节点的前一个的后一个

newNode.next.previous = newNode;    //调整，新节点的后一个的前一个

size++;

}

public Node get(int index) {

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

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

}

Node node = head;

if (index < (size >> 1)) {          //index转为二进制带符号向右移动一个bit，相当于index/2

for (int i = 0; i <= index; i++) {    //head是哑元，i<=index当index=0时，返回head.next

node = node.next;           //对头结点进行迭代

}

}else{

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

node=node.previous;

}

}

return node;

}

public int size() {

return size;

}

public static void main(String[] args) {

LinkedList list = new LinkedList();

list.add(1);

list.add(2);

for (int i = 0; i < list.size; i++) {

System.out.println(list.get(i).node);

}

}

}

class Node {

E node;

Node next;

Node previous;

public Node(Node previous, E node, Node next) {

this.node = node;

this.next = next;

this.previous = previous;

}

}

//以下实现的是单链表，没有了双链表的head头指针的哑元(空元素)，但必须构造一个tail尾结点辅助。

/*

* To change this template, choose Tools | Templates

* and open the template in the editor.

*/

package linkedlisttest;

/**

*

* @author Lindily

*/

public class SingleLinkedList {

int size = 0;

Node head, tail;

public SingleLinkedList() {

head = tail = null;

}

public void add(T node) {

if (size == 0) {

head = tail = new Node(node, null);

} else {

tail.next = new Node(node, null);

tail = tail.next;

}

size++;

}

public Node get(int index) {

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

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

}

Node node = head;

for (int i = 0; i < index; i++) { //当index=0时，i不小于index(零不小于零)，于是直接return头结点，与linkedList不同，head不是哑元

node = node.next;           //对头结点进行迭代

}

return node;

}

public int size(){

return size;

}

public static void main(String[] args){

SingleLinkedList list=new SingleLinkedList();

list.add(1);

list.add(2);

list.add(3);

for(int i=0;i

System.out.println(list.get(i).node);

}

}

}

class Node {

T node;

Node next;

public Node(T node, Node next) {

this.node = node;

this.next = next;

}

}

这两个链表最大的不同就是头结点是否是哑元，以及取出元素(get函数)的时候for循环变量i的不同：

双向循环链表(和java.util包的设计一样)：由于head是哑元，因此取元素从head的下一个结点取

单向链表：head不是哑元，第一次必须取head头结点的元素，因此循环上和双向循环链表不同。也就是第一次get并没有进入for循环，直接返回了头结点，从第二次才开始进入for循环，这里要特别注意。