线性表-链式实现-循环链表

循环链表是另一种形式的链式存贮结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。（摘自百度百科）

由于循环链表的最后一个节点指向头结点，所以在遍历的时候就不能通过next是否为空来判断遍历是否结束，而应该判断最后一个元素的next是否和第一个元素相等。

循环链表的好处在于从任一节点出发，可以到达列表中的所有节点。

下面开始介绍实现的代码。

public class LoopLinkList<T> implements ListBase<LinkedNode<T>> {
	
	private int mSize = 0;
	private LinkedNode<T> root = new LinkedNode<>();
	private LinkedNode<T> rear;
	// 定义几个异常
	private Exception mSTZeroException = new Exception("数值必须大于0");
	private Exception mBTLengthException = new Exception("超出列表长度");
	private Exception mFirstException = new Exception("已经是第一个元素");
	private Exception mLastException = new Exception("已经是最后一个元素");

	@Override
	public void clearList() {
		root.next = null;
		mSize = 0;
	}

	@Override
	public boolean isEmpty() {
		return mSize == 0;
	}

	@Override
	public int size() {
		return mSize;
	}

	@Override
	public LinkedNode<T> get(int index) throws Exception {
		if(index > mSize - 1)
			throw mBTLengthException;
		if(index < 0)
			throw mSTZeroException;
		LinkedNode<T> currentNode = root.next;
		for(int i=0; i<index; i++) {
			currentNode = currentNode.next;
		}
		return currentNode;
	}

	@Override
	public LinkedNode<T> preElem(LinkedNode<T> t) throws Exception {
		if(root.next.equals(t)) 
			throw mFirstException;
		LinkedNode<T> preNode = root.next;
		for(int i=0; i<mSize; i++) {
			if(preNode.next.equals(t))
				return preNode;
			preNode = preNode.next;
		}
		return null;
	}

	@Override
	public LinkedNode<T> nextElem(LinkedNode<T> t) throws Exception {
		if(t.next.equals(root.next)) {
			throw mLastException;
		}
		return t.next;
	}

	@Override
	public void add(int index, LinkedNode<T> t) throws Exception {
		if(index > mSize)
			throw mBTLengthException;
		if(index < 0)
			throw mSTZeroException;
		mSize++;
		// 如果这是第一个元素，那么同时需要设定它为最后一个元素，并指向自己
		if(root.next == null) {
			root.next = t;
			rear = t;
			t.next = t;
			return;
		}
		// 如果要插入最后一个位置，那么需要改变最后一个节点的指针
		if(index == mSize - 1) {
			t.next = rear.next;
			rear.next = t;
			rear = t;
			return;
		}
		LinkedNode<T> preNode = root.next;
		for(int i=0; i<index - 1; i++) {
			preNode = preNode.next;
		}
		t.next = preNode.next;
		preNode.next = t;
	}

	@Override
	public void remove(int index) throws Exception {
		if(index > mSize - 1)
			throw mBTLengthException;
		if(index < 0)
			throw mSTZeroException;
		mSize--;
		// 如果要删除第一个元素，需要做两步操作
		// 1. 将root.next指向第二个节点
		// 2. 将最后一个节点的next指向第二个节点
		if(index == 0) {
			root.next = root.next.next;
			rear.next = root.next;
			return;
		}
		LinkedNode<T> preNode = root.next;
		// 找到要删除的前一个节点
		for(int i=0; i<index-1; i++) {
			 preNode= preNode.next;
		}
		// 如果要删除的是最后一个元素，要做相应的处理
		if(preNode.next.equals(rear)) {
			rear = preNode;
		}
		preNode.next = preNode.next.next;
	}

	@Override
	public void printAll() {
		LinkedNode<T> currentNode = root.next;
		for(int i=0; i<mSize; i++) {
			System.out.print(currentNode.value + "    ");
			currentNode = currentNode.next;
		}
	}

}

至此，循环链表就完成了。

使用起来也很简单。

	public static void main(String[] args) throws Exception {
		LoopLinkList<String> list = new LoopLinkList<>();
		for(int i=0; i<10; i++) {
			list.add(i, new LinkedNode<String>("" + i));
		}
		System.out.println(list.preElem(list.get(1)).value);
		list.printAll();
	}

下一章将实现双向链表。