数据结构之线性表（2）链式存储结构（2）双向循环链表

双向链表基于单链表结构，它的结点结构多了一个前继。所以操作过程中也就多了一个指针的操作

基本形态

 算法：

 下面上代码：

首先是结点结构：

package com.tong.xu.a.models;

public class DuNode {
    private String data ;
    private DuNode proior;
    private DuNode next;

    public String getData() {
        return data;
    }

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

    public DuNode getProior() {
        return proior;
    }

    public void setProior(DuNode proior) {
        this.proior = proior;
    }

    public DuNode getNext() {
        return next;
    }

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

然后是遍历，插入以及删除算法实现过程，注意看注释

package com.tong.xu.a.test;

import com.tong.xu.a.models.DuNode;
import org.junit.Test;
//测试双向循环链表
public class TestDuNode {
    //正序遍历链表
    public void  visitLinkList1(DuNode L){
        DuNode p = L;
        DuNode h = L;
        p = h.getNext();
        while(p != h){
            System.out.print(p.getData()+" ");
            p = p.getNext();
        }
        System.out.println();
    }
    //逆序遍历链表
    public void  visitLinkList2(DuNode L){
        DuNode p = L;
        DuNode h = L;
        p = h.getProior();
        while(p != h){
            System.out.print(p.getData()+" ");
            p = p.getProior();
        }
        System.out.println();
    }
    public DuNode addDuLinkList(){
        DuNode L;//创建链表
        DuNode head = new DuNode();//创建头结点并初始化
        head.setData(null);
        head.setProior(head);
        head.setNext(head);
        L = head;//将头结点添加到链表
        DuNode newNode;//创建要指向新增结点的指针
        DuNode p = L;//创建指针指向链表头结点
        for(int i = 0 ; i < 5; i++){
            newNode = new DuNode();
            newNode.setData(""+i);
//            System.out.print(newNode.getData());
            newNode.setNext(p.getNext()); //新增结点的next指针域指向P的下一个结点 newNode->next = p->next;
//            System.out.println(newNode.getNext() == p.getNext());
            p.setNext(newNode);//p的下一个结点指向新节点p->next = newNode
//            System.out.println(p.getNext() == newNode);
            newNode.setProior(p);//新节点的前继指向P newNode->prior = p
//            System.out.println(newNode.getProior() == p);
            newNode.getNext().setProior(newNode);//原链表中p下一结点的前继指向新结点newNode->next->prior = newNode
//            System.out.println(newNode.getNext().getProior() == newNode);
            p = p.getNext();
        }
        return L;
    }
    //创建双向循环链表，添加结点
    @Test
    public void testAddDuLinkList(){
        //创建链表并添加结点
        DuNode L = addDuLinkList();
        visitLinkList1(L);//0 1 2 3 4
        visitLinkList2(L);//4 3 2 1 0
    }
    @Test
    public void testDelDuNode(){
        //创建链表并添加结点
        DuNode L = addDuLinkList();
        visitLinkList1(L);
        //0 1 2 3 4

        //删除结点 :前提条件：1.链表不为空 2.链表删除位置在小于链表长度
        DuNode P = L.getNext();
        int i= 2;//定义删除的位置（从头结点之后的位置开始）
        int j =1;
        while(P != L && j<i ){//指针迭代到指定位置
            P = P.getNext();
            j++;
        }
        if(i == j){//删除指定位置的后一个结点
            DuNode S = P.getNext();//S指向要删除的结点
            P.setNext(S.getNext());//p->next = s->next;
            P.getNext().setProior(P);//p->next->prior = p;
            //注意：java垃圾自动回收机制下，会回收没有指向的内存，如果其他语言需要释放指正指向的区域。
            S = null;
        }
        visitLinkList1(L);
        //0 1 3 4

        if(i == j){//删除指定位置结点
            P.getProior().setNext(P.getNext());//p->prior->next = p->next;
            P.getNext().setProior(P.getProior());//p->next->prior = p->prior;
            P = null;
        }
        visitLinkList1(L);
        //0 3 4
    }
}

 希望对你有帮助。