双向循环链表的基本操作: java语言实现

1. 双向循环链表简单介绍

      双向循环链表(Doubly Circular Linked List)是循环链表的一种。双向循环链表在双向链表的基础上，将表头结点的前驱指针指向尾结点，尾结点的后驱指针指向表头结点，首尾相连形成一个双向环。

2 双向循环链表的基本操作

2.1 创建结点类

//创建一个双向链表结点类，并用get，set方法获取其数据。
public class DCLLNode {
private int data;//数据域
private DCLLNode next;//后继指针域
private DCLLNode previous;//前驱指针域

public DCLLNode(int data) {
this.data = data;
this.next = null;
this.previous = null;
}

public int getData() {
return data;
}

public void setData(int data) {
this.data = data;
}

public DCLLNode getNext() {
return next;
}

public void setNext(DCLLNode next) {
this.next = next;
}

public DCLLNode getPrevious() {
return previous;
}

public void setPrevious(DCLLNode previous) {
this.previous = previous;
}
//显示该结点的数据
public void display() {
System.out.print( data + " ");
}
}

public class DoublyCircularLinkedList {
private DCLLNode head;
private int length = 0;

public DoublyCircularLinkedList() {
this.head = null;
}

//在链表头部添加结点
public void addHead(int data) {
DCLLNode newNode = new DCLLNode(data);
newNode.setNext(newNode);
newNode.setPrevious(newNode);
if(head == null){
head = newNode;
} else{
DCLLNode curNode = head;
while(curNode.getNext() != head) {
curNode = curNode.getNext();
}
newNode.setNext(head);
curNode.setNext(newNode);
newNode.setPrevious(curNode);
head.setPrevious(newNode);
head = newNode;
}
length++;
}

//在链表头部删除结点
public void deleteHead() {
if(head == null){
System.out.println("空表，删除的结点不存在");
}
DCLLNode curNode = head;
while(curNode.getNext() != head) {
curNode = curNode.getNext();
}
DCLLNode temp =head.getNext();
curNode.setNext(temp);
temp.setPrevious(curNode);
head =temp;
length--;
}

//在链表尾部添加结点
public void addTail(int data) {
DCLLNode newNode = new DCLLNode(data);
newNode.setNext(newNode);
newNode.setPrevious(newNode);
if (head == null) {
head = newNode;
} else {
DCLLNode curNode = head;
while(curNode.getNext() != head) {
curNode = curNode.getNext();
}
newNode.setNext(head);
head.setPrevious(newNode);
curNode.setNext(newNode);
newNode.setPrevious(curNode);
}
length++;
}

//在链表尾部删除结点
public void deleteTail() {
if(head == null){
System.out.println("空表，删除的结点不存在");
}
DCLLNode curNode = head;
DCLLNode preNode =head;
while(curNode.getNext() != head) {
preNode = curNode;
curNode = curNode.getNext();
}
preNode.setNext(head);
head.setPrevious(preNode);
curNode = null;
length--;
}

//在指定位置插入结点
public void insertList(int data, int index) {
DCLLNode newNode = new DCLLNode(data);
newNode.setNext(newNode);
newNode.setPrevious(newNode);
if(head == null){
head = newNode;
}
if(index > length+1 || index < 1) {
System.out.println("结点插入的位置不存在，可插入的位置为1到"+(length+1));
}else if(index == 1) {
DCLLNode curNode = head;
while(curNode.getNext() != head) {
curNode = curNode.getNext();
}
newNode.setNext(head);
curNode.setNext(newNode);
newNode.setPrevious(curNode);
head.setPrevious(newNode);
head = newNode;
} else{
DCLLNode preNode = head;
int count = 1;
while(count < index-1) {
preNode = preNode.getNext();
count++;
}
DCLLNode curNode = preNode.getNext();
newNode.setNext(curNode);
curNode.setPrevious(newNode);
preNode.setNext(newNode);
newNode.setPrevious(preNode);
}
length++;
}

//在指定位置删除结点
public void deleteList(int index) {
if(index > length || index < 1) {
System.out.println("结点删除的位置不存在，可删除的位置为1到"+length);
}else if(index == 1) {
DCLLNode curNode = head;
while(curNode.getNext() != head) {
curNode = curNode.getNext();
}
DCLLNode temp =head.getNext();
curNode.setNext(temp);
temp.setPrevious(curNode);
head =temp;
length--;
} else{
DCLLNode preNode = head;
int count = 1;
while(count < index-1) {
preNode = preNode.getNext();
count++;
}
DCLLNode curNode = preNode.getNext();
DCLLNode laterNode = curNode.getNext();
preNode.setNext(laterNode);
laterNode.setPrevious(preNode);
length--;
}
}

//查找数据是否存在
public boolean containData(int data) {
if(head == null){
System.out.println("空表");
return false;
}
DCLLNode curNode = head;
while(curNode.getData()!= data){
if(curNode.getNext() == head) {
System.out.println("结点数据不存在");
return false;
}
curNode =curNode.getNext();
}
System.out.println("结点数据存在");
return true;
}

//获取指定位置的数据
public void getIndexData(int index) {
if(head == null){
System.out.println("空表");
}
if(index > length || index < 1) {
System.out.println("结点位置不存在，可获取的位置为1到"+length);
}else {
DCLLNode curNode = head;
int count =1;
while(count != index) {
curNode =curNode.getNext();
count++;
}
curNode.display();
System.out.println();
}
}

//修改指定位置的结点数据
public void updateIndexData(int index, int data) {
if(head == null){
System.out.println("空表");
}
if(index > length || index < 1) {
System.out.println("结点位置不存在，可更新的位置为1到"+length);
}else {
DCLLNode curNode = head;
int count =1;//while也可以用for循环方式解决
while(count != index) {
curNode =curNode.getNext();
count++;
}
curNode.setData(data);
}
}

//获取链表的长度
public int  listLength() {
return length;
}

//正向遍历链表
public void printOrderNode() {
if(head == null) {
System.out.println("空表");
}
DCLLNode cur = head;
while (cur != null) {
cur.display();
cur = cur.getNext();
if(cur == head) {
break;
}
}
System.out.println();
}

//反向遍历链表
public void printReverseNode() {
if(head == null) {
System.out.println("空表");
}
DCLLNode curNode = head;
while (curNode.getNext() != head) {
curNode = curNode.getNext();
}
DCLLNode temp = curNode;
while (curNode.getPrevious() != temp) {
curNode.display();
curNode = curNode.getPrevious();
}
curNode.display();
System.out.println();
}
}

public class DoublyCircularLinkedListTest {
public static void main(String[] args) {
DoublyCircularLinkedList list = new DoublyCircularLinkedList();
list.addHead(3);
list.addHead(2);
list.addHead(1);
list.addTail(4);
list.addTail(5);
list.addTail(6);
//list.deleteHead();
//list.deleteTail();
//list.insertList(8,4);
//list.deleteList(4);
//list.containData(4);
//list.getIndexData(5);
list.updateIndexData(3,0);
list.printOrderNode();
list.printReverseNode();
}
}

4 参考资料