【数据结构与算法 | 基础篇】模拟LinkedList实现的双向循环链表

简介: 【数据结构与算法 | 基础篇】模拟LinkedList实现的双向循环链表

1. 前言

前文我们分别实现了不带哨兵的单链表,带哨兵节点的双向链表,接着我们实现带哨兵节点的双向循环链表.双向循环链表只需一个哨兵节点,该节点的prev指针和next指针都指向了自身哨兵节点.

2. 实现双向循环链表的代码

例 :

//模拟双向循环链表
public class CircleLinkedList implements Iterable<Integer>{
    private static class Node{
        Node prev;
        int value;
        Node next;
 
        public Node(Node prev, int value, Node next) {
            this.prev = prev;
            this.value = value;
            this.next = next;
        }
    }
    private static Node head = new Node(null, 10086, null);
    //只有一个哨兵节点, 并且哨兵节点的两个指针域都指向本身
    public CircleLinkedList() {
        head.prev = head;
        head.next = head;
    }
 
    //头插法
    public void addHead(int value) {
        Node p = head.next;
        Node q = new Node(head, value, p);
        head.next = q;
        p.prev = q;
 
    }
    //从头开始遍历
    public void Traverse1Head() {
        Node p = head.next;
        while (p != head) {
            System.out.println("该处节点的数据域的值是" + p.value);
            p = p.next;
        }
    }
    //从尾开始遍历
    public void Traverse1Tail() {
        Node p;
        for (p = head.prev; p != head; p = p.prev) {
            System.out.println("该处节点的数据域的值是" + p.value);
        }
    }
    //获取指定位置的值
    public static int get(int index) {
        Node p = findIndex(index);
        //此时该方法返回的是哨兵节点
        if (p == head) {
            throw new RuntimeException("哨兵节点不可获取值");
        }
        return p.value;
    }
    //从哨兵节点开始找指定索引的节点的值
    private static Node findIndex(int index) {
        //我们假设哨兵节点的索引为-1
        int count = -1;
        Node p = head;
        if (index < -1) {
            throw new RuntimeException("index输入不合法");
        }
        while (count < index) {
            p = p.next;
            //当p == head, 说明遍历一圈都没找到, 即index过大
            if (p == head) {
                throw new RuntimeException("输入无效的index");
            }
            count++;
        }
        return p;
    }
    //尾插法
    public void addTail(int value) {
        Node p = head.prev;
        Node q = new Node(p, value, head);
        p.next = q;
        head.prev = q;
    }
    //向指定索引的位置添加节点
    public void Insert(int index, int value) {
        //找到要插入节点的前一个节点
        Node p = findIndex(index - 1);
        Node q = new Node(p, value, p.next);
        p.next.prev = q;
        p.next = q;
    }
    //对指定索引的节点进行删除操作
    public void remove(int index) {
        //找到要插入节点的前一个节点
        //当index==0时, p指向哨兵节点
        Node p = findIndex(index - 1);
        p.next.next.prev = p;
        p.next = p.next.next;
    }
    //实现了Iterable接口, 可foreach循环
 
    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            Node p = head.next;
            @Override
            public boolean hasNext() {
                return p != head;
            }
 
            @Override
            public Integer next() {
                int value = p.value;
                p = p.next;
                return value;
            }
        };
    }
}
 

3. 单元测试

@Test
    public void test1() {
        CircleLinkedList c = new CircleLinkedList();
        c.addHead(12);
        c.addHead(23);
        c.addHead(34);
        c.addHead(45);
        c.addHead(56);
        c.addHead(67);
        c.addHead(78);
        c.Traverse1Head();
//        c.Traverse1Tail();
//        System.out.println(c.get(6));
    }
    @Test
    public void test2() {
        CircleLinkedList c = new CircleLinkedList();
        c.addTail(12);
        c.addTail(23);
        c.addTail(34);
        c.addTail(45);
        c.addTail(56);
        c.addTail(67);
        c.addTail(78);
        c.Insert(7, 100);
        c.remove(7);
        c.remove(0);
//        c.Traverse1Head();
        c.Traverse1Head();
    }
    @Test
    public void test3() {
        CircleLinkedList c = new CircleLinkedList();
        c.addTail(12);
        c.addTail(23);
        c.addTail(34);
        c.addTail(45);
        c.addTail(56);
        c.addTail(67);
        c.addTail(78);
        for (int element : c) {
            System.out.println("该节点的数据域是" + element);
        }
    }
相关文章
|
2月前
|
存储 算法 Perl
数据结构实验之链表
本实验旨在掌握线性表中元素的前驱、后续概念及链表的建立、插入、删除等算法,并分析时间复杂度,理解链表特点。实验内容包括循环链表应用(约瑟夫回环问题)、删除单链表中重复节点及双向循环链表的设计与实现。通过编程实践,加深对链表数据结构的理解和应用能力。
65 4
|
14天前
|
数据库
数据结构中二叉树,哈希表,顺序表,链表的比较补充
二叉搜索树,哈希表,顺序表,链表的特点的比较
数据结构中二叉树,哈希表,顺序表,链表的比较补充
|
2月前
|
存储 缓存 算法
在C语言中,数据结构是构建高效程序的基石。本文探讨了数组、链表、栈、队列、树和图等常见数据结构的特点、应用及实现方式
在C语言中,数据结构是构建高效程序的基石。本文探讨了数组、链表、栈、队列、树和图等常见数据结构的特点、应用及实现方式,强调了合理选择数据结构的重要性,并通过案例分析展示了其在实际项目中的应用,旨在帮助读者提升编程能力。
75 5
|
2月前
|
存储 C语言
【数据结构】手把手教你单链表(c语言)(附源码)
本文介绍了单链表的基本概念、结构定义及其实现方法。单链表是一种内存地址不连续但逻辑顺序连续的数据结构,每个节点包含数据域和指针域。文章详细讲解了单链表的常见操作,如头插、尾插、头删、尾删、查找、指定位置插入和删除等,并提供了完整的C语言代码示例。通过学习单链表,可以更好地理解数据结构的底层逻辑,提高编程能力。
122 4
|
2月前
|
算法 安全 搜索推荐
2024重生之回溯数据结构与算法系列学习之单双链表精题详解(9)【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丢脸好嘛?】
数据结构王道第2.3章之IKUN和I原达人之数据结构与算法系列学习x单双链表精题详解、数据结构、C++、排序算法、java、动态规划你个小黑子;这都学不会;能不能不要给我家鸽鸽丢脸啊~除了会黑我家鸽鸽还会干嘛?!!!
|
2月前
|
存储 Web App开发 算法
2024重生之回溯数据结构与算法系列学习之单双链表【无论是王道考研人还是IKUN都能包会的;不然别给我家鸽鸽丢脸好嘛?】
数据结构之单双链表按位、值查找;[前后]插入;删除指定节点;求表长、静态链表等代码及具体思路详解步骤;举例说明、注意点及常见报错问题所对应的解决方法
|
2月前
|
算法
数据结构之购物车系统(链表和栈)
本文介绍了基于链表和栈的购物车系统的设计与实现。该系统通过命令行界面提供商品管理、购物车查看、结算等功能,支持用户便捷地管理购物清单。核心代码定义了商品、购物车商品节点和购物车的数据结构,并实现了添加、删除商品、查看购物车内容及结算等操作。算法分析显示,系统在处理小规模购物车时表现良好,但在大规模购物车操作下可能存在性能瓶颈。
57 0
|
3月前
|
存储 缓存 算法
经典算法之链表篇(三)
经典算法之链表篇(三)
|
3月前
|
算法
经典算法之链表篇(二)
经典算法之链表篇(二)
|
2月前
|
C语言
【数据结构】双向带头循环链表(c语言)(附源码)
本文介绍了双向带头循环链表的概念和实现。双向带头循环链表具有三个关键点:双向、带头和循环。与单链表相比,它的头插、尾插、头删、尾删等操作的时间复杂度均为O(1),提高了运行效率。文章详细讲解了链表的结构定义、方法声明和实现,包括创建新节点、初始化、打印、判断是否为空、插入和删除节点等操作。最后提供了完整的代码示例。
84 0