java实现循环链表

在单链表中，如果把终端节点的引用指向头结点，就使整个链表形成以个环。这种链表称为循环链表。

链表中的节点代码：

public class Node <T>{

private T data; //数据

private Node<T> next; //下一个节点的引用

public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
public Node<T> getNext() {
return next;
}
public void setNext(Node<T> next) {
this.next = next;
}

}

链表源代码：

/**
* 循环链表
* @author Administrator
*
*/
public class CircularLinkedList <T>{

private Node<T> head; //头指针

@SuppressWarnings("unused")
private Node<T> rear; //尾指针

/**
* 构造空循环链表
*/
public CircularLinkedList(){

head = new Node<T>();
head.setNext(head);

}

/**
* 初始化循环链表(尾插法)
* @param e 初始数据
* @param n	大小
*/
public CircularLinkedList(T[] e,int n){
head = new Node<T>();
Node<T> s = head; //工作指针
Node<T> s2 = null;
for (T t : e) {
s2 = new Node <T>();
s2.setData(t);
s.setNext(s2);
s = s2;
}

s.setNext(head); //尾节点指向头指针，形成环
if(n != 0)
rear = s;  //把尾节点引用赋值给尾指针(方便以后找到尾节点)
}

/**
* 插入元素
* @param e 插入的元素
* @param index 插入的位置
* @return
*/
public boolean insert(T e,int index){

if(index < 1 || index > size()+1)
throw new ArrayIndexOutOfBoundsException();
Node<T> s = head;
Node<T> s2= null;
int count = 0;

while(count < index - 1){

s = s.getNext();
count ++;
}

s2 = new Node<T>();
s2.setData(e);
s2.setNext(s.getNext());
s.setNext(s2);
if(index == size()+1) //判断插入位置为最后
rear = s2; //将新尾节点的引用赋值给尾指针
return true;
}

/**
* 按位置删除元素
* @param index 位置
* @return
*/
public boolean remove(int index){

if(index < 1 || index > size())
throw new ArrayIndexOutOfBoundsException();

int count = 0; //计数器
Node<T> s = head;
while(count < index -1){
s = s.getNext();
count ++;
}

s.setNext(s.getNext().getNext());

if(index == size()&&size()!=1)
rear = s;
return true;
}

/**
* 给定元素删除
* @param e
* @param index
* @return
*/
public boolean remove(T e,int index){

if(index < 0 || index > size())
throw new ArrayIndexOutOfBoundsException();
int count = 0;
Node<T> s = head;
while(count < index - 1){
s = s.getNext();
count ++;
}

s.setNext(s.getNext().getNext());
//是否删除的是最后一个元素
if(index == size()&&index!=1){
rear = s;
}
return true;
}

/**
* 返回元素在链表中的位置
* @param e
* @return
*/
public List<Integer> locate(T e){

List<Integer> list = new ArrayList<Integer>();
Node<T> s = head;
int count = 0; //计数器
while(!s.getNext().equals(head)){
count ++;
s = s.getNext();
if(s.getData().equals(e))
list.add(count);
}
return list;
}

/**
* 按位置查询元素
* @param index
* @return
*/
public T get(int index){

if(index < 1 || index > size())
throw new ArrayIndexOutOfBoundsException();

int count = 0;
Node<T> s = head;
while(count < index){
s = s.getNext();
count ++;
}

return s.getData();
}

/**
* 替换元素
* @param index
* @param e
* @return
*/
public boolean replace(int index,T e){

if(index < 1 || index > size())
throw new ArrayIndexOutOfBoundsException();

Node<T> s = head;
int count =0;
while(count < index){
s= s.getNext();
count ++;
}

s.setData(e);
return true;
}

/**
* 判断链表是否为空
* @return
*/
public boolean isEmpty(){

if(head.getNext().equals(head))
return true;
return false;
}

/**
* 获取链表的长度
* @return
*/
public int size(){

Node<T> s = head;
int size = 0;
while(true){
s = s.getNext();
if(s.equals(head))
break;
else
size++;
}
return size;
}

@Override
public String toString(){

String str = "[";
Node<T> s= head;
while(!s.getNext().equals(head)){
s = s.getNext();

if(s.getNext().equals(head))
str = str + s.getData();
else
str = str + s.getData() + ",";
}

str = str + "]";
return str;
}

}

在代码中定义尾指针rear的目的是为运算方便。

如：在很多实际问题中要找到终端节点， 在有尾指针的情况下时间复杂度为O(1)，若没有就要从头指针一直遍历整个链表时间复杂度为O(n)