数据结构之单向循环链接，双向循环链表的常用方法封装

最新推荐文章于 2024-08-12 11:00:00 发布
最新推荐文章于 2024-08-12 11:00:00 发布
阅读量164 收藏
点赞数
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chuxialia/article/details/126509107
版权
本文介绍了单向循环链表和双向循环链表的实现，包括添加元素、插入元素、移除元素、查找元素等基本操作，并通过示例展示了这些操作的使用。在单向循环链表中，添加、插入和删除元素的逻辑得到了阐述。对于双向循环链表，除了相同的操作外，还额外提供了正向和反向输出链表元素的字符串方法。示例代码演示了链表的创建、元素的添加、删除及查找过程。
摘要由CSDN通过智能技术生成

单向循环链表

上一篇文章已经讲过单向链表和双向链表了，那么这里就不在赘述了，单向循环链接，双向循环链表只是加了一个从尾结点指向头结点的这一步，其他的不变

所以我们就直接封装方法啦，其他的就不在细说了

单向循环链表常用的方法

上一篇文章以及详细讲过，这里就不一一分开写了，直接合并在一起封装出来

<script>
  class Cnode {
        constructor(data) {
            this.data = data;
            this.next = null;
        }
    }
    class CycleLinkList {
        constructor() {
            this.head = null;
            this.len = 0
        }

        // 1.向链表最后添加元素
        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.next = newnode;
                newnode.next = this.head;
            }
            this.len++
        }

        // 2.向链表中插入元素
        insert(position, ele) {
            if (position < 0 || position > this.len || !Number.isInteger(position)) {
            	return
            }
            let newnode = new Cnode(ele);
            let current = this.head,
                index = 0;
            if (position == 0) {
                if (this.len == 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.len++
            } else if (position == this.len) {
                this.append(ele)
            } else {
                while (index < position - 1) {
                    current = current.next;
                    index++;
                }
                newnode.next = current.next;
                current.next = newnode;
                this.len++
            }
        }

        // 3.removeAt(position)  移除指定位置的元素
        removeAt(position) {
            if (position < 0 || position > this.len || !Number.isInteger(position)) {
            	return
            }
            let current = this.head,
                index = 0;
            if (position == 0) {
                if (this.len == 1) {
                    this.head = null;
                } else {
                    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.len--
        }

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

        // 5.移除指定元素
        remove(ele){
            this.removeAt(this.indexOf(ele))
        }
        toString() {
            let current = this.head,
                index = 0,
                res = "";
            while (index < this.len) {
                res += "-" + current.data;
                current = current.next;
                index++;
            }
            return res.slice(1)
        }
    }
    
    let clist = new CycleLinkList();
    for (let i = 0; i < 4; i++) {
        clist.append(i)
    }
    
    console.log(clist.indexOf("hello"));
    console.log(clist.indexOf(0));
    console.log(clist.indexOf(2));
    console.log(clist.indexOf(666));

    clist.remove("hello")
    clist.remove(1)
    clist.remove(2)
    clist.remove(0)
    clist.remove(4)

    console.log(clist.toString());
</script>

结果

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
移除过后就只剩下了3这个元素了

双向循环链表

<script>
   class Node {
       constructor(data) {
           this.prev = null;
           this.data = data;
           this.next = null;
       }
   }
   class CycleDoubleLinkList {
       constructor() {
           this.head = null;
           this.tail = null;
           this.len = 0;
       }
       
       // 1.向链表最后添加元素
       append(ele) {
           let newnode = new Node(ele);
           if (this.len == 0) {
               this.head = newnode;
               this.tail = newnode;
               newnode.prev = this.tail;
               newnode.next = this.head;
           } else {
               newnode.prev = this.tail;
               newnode.next = this.head;
               this.tail.next = newnode;
               this.head.prev = newnode;
               this.tail = newnode;
           }
           this.len++
       }

       // 2.向链表中的指定位置插入元素
       insert(position, ele) {
            if (position < 0 || position > this.len || !Number.isInteger(position)) {
            	return
            }
           let newnode = new Node(ele);
           if (position == 0) {
               if (this.len == 0) {
                   this.head = newnode;
                   this.tail = newnode;
                   newnode.prev = this.tail;
                   newnode.next = this.head;
               } else {
                   newnode.prev = this.tail;
                   newnode.next = this.head;
                   this.head.prev = newnode
                   this.tail.next = newnode;
                   this.head = newnode;
               }
               this.len++
           }else if(position == this.len){
               this.append(ele)
           }else{
               let current = this.head,index = 0;
               while(index< position-1){
                   current = current.next;
                   index++;
               }
               newnode.prev = current;
               newnode.next = current.next;
               current.next = newnode;
               newnode.next.prev = newnode;
               this.len++
           }
       }
  
       // 3.移除指定位置的元素
       removeAt(position){
            if (position < 0 || position > this.len || !Number.isInteger(position)) {
            	return
            }
           if(position == 0){
               if(this.len == 1){
                   this.head = null;
                   this.tail = null;
               }else{
                   this.head = this.head.next;
                   this.tail.next = this.head;
                   this.head.prev = this.tail;
               }               
           }else if(position == this.len-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.len--
       }
  
       // 4.查找指定元素
       indexOf(ele){
           let current = this.head,index=0;
           while(index < this.len){
               if(current.data == ele){
                   return index
               }else{
                   current = current.next;
                   index++
               }
           }
           return -1
       }

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

		// 6.正向字符串输出
       toAfterString(){
           let current= this.head,index=0,res ="";

           while(index < this.len){
               res+= "-" + current.data;
               current = current.next;
               index++;
           }
           return res.slice(1)
       }
		
		// 7.反向字符串输出
       toBeforeString(){
           let current= this.tail,index=this.len-1,res ="";
           while(index >= 0){
               res+= "-" + current.data;
               current = current.prev;
               index--;
           }
           return res.slice(1)
       }
   }
   let list = new CycleDoubleLinkList()
   for (let i = 0; i < 9; i++) {
       list.append(i)
   }
   console.log(list);
   
   list.insert(0,"hello");
   list.insert(5,"world");
   
   list.removeAt(0);
   list.removeAt(0);
   
   console.log(list.toAfterString());
   console.log(list.toBeforeString());
</script>

结果

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

初夏半微凉
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【数据结构】单向循环链表
dodobibibi的博客
02-06 159
单链表的一个变形是单向循环表，链表中最后一个节点的next域不再为None，而是指向链表的头节点。 class Node(object): """节点""" def __init__(self, elem): self.elem = elem self.next = None class SingleCycleLink(object): ...
数据结构：单向循环链表
pudding666的博客
03-03 296
单向循环链表单向循环链表节点实现单向循环链表实现测试总结 单向循环链表 单链表的一个变形是单向循环链表，链表中最后一个节点的next域不再为None，而是指向链表的头节点。 节点实现 class Node(object): def __init__(self,item): self.item = item self.next = None 单向循环链表实现 class SinCycLinkedlist(object): """单向循环链表"""
【数据结构】（循环链表）链接循环单链表
你好丶下一秒
08-18 300
算法思想：这个就很简单了就是找尾指针的过程进行解链，和链接就行 void Link_A_B(LinkList &A,LinkList &B){ if(A->next==NULL||B->next==NULL) return ; LinkList pa=A->next; LinkList pb=B->next; while(pa-&g...
数据结构：单向循环链表(1)
梦在深巷的博客
07-03 1000
单向循环链表引子回顾以及目的回顾单向链表期望的单向循环链表新建工程增加结点setFirstNode修改MyList测试测试1：没有节点，设置第一个节点测试2：有节点，替换第一个节点addNode修改MyList测试测试1：本身没有节点，addNode加入第一个节点遍历节点修改MyList测试2：本身有一个节点，addNode加入新的节点测试3：本身用addNode加入新的节点，setFirstNode替换第一个节点测试4，使用addNode一次性添加多个节点删除节点deleteFirstNode修改MyLi
数据结构之单向循环链表
jiangbazi的博客
09-05 3266
概述 单向循环链表里面的每一个节点的next都要有指向，最后一个节点的next指向head节点 单向循环链表跟普通的单链表的操作逻辑几乎—模一样，唯一的区别，结尾的判断，区别如下 建议学完单向非循环链表，再来对比 （本人先是在掘金上编辑的，然后复制粘贴自己的博客，所以图片都有掘金的水印，欢迎来我的掘金博客查看原文） 示例代码 //单向循环链表 #include <stdio.h> #include <stdbool.h> #include <stdlib.h> typ
数据结构——单向循环链表&双向循环链表
qq_56668869的博客
08-24 3149
数据结构、单向循环链表、程序实现单向循环链表、方法操作示例、双向循环链表、程序实现双向循环链表
单向循环链表和双向循环链表的结构分析
派拉斯兔子的博客
10-23 1051
单向循环链表： 如果把单链表的最后一个节点的指针指向链表头部，而不是指向NULL，那么就构成了一个单向循环链表，通俗讲就是把尾节点的下一跳指向头结点。 单向循环链表 –多个节点和只有一个节点的结构分析 双向循环链表： 双向循环链表 –多个节点和只有一个节点的结构分析 双向循环链表直接体现为 双向和循环，一般的单链表只有节点数据data和next指向地址(应该也是引用的意思)，而在此需要增加前面部分的pre指向地址，同时还需要循环循环则在定义节点时可以解决，
数据结构——双向循环链表
qq_67611811的博客
08-28 2081
双向循环链表，在原单链表的基础上多了一个指向上一个结点的前驱指针prev，这样前后结点就不仅仅有了单向的从头至尾的指向顺序，也可以从后指向前，从末结点指向头结点。双向带头循环链表结构} DGR;加入前驱指针后，不管是对于链表数据的尾插尾删，或是头插头删，其时间复杂度都为O(1)，大大简化了链表遍历过程，而可以直接在链表首尾增减数据，因为一个链表的末节点可由头结点的前驱指针直接访问而不需要遍历至尾。为了简化文本描述，本章双向循环带头链表均简称为双向链表。...
高阶数据结构——LRU Cache
weixin_74310945的博客
08-09 650
LRU是Least Recently Used的缩写，意思是最近最少使用，它是一种Cache替换算法。什么是Cache？狭义的Cache指的是位于CPU和主存间的快速RAM， 通常它不像系统主存那样使用DRAM技术，而使用昂贵但较快速的SRAM技术。广义上的Cache指的是位于速度相差较大的两种硬件之间， 用于协调两者数据传输速度差异的结构。
常见8种数据结构
qq_43575301的博客
08-08 1957
应用于需要后进先出访问元素的场景，如函数调用栈、表达式求值等。应用于需要先进先出访问元素的场景，如任务调度、消息队列等。适用于优先队列，堆排序和实现高效的合并K个有序链表问题。应用于需要表示层次结构的场景，比如文件系统、组织结构等。应用于需要表示网络结构的场景，如社交网络、交通网络等。应用于需要快速查找和插入操作的场景，如字典、缓存等。一般应用于需要快速随机访问元素的场景。适用于需要频繁插入和删除元素的场景。
基础算法模板
2301_79235379的博客
08-08 509
欢迎订阅专栏，数据结构实验，期末大作业，前端后端，算法都有哦，想我发哪个方面的资源或文章可以私信我，免费的哦。
数据结构--第六天
xujiashuo1的博客
08-08 1265
树是由。
数据结构图书管理系统
2305_78057683的博客
08-07 276
数据结构图书管理系统
数据结构——顺序表
最新发布
2401_82924480的博客
08-12 180
今天我们来进入数据结构的下一节——顺序表，在正式开始说顺序表之前，我们首先需要知道线性表的概念！
「栈」实现LIFO栈（先进后出栈|堆栈|stack）的功能 / 手撕数据结构（C++）
dakingffo的博客
08-09 924
​栈，是一种基本的数据结构，也是一种数据适配器。它在底层上以链表方法或动态数组方法实现。本文选择了使用动态数组来实现这种数据结构。
【数据结构】栈篇
2303_79015671的博客
08-07 1081
手把手教你实现栈~
重生之我 学习【数据结构之顺序表（SeqList）】
xupy019的博客
08-06 1110
全新的开始，为大家带来数据结构的内容（C语言实现）将以顺序表、链表、栈区、队列、二叉树、常见排序算法为主要内容展开学习
数据结构初阶最终讲：排序
2301_79761834的博客
08-09 760
数据结构初阶最终讲：排序
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值