数据结构——单向循环链表&双向循环链表

已于 2022-08-24 19:00:40 修改
阅读量2.9k 收藏 7
点赞数 4
分类专栏： 数据结构 文章标签： 数据结构 链表 循环链表
于 2022-08-24 18:57:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56668869/article/details/126498355
版权

一、单向循环链表

(一)概念

  • 将单链表尾节点的指针域置为起始节点的地址，而不再是NULL，这样从表中任一节点出发，均可访问到链表中的所有节点

(二)单向循环链表的结构图

（三）程序封装单向循环链表 

   1.创建链表类和节点类

 //节点的结构
        class Cnode {
            constructor(data) {
                this.data = data
                this.next = null
            }

        }
//链表的结构
        class CycleLinkList {
            constructor() {
                this.head = null
                this.length = 0
            }
         }

  2.单向循环链表的操作（方法） 

   1）append() 向链表尾部添加一个节点

append(ele) {
                let newnode = new Cnode(ele)

                if(this.head==null){
                    //空链表
                    this.head=newnode
                    newnode.next=this.head 
                }else{
                    //非空链表
                    //需要找到最后一个节点
                    let current=this.head
                    while(current.next!=this.head){
                        current=current.next
                    }
                    //找到了current表示最后一个节点
                    current.next=newnode
                    newnode.next=this.head
                }
                this.length++
            }

   2）toString()  将链表中的数据连接为字符串

toString(){
                let current=this.head,index=0,str=""
                while(index<this.length){
                    str+="-"+current.data
                    current=current.next
                    index++
                }
               return str.slice(1)
            }

   3）insert() 向链表中插入元素 

 insert(position, ele) {
                if (position < 0 || position > this.length || Number.isInteger(position)) {
                    return false
                }
                let newnode = new Cnode(ele)
                let current = this.head,
                    index = 0
                if (position == 0) {
                    //在头部插入
                    if (this.length == 0) {
                        //空链表
                        this.head = newnode
                        newnode.next = this.head
                    } else {
                        //非空链表
                        while (current.next != this.head) {
                            current = current.next
                        }
                        newnode.next = this.head
                        current.next = newnode
                        this.head = newnode
                    }
                    this.length++
                } else if (position == this.length) {
                    //在尾部插入
                    this.append(ele)
                } else {
                    //在中间插入
                    while (index < position - 1) {
                        current = current.next
                        index++
                    }
                    newnode.next = current.next
                    current.next = newnode
                    this.length++
                }

            }

    4）removeAt() 移除在指定位置的元素

removeAt(position) {
                //判断位置是否合法(越界判断)
                if (position < 0 || position > this.length - 1 || !Number.isInteger(position)) {
                    return false
                }
                //非空链表
                let current = this.head,
                    index = 0
                if (position == 0) {
                    //移除头部
                    if (this.length == 1) {
                        //只有一个节点
                        this.head = null
                    } else {
                        //找到最后一个节点 最后一个节点的next指向新头部
                        while (current.next != this.head) {
                            current = current.next
                        }
                        this.head = this.head.next
                        current.next = this.head
                    }
                } else {
                    //移除任意位置(包括末尾)
                    while (index < position - 1) {
                        current = current.next
                        index++
                    }
                    current.next = current.next.next
                }
                this.length--
            }

   5）indexOf() 查找指定元素

indexOf(ele) {
                let current = this.head,
                    index = 0
                while (index < this.length) {
                    if (current.data == ele) {
                        return index
                    } else {
                        current = current.next
                        index++
                    }
                }
                return -1
            }

    6）remove() 移除指定元素

remove(ele) {
                let index = this.indexOf(ele)
                this.removeAt(index)
            }

(四)完整代码&操作示例

        //节点的结构
        class Cnode {
            constructor(data) {
                this.data = data
                this.next = null
            }

        }
        //链表的结构
        class CycleLinkList {
            constructor() {
                this.head = null
                this.length = 0
            }

            //1.append() 向链表尾部添加一个元素
            append(ele) {
                let newnode = new Cnode(ele)

                if (this.head == null) {
                    //空链表
                    this.head = newnode
                    newnode.next = this.head
                } else {
                    //非空链表
                    //需要找到最后一个节点 最后一个节点的next指向头结点
                    let current = this.head
                    while (current.next != this.head) {
                        //继续往下找
                        current = current.next
                    }
                    //找到了current表示最后一个节点
                    current.next = newnode
                    newnode.next = this.head
                }
                this.length++
            }

            //2.toString()  将链表中的数据链接为字符串
            toString() {
                let current = this.head,
                    index = 0,
                    str = ""
                while (index < this.length) {
                    str += "-" + current.data
                    current = current.next
                    index++
                }
                return str.slice(1)
            }

            //3.向链表中插入元素
            insert(position, ele) {
                if (position < 0 || position > this.length || !Number.isInteger(position)) {
                    return false
                }
                let newnode = new Cnode(ele)
                let current = this.head,
                    index = 0
                if (position == 0) {
                    //在头部插入
                    if (this.length == 0) {
                        //空链表
                        this.head = newnode
                        newnode.next = this.head
                    } else {
                        //非空链表
                        while (current.next != this.head) {
                            current = current.next
                        }
                        newnode.next = this.head
                        current.next = newnode
                        this.head = newnode
                    }
                    this.length++
                } else if (position == this.length) {
                    //在尾部插入
                    this.append(ele)
                } else {
                    //在中间插入
                    while (index < position - 1) {
                        current = current.next
                        index++
                    }
                    newnode.next = current.next
                    current.next = newnode
                    this.length++
                }

            }

            //4.移除在指定位置的元素
            removeAt(position) {
                //判断位置是否合法(越界判断)
                if (position < 0 || position > this.length - 1 || !Number.isInteger(position)) {
                    return false
                }
                //非空链表
                let current = this.head,
                    index = 0
                if (position == 0) {
                    //移除头部
                    if (this.length == 1) {
                        //只有一个节点
                        this.head = null
                    } else {
                        //找到最后一个节点 最后一个节点的next指向新头部
                        while (current.next != this.head) {
                            current = current.next
                        }
                        this.head = this.head.next
                        current.next = this.head
                    }
                } else {
                    //移除任意位置(包括末尾)
                    while (index < position - 1) {
                        current = current.next
                        index++
                    }
                    current.next = current.next.next
                }
                this.length--
            }

            //5.查找指定元素
            indexOf(ele) {
                let current = this.head,
                    index = 0
                while (index < this.length) {
                    if (current.data == ele) {
                        return index
                    } else {
                        current = current.next
                        index++
                    }
                }
                return -1
            }


            //6.移除指定元素
            remove(ele) {
                let index = this.indexOf(ele)
                this.removeAt(index)
            }

        }
        let clist = new CycleLinkList()

       //链表操作
        //在末尾添加元素
        for (let i = 0; i < 9; i++) {
            clist.append(i)
        }
        console.log(clist.toString(),"添加了元素")
        //在指定位置插入元素
        clist.insert(3, "newnode")
        console.log(clist.toString(),"在3的位置插入了newnode")
        //移除指定位置的元素
        clist.removeAt(4)
        console.log(clist.toString(),"移除了第4个节点--3")
        //查找元素
        console.log(clist.indexOf(3),"查找3，已经被移除了所以返回-1")
        console.log(clist.indexOf(5),"存在，返回下标")
        //移除指定元素
        clist.remove(8)
        console.log(clist.toString(),"删除了8")

打印结果：

二、双向循环链表

(一)概念

  • 可以从两个方向进行遍历，可以利用中间的一个节点推出下一个节点和上一个节点

(二)双向循环链表的结构图

(三)程序封装双向循环链表 

1.创建链表类和节点类

 //节点的结构
       class Dnode {
            constructor(data) {
                this.prev = null;
                this.data = data;
                this.next = null;
            }
        }
//链表的结构
       class DoubleCycleLinkList {
            constructor() {
                this.head = null;
                this.tail = null;
                this.length = 0
            }
         }

2.单向循环链表的操作（方法） 

  1）append() 向链表尾部添加一个节点

append(ele) {
                let newnode = new Dnode(ele);
                if (this.length == 0) { //空链表
                    this.head = newnode;
                    this.tail = newnode;
                    newnode.prev = newnode;
                    newnode.next = newnode; //自己连自己
                } else {
                    //将新节点连接
                    newnode.prev = this.tail; //新节点.prev = 尾节点
                    newnode.next = this.head; //新节点的next指向头结点
                    //断开原来的指向，重新指向新节点
                    this.tail.next = newnode; //尾节点.next指向新节点
                    this.head.prev = newnode; //头结点的prev指向新节点
                    this.tail = newnode; //将尾节点指向新节点
                }
                this.length++;
            }

  2）insert() 向链表中插入元素 

insert(position, ele) {
                // 位置是否合法
                if (position < 0 || position > this.length || !Number.isInteger(position)) {
                    return false
                }
                let newnode = new Dnode(ele);
                if (position == 0) {
                    //在头部插入
                    if (this.length == 0) { //空链表
                        this.head = newnode;
                        this.tail = newnode;
                        newnode.prev = this.tail
                        newnode.next = this.head
                    } else {
                        //将新节点连接
                        newnode.next = this.head; //新节点.next指向头节点
                        newnode.prev = this.tail; //新节点的prev指向尾结点
                        //断开原来的指向

                        this.head.prev = newnode; //头节点.prev指向新节点
                        this.tail.next = newnode //尾节点的next指向新节点
                        this.head = newnode; //头节点指向新节点
                    }
                    this.length++
                } else if (position == this.length) {
                    //在尾部插入
                    this.append(ele)
                } else {
                    //在中间任意位置
                    let current = this.head,
                        index = 0;

                    while (index < position - 1) {
                        current = current.next;
                        index++;
                    }
                    // 1.将新节点连上去
                    newnode.prev = current;
                    newnode.next = current.next;
                    // 2.断开原来的指向
                    current.next = newnode;
                    newnode.next.prev = newnode;
                    this.length++;
                }
            }

   3）removeAt() 移除在指定位置的元素

 removeAt(position) {
                //判断位置的合法性（越界判断）
                if (position < 0 || position > this.length - 1 || !Number.isInteger(position)) {
                    return false
                }
                if (this.length == 0) {
                    //空链表
                    return
                } else {
                    if (position == 0) {
                        //移除头节点
                        if (this.length == 1) {
                            this.head = null
                            this.tail = null
                        } else {
                            this.head = this.head.next
                            this.tail.prev=this.head
                            this.head.prev = this.head
                        }
                    } else if (position == this.length - 1) {
                        //移除尾结点
                        this.tail = this.tail.prev
                        this.tail.next = this.head
                        this.head.prev=this.tail
                    } else {
                        //移除中间任意位置的节点
                        let current = this.head,
                            index = 0
                        while (index < position - 1) {
                            current = current.next
                            index++
                        }
                        current.next = current.next.next
                        current.next.prev = current
                    }
                    this.length--
                }
            }

  4）indexOf() 查找指定元素

indexOf(ele) {
                let current = this.head,
                    index = 0
                while (index < this.length) {
                    if (current.data == ele) {
                        return index
                    } else {
                        current = current.next
                        index++
                    }
                }
                return -1
            }

   5）remove() 移除指定元素

remove(ele) {
                let index = this.indexOf(ele)
                this.removeAt(index)
            }

  6）正向遍历

 forwardString() {
                let current = this.head,
                    index = 0,
                    str = "";
                while (index < this.length) {
                    str += "-" + current.data
                    current = current.next
                    index++
                }
                return str.slice(1)
            }

  7）反向遍历      

 reverseString() {
                let current = this.tail,
                    index = this.length - 1,
                    str = "";
                while (index >= 0) {
                    str += "-" + current.data
                    current = current.prev
                    index--
                }
                return str.slice(1)
            }

(四)完整代码&操作示例

        //节点的结构
        class Dnode {
            constructor(data) {
                this.prev = null;
                this.data = data;
                this.next = null;
            }
        }
        //链表的结构
        class DoubleCycleLinkList {
            constructor() {
                this.head = null;
                this.tail = null;
                this.length = 0
            }

            //1.在链表尾部添加元素
            append(ele) {
                let newnode = new Dnode(ele);
                if (this.length == 0) { //空链表
                    this.head = newnode;
                    this.tail = newnode;
                    newnode.prev = newnode;
                    newnode.next = newnode; //自己连自己
                } else {
                    //将新节点连接
                    newnode.prev = this.tail; //新节点.prev = 尾节点
                    newnode.next = this.head; //新节点的next指向头结点
                    //断开原来的指向，重新指向新节点
                    this.tail.next = newnode; //尾节点.next指向新节点
                    this.head.prev = newnode; //头结点的prev指向新节点
                    this.tail = newnode; //将尾节点指向新节点
                }
                this.length++;
            }
            // 2.向链表指定位置插入元素
            insert(position, ele) {
                // 位置是否合法
                if (position < 0 || position > this.length || !Number.isInteger(position)) {
                    return false
                }
                let newnode = new Dnode(ele);
                if (position == 0) {
                    //在头部插入
                    if (this.length == 0) { //空链表
                        this.head = newnode;
                        this.tail = newnode;
                        newnode.prev = this.tail
                        newnode.next = this.head
                    } else {
                        //将新节点连接
                        newnode.next = this.head; //新节点.next指向头节点
                        newnode.prev = this.tail; //新节点的prev指向尾结点
                        //断开原来的指向

                        this.head.prev = newnode; //头节点.prev指向新节点
                        this.tail.next = newnode //尾节点的next指向新节点
                        this.head = newnode; //头节点指向新节点
                    }
                    this.length++
                } else if (position == this.length) {
                    //在尾部插入
                    this.append(ele)
                } else {
                    //在中间任意位置
                    let current = this.head,
                        index = 0;

                    while (index < position - 1) {
                        current = current.next;
                        index++;
                    }
                    // 1.将新节点连上去
                    newnode.prev = current;
                    newnode.next = current.next;
                    // 2.断开原来的指向
                    current.next = newnode;
                    newnode.next.prev = newnode;
                    this.length++;
                }

            }

            //3.移除指定位置的节点
            removeAt(position) {
                //判断位置的合法性（越界判断）
                if (position < 0 || position > this.length - 1 || !Number.isInteger(position)) {
                    return false
                }
                if (this.length == 0) {
                    //空链表
                    return
                } else {
                    if (position == 0) {
                        //移除头节点
                        if (this.length == 1) {
                            this.head = null
                            this.tail = null
                        } else {
                            this.head = this.head.next
                            this.tail.prev=this.head
                            this.head.prev = this.head
                        }
                    } else if (position == this.length - 1) {
                        //移除尾结点
                        this.tail = this.tail.prev
                        this.tail.next = this.head
                        this.head.prev=this.tail
                    } else {
                        //移除中间任意位置的节点
                        let current = this.head,
                            index = 0
                        while (index < position - 1) {
                            current = current.next
                            index++
                        }
                        current.next = current.next.next
                        current.next.prev = current
                    }
                    this.length--
                }
            }
            
            //4.查找指定元素的位置
            indexOf(ele) {
                let current = this.head,
                    index = 0
                while (index < this.length) {
                    if (current.data == ele) {
                        return index
                    } else {
                        current = current.next
                        index++
                    }
                }
                return -1
            }

            //5.移除指定元素
            remove(ele) {
                let index = this.indexOf(ele)
                this.removeAt(index)
            }

            //6.正向遍历
            forwardString() {
                let current = this.head,
                    index = 0,
                    str = "";
                while (index < this.length) {
                    str += "-" + current.data
                    current = current.next
                    index++
                }
                return str.slice(1)
            }
            //7.反向遍历
            reverseString() {
                let current = this.tail,
                    index = this.length - 1,
                    str = "";
                while (index >= 0) {
                    str += "-" + current.data
                    current = current.prev
                    index--
                }
                return str.slice(1)
            }
        }
        let clist = new DoubleCycleLinkList()
        //向链表尾部添加元素
        for (let i = 0; i < 9; i++) {
            clist.append(i)
        }
        console.log(clist.forwardString(),"向链表尾部添加元素后的链表")

        //向链表中的3的位置插入元素
        clist.insert(3,"newnode")
        console.log(clist.forwardString(),"插入元素后的链表")

         //移除指定位置的元素
         clist.removeAt(5)
         console.log(clist.forwardString(),"移除位置为5的元素(4)的链表")
    
         //查找指定元素
         console.log(clist.indexOf(4),"4已经被移除，不存在返回-1")
         console.log(clist.indexOf(6),"6存在返回下标")

         //移除指定元素
         clist.remove(8)
         console.log(clist.reverseString(),"移除元素8后的反向遍历的链表")

打印结果：

哈哈ha~
关注
  • 4
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
单向循环链表
01-20
循环链表 循环链表是一种特殊的单链表。实际上，循环链表也很简单。它跟单链表唯一的区别就在尾结点。我们知道，单链表的尾结点指针指向空地址，表示这就是最后的结点了。而循环链表的尾结点指针是指向链表的头结点。从我画的循环链表图中，你应该可以看出来，它像一个环一样首尾相连，所以叫作“循环”链表。 操作 is_empty() 判断链表是否为空 length() 返回链表的长度 travel() 遍历 add(item) 在头部添加一个节点 append(item) 在尾部添加一个节点 insert(pos, item) 在指定位置pos添加节点 remove(item) 删除一个节点 search(i
循环链表（单循环、双循环）(数据结构与算法)
AII_IIA的博客
11-04 1392
循环单链表与普通单链表的主要区别在于，循环单链表的尾节点的指针不是指向 nullptr，而是指向头节点，形成一个闭环。这意味着，在循环单链表中，可以通过尾节点的指针重新回到头节点。循环双链表与普通双链表的主要区别在于，循环双链表既具有双向链表的前驱和后继关系，也具有循环遍历的能力。
双向循环链表
10-13
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。
循环链表实验
09-04
循环链表的基本操作 一、实验目的 熟练掌握线性表的基本操作在链式循环存储结构上的实现。 二、实验内容 1、在上一次单链表基本操作的基础上，修改程序，将其改为单循环链表，并实现相关操作。 （1）初始化单循环链表 （2）创建单循环链表 （3）求单循环链表长度 （4）输出单循环链表中每一个结点元素 （5）指定位置插入某个元素 （6）查找第i个结点元素的值 （7）查找值为e 的结点，并返回该结点指针 （8）删除第i个结点 （9）销毁单循环链表 2、实验要求 （1）程序中用户可以选择上述基本操作。 程序启动后，在屏幕上可以菜单形式显示不同功能，当按下不同数字后完成指定的功能，按其他键，则显示错误后重新选择。 （2）要求用不带头结点的循环链表实现。 （3）具体功能测试由主函数实现。
C语言数据结构之判断循环链表空与满
01-21
C语言数据结构之判断循环链表空与满 前言： 何时队列为空？何时为满？ 由于入队时尾指针向前追赶头指针，出队时头指针向前追赶尾指针，故队空和队满时头尾指针均相等。因此，我们无法通过front=rear来判断队列“空”还是“满”。 注：先进入的为‘头’，后进入的为‘尾’。 解决此问题的方法至少有三种： 其一是另设一个布尔变量以匹别队列的空和满； 其二是少用一个元素的空间，约定入队前，测试尾指针在循环意义下加1后是否等于头指针，若相等则认为队满（注意：rear所指的单元始终为空）； 其三是使用一个计数器记录队列中元素的总数（实际上是队列长度）。 第一种方法没有实现，下面实现第二种和第三
数据结构之单链表非常详细介绍(适合小白）
m0_74438843的博客
08-22 3884
数据结构深度学习之单链表非常详解解读~~~一万多字详解
单向循环链表 ---- C++使用类模板实现
Zhoujy1996的博客
06-19 768
单向循环链表实现代码 //单向循环链表 -- 采用类模板 template &lt;typename T&gt; class LinkListCy { public: LinkListCy(); LinkListCy(T elem); LinkListCy(int n, T elem); ~LinkListCy(); void ClearList() co...
封装链表：
weixin_72151098的博客
08-26 160
链表的最后一个结点的next不再指向NULL，而是指向头结点，这种链表称为单向循环链表，简称循环链表，它好处是可以通过任意结点来遍历整个链表。牺牲了随机访问的功能、也没达到链表动态申请内存的效果，只是给没有指针的编程语言实现链表的一种方式，适用范围不大。顺序结构：数据存储在连续的内存中，可以使用数据的相对位置来表示数据之间的关系。注意：栈、队列的功能受限、只能操作栈顶或队头队尾，除此之外操作其他任何元素都是非法的。创建、销毁、清空、添加、删除、查询、访问、修改、排序、遍历。栈2不空，栈1不能到栈2。...
单向循环链表的实现C++封装
J.Anson的博客
10-03 932
单项循环链表的实现，C++封装。
【数据结构-C语言】单向链表，循环单向链表
sakura0908的博客
03-02 2090
顺序表：顺序存储的线性表 链式表：链式存储的线性表，简称链表 由于顺序表的缺点（数据连续存储），顺序存储的数据因为挤在一起而导致需要成片移动，那很容易想到的解决方案是将数据离散地存储在不同内存块中，然后再用指针将他们串起来，这种朴素的思路所形成的链式线性表，就是所谓的链表。顺序表和链表存在的基本样态如下图所示
C语言数据结构之双向循环链表的实例
08-30
主要介绍了C语言数据结构之双向循环链表的实例的相关资料,需要的朋友可以参考下
python实现数据结构中双向循环链表操作的示例
12-16
看此博客之前建议先看看B站的视频python数据结构与算法系列课程，该课程中未实现双向循环链表的操作，所以我按照该视频的链表思路实现了双向循环链表的操作，欢迎大家阅读与交流，如有侵权，请联系博主！ 下面附上代码： class Node: def __init__(self, elem): self.elem = elem self.prev = None self.next = None class DoubleCycleLinkList: def __init__(self, node=None): self.__head = node de
C语言实现循环链表
12-17
本文实例为大家分享了C语言实现循环链表的具体代码，供大家参考，具体内容如下 注意事项： 1、循环链表设置尾指针。由于在链表的操作过程中，尾指针会不断变化，所以在一些函数的形参中都设置指向头指针的指针。以及链表的结束判断条件变成q是否等于尾指针。 2、注意传递的实参需要取地址 3、循环链表的优势在于双链表合并，以及实现尾插法简单（首先新建结点指向头结点，然后把尾指针的next域指向该新建结点） 4、在创建链表时，使用尾插法，而不是用头插法（因为头插法很难去更新尾指针，使得最后尾指针还需额外更新一次）,直接用头插法建立的是头指针,而非尾指针 代码： #include #inc
栈和队列--数据结构
m0_72565784的博客
04-25 616
一种特殊的线性表，其只。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵循“后进先出”（LIFO）的原则。
【数据结构】图的应用（最小生成树、拓扑排序、最短路径等）
2201_75475240的博客
04-27 1272
本文章介绍数据结构中的图的应用，包括最小生成树的Prim算法和Kruskal算法，拓扑排序和最短路径，且还包含408习题（附有解析）。此外，含有关于Prim算法，Kruskal算法和Dijkstra算法全部具体实现代码。
【数据结构】二叉树（带图详解）
最新发布
Z1tai的博客
04-27 1510
链表和数组都是线性结构，而树是非线性的结构。树是依靠分支关系定义出的一种层次结构。社会亲缘关系和组织结构图都可以用树来形象地表示。
数据结构系列-二叉树之前序遍历
in_seattle的博客
04-26 477
这篇文章，我们主要的内容是对二叉树当中的前历的算法进行讲解，二叉树中的算法所要求实现的是 从根到左子树再到右子树的遍历顺序，可能这样不太好理解，我们拿一张图片进行解释，我们先来分析一下这个的实现逻辑是什么，按照根节点，左子树，右子树的顺序，我们先来判断一下这个应该实现的结果是什么。在这里，我们将空也表现了出来，那下面，我们就讲解一下怎么用代码实现这个过程。假设在这个二叉树当中，我们要实现二叉树遍历当中的前历，我们应该怎么做呢。这些代码我们在前面就详细的进行了展开，在这里我们就不进行详细的讲解。
【数据结构】第二章 线性数据结构.线性表.顺序表
KX_52517的博客
04-26 1347
线性数据结构章节
《数据结构》（学习笔记）（王道）
qiqi_liuliu的博客
04-23 624
Personal study notes, please point out any errors, thank you!
循环链表 python
09-13
循环链表是一种特殊类型的链表，其最后一个节点指向头节点，形成了一个循环的结构。 在 Python 中，可以通过定义一个 Node 类来表示链表中的节点，每个节点包含两个属性：data（存储节点的数据）和 next（指向下一个节点）。 下面是一个实现循环链表的示例代码： ```python class Node: def __init__(self, data): self.data = data self.next = None def create_circular_linked_list(elements): if len(elements) == 0: return None head = Node(elements[0]) current = head for i in range(1, len(elements)): new_node = Node(elements[i]) current.next = new_node current = new_node current.next = head # 将最后一个节点的 next 指向头节点，形成循环 return head ``` 你可以调用 `create_circular_linked_list` 函数，并传入一个列表作为参数来创建循环链表。例如： ```python elements = [1, 2, 3, 4, 5] head = create_circular_linked_list(elements) ``` 这样就创建了一个包含元素 `[1, 2, 3, 4, 5]` 的循环链表。你可以通过遍历链表来访问每个节点的数据，并且可以使用 `head.next` 来访问下一个节点。 希望这可以帮助到你！如果你还有其他问题，请随时提出。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

哈哈ha~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值