《Java数据结构和算法》学习笔记(4)——链表

于 2008-12-28 17:32:34 发布
阅读量131 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 学习笔记 文章标签： 数据结构 算法 Java TDD IDEA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/iteye_20966/article/details/81656943
[b]每篇笔记都会附上随书的Applet演示程序，有算法看不明白的，可以[url="http://yuan.iteye.com/topics/download/4fbef832-a603-3ae6-be34-dd0cb2dd7750"]下载Applet[/url]运行起来（直接打开html文件即可），可以很容易地看清楚算法的每一步。[/b]
[b][size=x-large][align=center]链表[/align][/size][/b]
[b]链表[/b]简单的说就是个对象链，一个对象里包含另一个对象的引用。链表类的成员只有一个：这个链表的第一个链接点。只要通过第一个链接点，就能得到链表里所有的其它链接点。下面是一个链表的实现： 
package dsaa.array;
/**
 * @(#)LinkList.java 2008-12-27 下午07:02:17
 * 
 * @author Qiu Maoyuan
 * Link List
 */
public class LinkList<E> {

	private Link first;

	public void addFirst(E value){
		Link newElement = new Link(value);
		newElement.next = first;
		first = newElement;
	}

	public E getFirst(){
		if(isEmpty())
			throw new IllegalStateException("Linklist is empty");
		return first.element;
	}

	public boolean isEmpty(){
		return first == null;
	}

	public E removeFirst(){
		if(isEmpty())
			throw new IllegalStateException("Linklist is empty");
		E value = first.element;
		first = first.next;
		return value;
	}

	public boolean delete(E element){
		if(isEmpty())
			return false;
		Link current = first;
		Link previous = first;
		while(!element.equals(current.element)){
			if(current.next == null){
				return false;
			} else {
				previous = current;
				current = current.next;
			}
		}
		if(current == first)
			first = first.next;
		else
			previous.next = current.next;
		return true;
	}

	@Override
	public String toString(){
		StringBuilder buffer = new StringBuilder();
		Link current = first;
		while(current != null){
			buffer.append(current.toString());
			current = current.next;
		}
		return buffer.toString();
	}

	private class Link{

		private E element;

		private Link next;

		public Link(E element){
			this.element = element;
		}

		@Override
		public String toString(){
			return "[" + element.toString() + "]";
		}
	}
}

[b]双端链表[/b]与普通链表的区别就是：双端链表多了一个对链表尾部元素的引用以及一个用于在尾部增加链拉点的addLast()方法。 
package dsaa.array;
/**
 * @(#)LinkList.java 2008-12-27 下午07:02:17
 * 
 * @author Qiu Maoyuan
 * Link List
 */
public class LinkList<E> {

	private Link first;
	private Link last;

	public void addFirst(E value){
		Link newElement = new Link(value);
		if(isEmpty()){
			last = newElement;
		}
		newElement.next = first;
		first = newElement;
	}

	public E getFirst(){
		if(isEmpty())
			throw new IllegalStateException("Linklist is empty");
		return first.element;
	}

	public boolean isEmpty(){
		return first == null;
	}

	public E removeFirst(){
		E value = getFirst();
		first = first.next;
		return value;
	}

	public boolean delete(E element){
		if(isEmpty())
			return false;
		Link current = first;
		Link previous = first;
		while(!element.equals(current.element)){
			if(current.next == null){
				return false;
			} else {
				previous = current;
				current = current.next;
			}
		}
		if(current == first)
			first = first.next;
		else
			previous.next = current.next;
		if(current == last)
			last = previous;
		return true;
	}

	public void addLast(E value){
		Link newElement = new Link(value);
		if(isEmpty()){
			first = newElement;
		}else{
			last.next = newElement;
		}
		last = newElement;
	}

	@Override
	public String toString(){
		StringBuilder buffer = new StringBuilder();
		Link current = first;
		while(current != null){
			buffer.append(current.toString());
			current = current.next;
		}
		return buffer.toString();
	}

	private class Link{

		private E element;

		private Link next;

		public Link(E element){
			this.element = element;
		}

		@Override
		public String toString(){
			return "[" + element.toString() + "]";
		}
	}
}

[b]链表的效率[/b]
链表在表头的插入和删除操作都很快，只需要O(1)级别的时间。删除指定链接点的操作和数组一样，需要O(N)级别的时间。但是链表仍然比数组快得多，因为不需要像数组那样删除元素后还要移动元素。
链表比数组优越的另一个地方是：链表需要多少长度就可以分配多少长度，而数组的长度在创建时就是固定了的。尽管有Vector或者ArrayList这样可扩展长度的数组，但是它们只允许以固定的增量扩展，在内存的使用效率上还是比链表低。
下面是一个用[b]链表实现的栈[/b]： 
package dsaa.array;

import java.util.EmptyStackException;

/**
 * @(#)LinkStack.java 2008-12-28 上午04:21:08
 * 
 * @author Qiu Maoyuan
 * Stack
 */
public class LinkStack<E> {

	private LinkList<E> stackLinkList;

	public LinkStack(){
		stackLinkList = new LinkList<E>();
	}

	public void push(E value){
		stackLinkList.addFirst(value);
	}

	public E peek(){
		E element = null;
		try{
			element = stackLinkList.getFirst();


		}catch(IllegalStateException ex){
			throw new EmptyStackException();
		}
		return element;
	}

	public E pop(){
		E element = null;
		try{
			element = stackLinkList.removeFirst();
		}catch(IllegalStateException ex){
			throw new EmptyStackException();
		}
		return element;
	}

	public boolean isEmpty(){
		return stackLinkList.isEmpty();
	}
}

[b]链表实现的队列[/b]： 
package dsaa.array;
/**
 * @(#)LinkQueue.java 2008-12-28 上午04:27:07
 * 
 * @author Qiu Maoyuan
 * Link Queue
 */
public class LinkQueue<E> {

	private LinkList<E> queueLinkList;

	public LinkQueue(int size){
		queueLinkList = new LinkList<E>();
	}

	public E peek(){
		return queueLinkList.getFirst();
	}

	public void insert(E value){
		queueLinkList.addLast(value);
	}

	public E remove(){
		return queueLinkList.removeFirst();
	}

	public boolean isEmpty(){
		return queueLinkList.isEmpty();
	}
}

一写完代码发现链表是个好东西，Stack和Queue的实现变得很容易 :idea:
在写这些笔记的代码时，我都采用TDD的方式，上一章写Stack和Queue的测试代码完全可以直接用在LinkStack和LinkQueue上。。。针对接口测试……嗯，也许一开始就应该对接口进行测试。

[b]有序链表[/b]，就不多说了，看名字就知道意思了 :) 插入元素的实现就是先遍历找准位置，然后把新增链接点的next指向previous的next（也就是current），再把previous的next指向新增的这个链接点。然后注意处理一下特殊情况（比如正好插入位置是在链表头）。有序链表的效率还是比数组高：插入时和数组一样只需要O(N)级别的查找时间，但插入之前不需要像数组那样移动元素。
下面是一个有序链表的实现： 
package dsaa.array;
/**
 * @(#)SortedLinkList.java 2008-12-28 下午02:16:35
 * 
 * @author Qiu Maoyuan
 * Sorted LinkList
 */
public class SortedLinkList<E extends Comparable<E>> {

	private Link first;

	public void add(E value){
		Link newElement = new Link(value);
		if(isEmpty()){
			first = newElement;
		}else{
			Link current = first;
			Link previous = null;
			while(!endOfLink(current) && current.element.compareTo(value)>=0){
				previous = current;
				current = current.next;
			}
			if(!endOfLink(current)){
				newElement.next = current;
			}
			if(current == first)
				first = newElement;
			else
				previous.next = newElement;
		}
	}

	public E getFirst(){
		if(isEmpty())
			throw new IllegalStateException("Linklist is empty");
		return first.element;
	}

	public boolean isEmpty(){
		return first == null;
	}

	public E remove(){
		E value = getFirst();
		first = first.next;
		return value;
	}

	public boolean delete(E element){
		if(isEmpty())
			return false;
		Link current = first;
		Link previous = first;
		while(!element.equals(current.element)){
			if(endOfLink(current.next)){
				return false;
			} else {
				previous = current;
				current = current.next;
			}
		}
		if(current == first)
			first = first.next;
		else
			previous.next = current.next;
		return true;
	}

	private boolean endOfLink(Link link) {
		return link == null;
	}

	@Override
	public String toString(){
		StringBuilder buffer = new StringBuilder();
		Link current = first;
		while(current != null){
			buffer.append(current.toString());
			current = current.next;
		}
		return buffer.toString();
	}

	private class Link{

		private E element;

		private Link next;

		public Link(E element){
			this.element = element;
		}

		@Override
		public String toString(){
			return "[" + element.toString() + "]";
		}
	}
}

给有序列表添加一个简单的带数组参数的构造方法，就可以用这个链表给一个数组进行排序，这种排序方法叫[b]表插入排序[/b]法。表插入排序法的效率比数组插入排序法（第2章的插入排序法）还高些：构造有序链表时平均需要N^2/2次比较，时间复杂度为O(N^2)，跟数组插入排序法花在“比较”上的时间级别一样，但数组插入排序法花在复制上的时间级别为O(N)，而表插入排序法花在复制上的时间级别为O(N)。 
package dsaa.array;
/**
 * @(#)SortedLinkList.java 2008-12-28 下午02:16:35
 * 
 * @author Qiu Maoyuan
 * Sorted LinkList
 */
public class SortedLinkList<E extends Comparable<E>> {

	private Link first;

	public SortedLinkList(){}

	public SortedLinkList(E[] array){
		for(E element : array){
			add(element);
		}
	}

	public void add(E value){
		Link newElement = new Link(value);
		if(isEmpty()){
			first = newElement;
		}else{
			Link current = first;
			Link previous = null;
			while(!endOfLink(current) && current.element.compareTo(value)>=0){
				previous = current;
				current = current.next;
			}
			if(!endOfLink(current)){
				newElement.next = current;
			}
			if(current == first)
				first = newElement;
			else
				previous.next = newElement;
		}
	}

	public E getFirst(){
		if(isEmpty())
			throw new IllegalStateException("Linklist is empty");
		return first.element;
	}

	public boolean isEmpty(){
		return first == null;
	}

	public E remove(){
		E value = getFirst();
		first = first.next;
		return value;
	}

	public boolean delete(E element){
		if(isEmpty())
			return false;
		Link current = first;
		Link previous = first;
		while(!element.equals(current.element)){
			if(endOfLink(current.next)){
				return false;
			} else {
				previous = current;
				current = current.next;
			}
		}
		if(current == first)
			first = first.next;
		else
			previous.next = current.next;
		return true;
	}

	private boolean endOfLink(Link link) {
		return link == null;
	}

	@Override
	public String toString(){
		StringBuilder buffer = new StringBuilder();
		Link current = first;
		while(current != null){
			buffer.append(current.toString());
			current = current.next;
		}
		return buffer.toString();
	}

	private class Link{

		private E element;

		private Link next;

		public Link(E element){
			this.element = element;
		}

		@Override
		public String toString(){
			return "[" + element.toString() + "]";
		}
	}
}

可以这样使用这个有序链表： 
	/**
	 * 表插入排序法
	 * @param <T>
	 * @param array
	 */
	@SuppressWarnings("unchecked")
	public static <T extends Comparable<? super T>> void listInsertionSort(T[] array){
		SortedLinkList linkList = new SortedLinkList(array);
		T[] newArray = (T[])new Comparable[array.length];
		for(int i=0; i<newArray.length; i++){
			newArray[i] = (T)linkList.remove();
		}
		array = newArray;
	}

[b][[/b]Java的泛型真恶心...... :( [b]][/b]
还有一种链表叫[b]双向链表[/b]，就是既可以向前遍历，又可以向后遍历的链表。这种链表的链接点内部有两个成员：previous和next。插入和删除的时候需要多操作一个引用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值