循环链表

循环链表

定义将单链表中终端结点的指针端由空指针指向头结点，使整个单链表形成头尾相连的环，简称循环链表。

单链表与循环链表的主要差别在于，循环的判断条件上，原来是p.next是否空，现在是
p.next是否为头结点。

1.若将头指针作为循环链表的指针，则查询第一个结点的时间复杂度为O(1)，尾结点为O(n)
2.若将尾针作为循环链表的指针，则查询第一个结点的时间复杂度为O(1)，尾结点为O(1)

定义及构造方法

public class LoopSingle<E> implements List<E>{
	private class Node{
		E data; //数据域
		Node next; //指针域
		
		public Node(E data,Node next){
			this.data = data;
			this.next = next;
		}

		public Node() {
			this(null, null);
		}
		@Override
		public String toString() {
			return data.toString();
		}
	}
	
	private Node head;	//真实头结点
	private Node rear;	//尾结点
	private int size;
	

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

add()

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++){	//-1,无虚拟结点，0时已经移动了一次
				p = p.next;
			}
			n.next = p.next;
			p.next = n;
		}
		size++;
	}

remove()

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指针在rear指针前一个
			p.next = rear.next;	//尾指针指向的给予了指针的指向
			rear = p;		//尾指针更新为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;
		
	}

get()

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

set()

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-1){	//尾修改
			 rear.data = e;
		}else{						//一般修改
			Node p = head;
			for(int i=0;i<index;i++){
				p = p.next;
			}
			 p.data = e;
		}

find()

public int find(E e) {
		if(isEmpty()){
			return -1;
		}
		Node p = head;
		int index = 0;
		while(p.next!=e){
			p = p.next;
			index++;		//p指针移到一次index下标+1
			if(p==head){	//进行判断是否移动完
				return -1;
			}
		}
		return index;		//返回元素的下标
	}

toString()

@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append("LoopSingle size="+getSize()+"\n");
		if(isEmpty()){
			sb.append("[]");
		}else {
			sb.append('[');
			Node p = head;	//p指针从头开始
			while(true){
				sb.append(p.data);	//添加p指针中的数据
				if(p.next==head){	//当重新移动到head时跳出循环
					sb.append(']');	//添加结束标志
					break;
				}else{
					sb.append(',');	//否者添加，
				}
				p = p.next;	//p指针移动
			}
		}
		return sb.toString();
	}

equals()

@Override
	public boolean equals(Object obj) {
		if(obj==null){
			return false;
		}
		if(obj==this){
			return true;
		}
		if(obj instanceof LoopSingle ){
			LoopSingle loopSingle = (LoopSingle) obj;
			if(loopSingle.getSize()==getSize()){
				for(int i=0;i<getSize();i++){
					if(loopSingle.get(i)!=get(i)){
						return false;
					}
				}
				return true;
			}
		}
		return false;