java数据结构单向循环链表的实现

一、
由图可以看出，单项循环链表和普通单链表的区别在于尾节点，普通单链表的为节点指向一个空的位置，表示这个节点是链表的族最末端，而循环链表的尾节点则指向该链表的头结点，形成一个环状结构，首尾相连。
二、
1、空表的循环列表是头结点的后继指针指向首结点自身 head.next=head；
2、循环列表中，尾结点后继指针指向了头结点 rear.next=head
3、与单链表的区别还有一点，就是关于循环遍历链表时的判断条件，单链表的循环体的结束条件是p = = null，而单向循环链表的循环判断条件是p.next = = head，如下代码所示：

//单链表
Node<E> p = this.head
while(p!=null){
  }
//单向循环链表
Node<E> p = this.head
while(p.next!=head){
}

3.1首先每个链表都是有节点组成的，每个节点都包含该节点所存储的数据和该节点后继得地址，所以需要定义一个节点类

     /**
	 * 结点类
	 * @author Administrator
	 */
	public class Node<E> {
		private E data;//存储数据
		private Node next;
		public Node(E data){
			this.data=data;
		}
		public Node(E data,Node next){
			this.data=data;
			this.next=next;
		}
	}

3.2循环链表的接口与单链表一致，为线性表

/**
 * 链表的接口,包含所有
 * 链表的基本方法
 * @author Administrator
 *
 */
public interface List<E> {
	//判断链表是否为空
	boolean isEmpty();
	//链表长度
	int length();
	//获取元素
	E get(int index);
	//根据index添加元素data
	E set(int index,E data);
	//根据index添加元素data
	boolean add(E data);
	//根据index插入元素
	boolean add (int index,E data);
	//删除指定位置的元素
	E remove(int index);
	//删除指定元素
	boolean remove(E data);
	//根据data移除所有相同元素
	E removeAll(E data);
	//清空链表
	void clear();
	//是否包含特定元素
	boolean contains(E data);
	//获取元素的位置
	int indexOf(E data);
	//根据data值查询最后一个出现在顺序表的下标
	int lastIndexOf(E data);
	// 输出格式
	String toString();
}

3.3在SingLoop类中实现List接口,声明头结点和尾节点以及其构造方法

	private Node head;										//头结点
	private Node rear;										//尾节点
	private int size;											//链表的长度
	
	public LoopSingle() {
		head = null;
		rear = null;
		size = 0;
	}
	
	public LoopSingle(E[] arr) {
		this();
		for(E e:arr) {
			addLast(e);
		}
	}

判断链表是否为空：由于链表的结构特点，头结点是链表的开始位置，所有判断链表是否为空，只要判断链表的头结点是为空

public boolean isEmpty() {
		return size == 0&&head == null&&rear == null;
}

获取元素：由于链表的结构特点，获取链表首先声明变量count（从0开始）来表示结点指向的位置，需要依次按照后继指针循环直到获取结点从而取得结点存储的数据。从程序来看，链表获取元素在最坏情况下需要依次遍历所结点，最好情况下时间复杂度为O（1），最坏情况下时间复杂度O（n）。而特别注意结点的结束判断，避免死循环。

public E get(int index) {
		if(index<0||index>=size) {
			throw new IllegalArgumentException("查找角标非法");
		}
		if(index == 0){
			return head.data;
		}else if(index == size) {
			return rear.data;
		}else {
			Node p = head;
			for(int i = 0;i<index;i++) {
				p = p.next;
			}
			return p.data;
		}
}

修改指定位置的元素：在获取元素位置时，与获取元素位置相同，修改元素只是在获取元素后用新的存储数据替换旧的存储数据data。在时间复杂度上，与获取元素相同。

public void set(int index, E e) {
		if(index<0||index>=size) {
			throw new IllegalArgumentException("修改角标非法");
		}
		if(index == 0){
			head.data = e;
		}else if(index == size) {
			rear.data = e;
		}else {
			Node p = head;
			for(int i = 0;i<index;i++) {
				p = p.next;
			}
			p.data = e;
		}
}

添加元素：单链表添加元素主要分为四种场景，a.空链表插入结点；b.头结点插入元素，新增结点为头结点；c.中间情况插入节点；d.尾结点插入元素，也就是在插入在单链表末尾

public void add(int index, E e) {
		if(index<0||index>size) {
			throw new IllegalArgumentException("插入角标非法");
		}
		Node n = new Node(e,null);
		if(isEmpty()) {				//为空的情况
			head = n;
			rear = n;
			rear.next=head;
		}else if(index == 0) {		//头插
			n.next = head;
			head = n;
			rear.next = head;
		}else if(index == size){	//尾插
			n.next = head;
			rear.next = n;
			rear = n;
		}else {						//一般情况
			Node p =head;
			for(int i = 0;i<index-1;i++) {
				p = p.next;
			}
			n.next = p.next;
			p.next = n;
		}
		size++;
}

删除指定位置的元素：删除元素与插入结点类型，首先要先找到要删除指定位置的索引位置分为三种情况，删除头结点，删除中间位置结点，删除尾结点

public E remove(int index) {
		if(index<0||index>=size) {
			throw new IllegalArgumentException("删除角标非法");
		}
		E res = null;
		if(size == 1) {
			res = head.data;
			head = null;
			rear = null;
		}else if(index == 0) {
			res = head.data;
			head = head.next;
			rear.next = head;
		}else if(index == size-1) {
			res = rear.data;
			Node p = head;
			while(p.next!=rear) {
				p=p.next;
			}
			p.next = rear.next;
			rear = p;
		}else {
			Node p = head;
			for(int i = 0;i<index -1;i++) {
				p = p.next;
			}
			Node del = p.next;
			res = del.data;
			p.next = del.next;
		}
		size--;
		return res;
}

查找链表中是否存在某个元素：如果链表为空则返回-1，否则定义一个指针从第一个节点开始判断，每部循环都对index进行+1操作，如果查找到，则返回index，否则返回-1

public int find(E e) {
		if(isEmpty()) {
			return -1;
		}
		Node p = head;
		int index = 0;
		while(p.data!=e) {
			p = p.next;
			index++;
			if(p == head) {
				return -1;
			}
		}
		return index;
}

清空链表：可以直接使头结点和尾节点指向空，size=0。

public void clear() {
		head = null;
		rear = null;
		size = 0;
	}

最后输出格式：

	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append("loopSingle:size = " + getsize() + "\n");
		if(isEmpty()) {
			sb.append("[]");
		}else{
			sb.append('[');
			Node p = head;
			while(true) {
				sb.append(p.data);
				if(p.next == head) {
					sb.append(']');
					break;
				}else {
					sb.append(',');
				}
				p = p.next;
			}
		}
		return sb.toString();	
	}

总结：单向循环链表与普通链表的区别主要是在尾结点的判断，查询的时间复杂度都为O（1），插入和删除的时间复杂度为O（n）