这篇文章讲述的是数据结构部分的单向循环链表的java实现，如有错误或者不当之处，还望各位大神批评指正。
单向循环链表的特点
- 物理结构不连续逻辑结构连续
- 删除和添加操作方便
- 顺序储存随数据量的增大而增大
- 查询操作不方便
- 从任意一个节点可以访问整个链表
单向循环链表的基本操作
- init:初始化顺序表
- destroy：销毁数据表
- clear：清空数据表中的元素
- length：获取数据表长度
- get：获取索引位置的元素
- locateElem：定位元素
- priorElem：获取元素前驱
- nextElem：获取元素后继
- put：顺序放入元素
- insert：插入元素
- replace：替换元素
- delete：删除元素
- isEmpty：判断顺序表是否为空
- print：打印顺序表中的元素
单向循环链表的java实现
package list;
/**
* ================================数据结构说明：========================================
*
* 名称：单向循环链表（带头结点）
*
* 特征：
* 1. 物理结构不连续逻辑结构连续
* 2. 删除和添加操作方便
* 3. 顺序储存随数据量的增大而增大
* 4. 查询操作不方便
* 6. 从任意一个节点可以访问整个链表
*
* 主要方法：
* 1. init:初始化顺序表
* 2. destroy：销毁数据表
* 3. clear：清空数据表中的元素
* 4. length：获取数据表长度
* 5. get：获取索引位置的元素
* 6. locateElem：定位元素
* 7. priorElem：获取元素前驱
* 8. nextElem：获取元素后继
* 9. put：顺序放入元素
* 10. insert：插入元素
* 11. replace：替换元素
* 12. delete：删除元素
* 13. isEmpty：判断顺序表是否为空
* 14. print：打印顺序表中的元素
*
* ======================================================================================
*/
/**
* @author 叶清逸
* @date 2018年7月25日下午2:26:08
* @version 1.0
* @project list
*/
public class CirLinkList implements List {
/*双向链表的长度*/
private int LENGTH ;
/*头指针*/
private Element head ;
/*元素类*/
private class Element{
Object data ;
Element next ;
}
/**
* @see list.List#init()
* @explain init方法:初始化链表
* @throws
* @author 叶清逸
* @date 2018年7月25日 下午2:26:52
*/
@Override
public void init() {
head = new Element() ;
head.next = head ;
LENGTH = 0 ;
}
/**
* @explain destroy方法:销毁链表
* @throws
* @author 叶清逸
* @date 2018年7月25日 下午2:29:34
*/
@Override
public void destroy() {
/*若未初始化输出异常信息*/
if(head == null){
System.out.println("错误：链表未初始化！");
return ;
}
head = null ;
}
/**
* @explain clear方法: 清空链表
* @throws
* @author 叶清逸
* @date 2018年7月25日 下午2:30:53
*/
@Override
public void clear() {
/*若未初始化输出异常信息*/
if(head == null){
System.out.println("错误：链表未初始化！");
return ;
}
head.next = null ;
}
/**
* @explain length方法: 获取链表的长度
* @return int 元素的长度
* @throws
* @author 叶清逸
* @date 2018年7月25日 下午2:32:08
*/
@Override
public int length() {
/*若未初始化输出异常信息*/
if(head == null){
System.out.println("错误：链表未初始化！");
return -1;
}
return LENGTH ;
}
/**
* @see list.List#get(int)
* @explain get方法:获取索引位置的元素
* @param index 索引位置
* @return 索引位置的元素
* @throws
* @author 叶清逸
* @date 2018年7月25日 下午2:43:31
*/
@Override
public Object get(int index) {
/*若未初始化输出异常信息*/
if(head == null){
System.out.println("错误：链表未初始化！");
return null;
}
/*判断index是否合法*/
if(index > LENGTH || index<=0){
System.out.println("错误：索引不合法！");
return null;
}
/*初始化指针用于遍历*/
Element p = head ;
for(int i=0 ; i<index ; i++){
p = p.next ;
}
return p.data;
}
/**
* @see list.List#locateElem(java.lang.Object)
* @explain locateElem方法: 获取元素的索引
* @param elem 元素
* @return 元素的索引
* @throws
* @author 叶清逸
* @date 2018年7月25日 下午2:45:09
*/
@Override
public int locateElem(Object elem) {
/*若未初始化输出异常信息*/
if(head == null){
System.out.println("错误：链表未初始化！");
return -1;
}
int index = -1 ;
Element p = head.next ;
for(int i=0 ; i<LENGTH ;i++){
if(p.data.equals(elem)){
index = i+1 ;
break ;
}
p = p.next ;
}
return index;
}
/**
* @see list.List#priorElem(java.lang.Object)
* @explain priorElem方法:获取元素的前驱
* @param elem 当前元素
* @return 元素的前驱
* @throws
* @author 叶清逸
* @date 2018年7月25日 下午2:46:25
*/
@Override
public Object priorElem(Object elem) {
/*若未初始化输出异常信息*/
if(head == null){
System.out.println("错误：链表未初始化！");
return null;
}
Element prior = null ;
Element p = head;
while(p.next != head){
if(p.next.data.equals(elem)){
prior = p ;
break ;
}
p = p.next ;
}
if(p == head){
/*若为第一个元素，则需遍历整个链表获取最后一个元素*/
Element q = head.next ;
while(q.next != head){
q = q.next ;
}
prior = q ;
return prior.data ;
}else if(p.next == head){
return null ;
}else{
prior = p ;
return prior.data ;
}
}
/**
* @see list.List#nextElem(java.lang.Object)
* @explain nextElem方法:获取元素的后继
* @param elem 当前元素
* @return 元素的后继
* @throws
* @author 叶清逸
* @date 2018年7月25日 下午3:31:44
*/
@Override
public Object nextElem(Object elem) {
/*若未初始化输出异常信息*/
if(head == null){
System.out.println("错误：链表未初始化！");
return null;
}
Element next = null ;
Element p = head.next;
while(p != head){
if(p.data.equals(elem)){
next = p.next ;
break ;
}
p = p.next ;
}
if(p.next == head){
next = p.next.next ;
return next.data ;
}else{
next = p.next ;
return next.data;
}
}
@Override
public void put(Object elem) {
/*若未初始化输出异常信息*/
if(head == null){
System.out.println("错误：链表未初始化！");
return ;
}
/*新建元素*/
Element e = new Element() ;
e.next = null ;
e.data = elem ;
/*遍历找到链表尾*/
Element p = head.next ;
while(p.next != head){
p = p.next ;
}
/*修改指针的指向*/
p.next = e ;
e.next = head ;
/*长度+1*/
LENGTH++ ;
}
/**
* @see list.List#insert(int, java.lang.Object)
* @explain insert方法: 在索引位置插入元素elem
* @param index 索引位置
* @param elem 要插入的元素
* @throws
* @author 叶清逸
* @date 2018年7月25日 下午3:35:44
*/
@Override
public void insert(int index, Object elem) {
/*若未初始化输出异常信息*/
if(head == null){
System.out.println("错误：链表未初始化！");
return ;
}
/*判断index是否合法*/
if(index > LENGTH || index<=0){
System.out.println("错误：索引不合法！");
return ;
}
/*找到要插入的位置*/
Element p = head ;
for(int i=0 ; i<index-1 ; i++){
p = p.next ;
}
/*插入元素*/
Element curElem = p ;
Element nextElem = p.next ;
Element e = new Element() ;
e.data = elem ;
e.next = nextElem ;
curElem.next = e ;
LENGTH++ ;
}
/**
* @see list.List#replace(int, java.lang.Object)
* @explain replace方法: 替换索引位置的元素
* @param index 索引位置
* @param elem 要替换的元素
* @throws
* @author 叶清逸
* @date 2018年7月25日 下午3:40:45
*/
@Override
public void replace(int index, Object elem) {
/*若未初始化输出异常信息*/
if(head == null){
System.out.println("错误：链表未初始化！");
return ;
}
/*判断index是否合法*/
if(index > LENGTH || index<=0){
System.out.println("错误：索引不合法！");
return ;
}
/*找到替换的位置*/
Element p = head ;
for(int i=0 ; i<index ; i++){
p = p.next ;
}
/*替换元素*/
p.data = elem ;
}
/**
* @see list.List#delete(int)
* @explain delete方法:删除索引位置的元素
* @param index 索引位置
* @throws
* @author 叶清逸
* @date 2018年7月25日 下午3:42:49
*/
@Override
public void delete(int index) {
/*若未初始化输出异常信息*/
if(head == null){
System.out.println("错误：链表未初始化！");
return ;
}
/*判断index是否合法*/
if(index > LENGTH || index<=0){
System.out.println("错误：索引不合法！");
return ;
}
/*定位到要删除的位置*/
Element p = head ;
for(int i=0 ; i<index-1 ; i++){
p = p.next ;
}
/*记录当前位置和后一个元素位置*/
Element curElem = p ;
Element nextElem = p.next.next ;
/*删除元素，即改变指针的位置*/
curElem.next = nextElem ;
}
/**
* @see list.List#isEmpty()
* @explain isEmpty方法: 判断链表是否为空
* @return Boolean数值，true表示为空，false表示非空
* @throws
* @author 叶清逸
* @date 2018年7月25日 下午3:44:04
*/
@Override
public boolean isEmpty() {
boolean flag = false ;
if(head.next == null){
flag = true ;
}
return flag ;
}
/**
* @see list.List#print()
* @explain print方法: 打印链表，顺序访问每个节点
* @throws
* @author 叶清逸
* @date 2018年7月25日 下午3:45:52
*/
@Override
public void print() {
/*若未初始化输出异常信息*/
if(head == null){
System.out.println("错误：链表未初始化！");
return ;
}
/*定义一个用于遍历的指针*/
Element p = head.next;
while(p != head){
/*输出元素*/
System.out.print(p.data+" ");
p = p.next ;
}
System.out.println();
}
@Override
public String toString() {
String str = "LinkList:[" ;
Element p = head.next ;
while(p != head){
if(p.next != head){
str = str + p.data +"," ;
p = p.next ;
}else{
str = str + p.data ;
p = p.next ;
}
}
str = str+"]" ;
return str;
}
}