java 双向链表循环_数据结构 Java循环双向链表

this来初始化链接域 prev 和 next．图⑴

prev = this; next = this;

■　判断表空的条件

public boolean isEmpty() {

return (header.prev == header || header.next == header);

}

图⑴

■　addBefore 方法是 MyLinkedList 类的重要方法, 后面的很多方法都要依靠它来实现！图⑵

private static DNode addBefore(DNode curr, T item) {

DNode newNode, prevNode;

newNode = new DNode(item);

prevNode = curr.prev;

newNode.prev = prevNode;　①

newNode.next = curr;　②

prevNode.next = newNode;　③

curr.prev = newNode;　④

return newNode;

}

图⑵

■　addFirst方法就是靠addBefore来实现的！

因为

header.next = nd'  -->图⑵

所以

curr = nd'  --> addBefore()方法

因此

prevNode = curr.prev = h  --> addBefore()方法

继续重复这四句话

newNode.prev = prevNode;　①

newNode.next = curr;　②

prevNode.next = newNode;　③

curr.prev = newNode;　④

public void addFirst(T item) {

addBefore(header.next, item);

listSize++;

}

图⑶

■　remove方法也很重要！

private void remove(DNode curr) {

if(curr.next == curr) return;

DNode prevNode = curr.prev, nextNode = curr.next;

prevNode.next = nextNode;

nextNode.prev= prevNode;

}

package LinkedList;

import java.util.Iterator;

import java.util.ListIterator;

import java.util.NoSuchElementException;

public class MyLinkedList {

//*************************************************************

private DNode header;

private int listSize;

//*************************************************************

public MyLinkedList() {

header = new DNode();

listSize = 0;

}

//*************************************************************

private static class DNode {

T nodeValue;

DNode prev;

DNode next;

public DNode() { // for header

nodeValue = null;

prev = this; // left

next = this; // right

}

public DNode(T item) {

nodeValue = item;

prev = this;

next = this;

}

}

//**************************************************************

public boolean isEmpty() {

return (header.prev == header || header.next == header);

}

public int size() {

return listSize;

}

//**************************************************************

private DNode addBefore(DNode curr, T item) {

DNode newNode, prevNode;

newNode = new DNode(item);

prevNode = curr.prev;

newNode.prev = prevNode;

newNode.next = curr;

prevNode.next = newNode;

curr.prev = newNode;

return newNode;

}

public boolean add(T item) {

addBefore(header, item);

listSize++;

return true;

}

public void addFirst(T item) {

addBefore(header.next, item);

listSize++;

}

public void addLast(T item) {

addBefore(header, item);

listSize++;

}

//**************************************************************

private void remove(DNode curr) {

if(curr.next == curr) return;

DNode prevNode = curr.prev, nextNode = curr.next;

prevNode.next = nextNode;

nextNode.prev= prevNode;

}

public boolean remove(Object o) {

for(DNode p = header.next; p != header; p = p.next) {

if(o.equals(p.nodeValue)) {

remove(p);

listSize--;

return true;

}

}

return false;

}

//**************************************************************

public void printList() {

for(DNode p = header.next; p != header; p = p.next)

System.out.println(p.nodeValue);

}

//**************************************************************

private class MyIterator implements Iterator {

public DNode nextNode = header.next;

public DNode lastReturned = header;

public boolean hasNext() {

return nextNode != header;

}

public T next() {

if(nextNode == header)

throw new NoSuchElementException("");

lastReturned = nextNode;

nextNode = nextNode.next;

return lastReturned.nodeValue;

}

public void remove() {

if(lastReturned == header)

throw new IllegalStateException("");

MyLinkedList.this.remove(lastReturned);

lastReturned = header;

listSize--;

}

}

//**************************************************************

private class MyListIterator extends MyIterator implements ListIterator {

private int nextIndex;

MyListIterator(int index) {

if(index < 0 || index > listSize)

throw new IndexOutOfBoundsException("");

//如果index小于listSize/2，就从表头开始查找定位，否则就从表尾开始查找定位

if(index < (listSize >> 1)) {

nextNode = header.next;

for(nextIndex = 0; nextIndex < index; nextIndex++)

nextNode = nextNode.next;

}else {

nextNode = header;

for(nextIndex = listSize; nextIndex > index; nextIndex--)

nextNode = nextNode.prev;

}

}

public boolean hasPrevious() {

return nextIndex != 0;

//return nextNode.prev != header;

}

public T previous() {

if (nextIndex == 0)

throw new NoSuchElementException("no");

lastReturned = nextNode = nextNode.prev;

nextIndex--;

return lastReturned.nodeValue;

}

public void remove() {

if(lastReturned == header)

throw new IllegalStateException("");

MyLinkedList.this.remove(lastReturned);

nextIndex--;

listSize--;

if(lastReturned == nextNode)

nextNode = nextNode.next;

lastReturned = header;

}

public void add(T item) {

MyLinkedList.this.addBefore(nextNode, item);

nextIndex++;

listSize++;

lastReturned = header;

}

public void set(T item) {

if (lastReturned == header)

throw new IllegalStateException();

lastReturned.nodeValue = item;

}

public int nextIndex() {

return nextIndex;

}

public int previousIndex() {

return nextIndex - 1;

}

}

//**************************************************************

public Iterator iterator() {

return new MyIterator();

}

//**************************************************************

public ListIterator listIterator(int index) {

return new MyListIterator(index);

}

//**************************************************************

public static void main(String[] args) {

MyLinkedList t = new MyLinkedList();

t.add("A");

t.add("B");

t.add("C");

t.add("D");

//t.remove("B");

//t.addFirst("AA");

//t.addLast("BB");

//t.printList();

/*

Iterator it = t.iterator();

while(it.hasNext()) System.out.println(it.next()); // A B C D

*/

ListIterator it = t.listIterator(t.size());

while(it.hasPrevious()) {

System.out.println(it.previous()); // D C B A

}

}

}// MyLinkedList end~

分享到：

2008-03-08 17:33

浏览 2918

评论