怎么用JAVA实现链表，双向链表?

[xiaoben008]

怎么用JAVA实现链表，双向链表?
能给具体代码吗??

[yes152]

我看LinkedList类里面最重要的方法就是"addBefore(){}"和"private void remove(DNode<T> curr){}"
很多方法都与它俩有关系!!
下面的代码是个双向循环链表,我在LinkedList里抄的...

package LinkedList;

import java.util.Iterator;
import java.util.ListIterator;
import java.util.NoSuchElementException;

public class MyLinkedList<T> {
	//*************************************************************
	private DNode<T> header;
	private int listSize;
	//*************************************************************
	public MyLinkedList() {
		header = new DNode<T>();
		listSize = 0;
	}
	//*************************************************************
	private static class DNode<T> {
		T nodeValue;
		DNode<T> prev;
		DNode<T> 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<T> addBefore(DNode<T> curr, T item) {
		DNode<T> newNode, prevNode;

		newNode = new DNode<T>(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<T> curr) {
		if(curr.next == curr) return;
		
		DNode<T> prevNode = curr.prev, nextNode = curr.next;
		
		prevNode.next = nextNode;
		nextNode.prev= prevNode;
	}
	
	public boolean remove(Object o) {
		for(DNode<T> 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<T> p = header.next; p != header; p = p.next)
			System.out.println(p.nodeValue);
	}
	//**************************************************************
	private class MyIterator implements Iterator<T> {
		
		public DNode<T> nextNode = header.next;
		public DNode<T> 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<T> {
		
		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<T> iterator() {
		return new MyIterator();
	}
	//**************************************************************
	public ListIterator<T> listIterator(int index) {
		return new MyListIterator(index);
	}
	//**************************************************************
	public static void main(String[] args) {
		MyLinkedList<String> t = new MyLinkedList<String>();
		t.add("A");
		t.add("B");
		t.add("C");
		t.add("D");
		//t.remove("B");
		//t.addFirst("AA");
		//t.addLast("BB");
		//t.printList();
		/*
		Iterator<String> it = t.iterator();
		while(it.hasNext()) System.out.println(it.next()); // A B C D
		*/
		
		ListIterator<String> it = t.listIterator(t.size());
		
		while(it.hasPrevious()) {
			System.out.println(it.previous()); // D C B A
		}
	}

}// MyLinkedList end~

[ooo19841080xinxin]

ArrayList 底层数组实现的,当实例化一个ArrayList是也相当实例化了一个数组
所以对元素的随即访问较快,而增加删除操作慢
LinkedList 底层实现是一个双向链表,没一个结点都包含了前一个元素的引用和后一个元素的引用和结点值
所以对元素的随即访问很慢,而增删较快

[ooo19841080xinxin]

ArrayList 底层数组实现的,当实例化一个ArrayList是也相当实例化了一个数组
所以对元素的随即访问较快,而增加删除操作慢
LinkedList 底层实现是一个双向链表,没一个结点都包含了前一个元素的引用和后一个元素的引用和结点值
所以对元素的随即访问很慢,而增删较快

[shixitong]

来学习！

[Dream_JavaWorld]

mark

[jiaping108]

链表JAVA的API就实现了,双向链表可以利用LinkedList自己写个类来实现

[butter0000]

mark

[yangkaixin1226]

[Quote=引用 6 楼 ooo19841080xinxin 的回复:]
ArrayList 底层数组实现的,当实例化一个ArrayList是也相当实例化了一个数组
所以对元素的随即访问较快,而增加删除操作慢
LinkedList 底层实现是一个双向链表,没一个结点都包含了前一个元素的引用和后一个元素的引用和结点值
所以对元素的随即访问很慢,而增删较快
[/Quote]
经典

[Daniel_Cao_]

java 实现链表和c实现一样。
就是指针变成了引用。

[zhengpeiyong]

学习了

[keke880816]

其实我觉得自己写出来最好。不然你知道它是那么一个东西，根本不明白它实现的原理。当你真正明白的时候。你会觉得这些线性结构都是这么的简单。你可以自己写出栈和队列

[Jether]

C语言的你会吗？
把指针改为引用，结构体改为对象。就差不多了。

[wangyang_software]

[Quote=引用 5 楼 ooo19841080xinxin 的回复:]
ArrayList 底层数组实现的,当实例化一个ArrayList是也相当实例化了一个数组
所以对元素的随即访问较快,而增加删除操作慢
LinkedList 底层实现是一个双向链表,没一个结点都包含了前一个元素的引用和后一个元素的引用和结点值
所以对元素的随即访问很慢,而增删较快
[/Quote]
dd

[一天十小时]

[zuoguodang]

sun都给写好了，还写啥，如果你想写就实现List接口写吧

[mst1234]

你们给代码的时候也给一下注释啊，让我们这些新学手能看懂啊

[Java2King]

JAVA JDK下的LinkedList就是基于双向链表的

[xqhrs232]

做个记号

[xqhrs232]

[Quote=引用 14 楼 keke880816 的回复:]
其实我觉得自己写出来最好。不然你知道它是那么一个东西，根本不明白它实现的原理。当你真正明白的时候。你会觉得这些线性结构都是这么的简单。你可以自己写出栈和队列
[/Quote]

说的很在理！！！

[tryitagainagain]

xizhi