数据结构——链表基本功能的代码实现

最新推荐文章于 2024-07-18 12:25:18 发布
最新推荐文章于 2024-07-18 12:25:18 发布
阅读量253 收藏
点赞数
文章标签： 数据结构 链表 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CoderMateng/article/details/105124897
版权

单向链表
单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包括两个域，一个信息域（元素域），一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域指向一个空值。

单链表操作实现：
is_empty() 链表是否为空
length() 链表长度
travel() 遍历整个链表
add(item) 链表头部添加元素
append(item) 链表尾部添加元素
insert(pos , item) 链表指定位置添加元素
remove(item) 删除节点
search(item) 查找节点是否存在

class Node(object):
    '''构造单向链表节点'''
    def __init__(self, elem):
        self.elem = elem
        self.next = None


class SingleLinkList(object):
    '''构造单向链表'''
    def __init__(self, node=None):
        self.__head = node ##双下划线表示私有变量

    def is_empty(self):
        '''链表是否为空'''
        return self.__head is None

    def length(self):
        '''链表长度'''
        #cur游标，用来移动遍历节点
        cur = self.__head
        #count计数器，记录数量
        count = 0
        while cur is not None:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        '''遍历整个链表'''
        # cur游标，用来移动遍历节点
        cur = self.__head
        while cur is not None:
            print(cur.elem, end=' ')
            cur = cur.next
        print('')

    def add(self, item):
        '''链表头部添加元素'''
        node = Node(item)
        node.next = self.__head
        self.__head = node

    def append(self, item):
        '''链表尾部添加元素'''
        node = Node(item)
        if self.is_empty():
            self.__head = node
        else:
            cur = self.__head
            while cur.next is not None:
                cur = cur.next
            cur.next = node

    def insert(self, pos, item):
        '''链表指定位置添加元素'''
        node = Node(item)
        pre = self.__head ##pre为游标，最终指向指定位置pos前一个节点
        count = 0
        if pos <= 0:
            self.add(item)
        elif pos > (self.length() - 1):
            self.append(item)
        else:
            while count < (pos - 1):
                count += 1
                pre = pre.next
            ##循环结束后，pre位于(pos - 1)节点处
            node.next = pre.next
            pre.next = node


    def remove(self, item):
        '''删除节点'''
        cur = self.__head
        pre = None
        while cur is not None:
            if cur.elem == item:
                #先判断此节点是否为首节点
                if cur == self.__head: #是首节点
                    self.__head = cur.next
                else:
                    pre.next = cur.next
                break
            else:
                pre = cur
                cur = cur.next


    def search(self, item):
        '''查找节点是否存在'''
        cur = self.__head
        while cur is not None:
            if cur.elem == item:
                return True
            else:
                cur = cur.next
        return False

if __name__ == '__main__':
    ll = SingleLinkList()
    print(ll.is_empty())
    print(ll.length())

    ll.append(1)
    print(ll.is_empty())
    print(ll.length())

    ll.append(2)
    ll.add(0)
    ll.append(3)
    ll.append(4)
    ll.append(5)
    ll.append(6)
    ll.insert(-1, -1) #-1,0,1,2,3,4,5,6
    ll.travel()
    ll.insert(2, 8) #-1,0,8,1,2,3,4,5,6
    ll.travel()
    ll.insert(10, 7) #-1,0,8,1,2,3,4,5,6,7
    ll.travel()
    print(ll.search(8)) #Ture
    ll.search(10) #False
    ll.remove(8)
    ll.travel() #-1,0,1,2,3,4,5,6,7

程序运行结果如下：
在这里插入图片描述
双向链表
一种更复杂的链表是“双向链表”或“双面链表”。每个节点有两个链接：一个指向前节点，此节点为第一个节点时，指向空值；而另一个指向下一个节点，此节点为最后一个节点时，指向空值。
双向链表操作实现：
is_empty() 链表是否为空
length() 链表长度
travel() 遍历整个链表
add(item) 链表头部添加元素
append(item) 链表尾部添加元素
insert(pos , item) 链表指定位置添加元素
remove(item) 删除节点
search(item) 查找节点是否存在

class Node(object):
    '''构造双向链表节点'''
    def __init__(self, item):
        self.elem = item
        self.prev = None
        self.next = None

class SingleLinkList(object):
    '''构造双向链表'''
    def __init__(self, node=None):
        self.__head = node ##双下划线表示私有变量

    def is_empty(self):
        '''链表是否为空'''
        return self.__head is None

    def length(self):
        '''链表长度'''
        #cur游标，用来移动遍历节点
        cur = self.__head
        #count计数器，记录数量
        count = 0
        while cur is not None:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        '''遍历整个链表'''
        # cur游标，用来移动遍历节点
        cur = self.__head
        while cur is not None:
            print(cur.elem, end=' ')
            cur = cur.next
        print('')

    def add(self, item):
        '''链表头部添加元素'''
        node = Node(item)
        node.next = self.__head
        self.__head = node
        node.next.prev = node #原首节点的前驱链接指向新添加的节点
        #相同操作
        # self.__head.prev = node #原首节点的前驱链接指向新添加的节点
        # self.__head = node#head指向新添加节点

    def append(self, item):
        '''链表尾部添加元素'''
        node = Node(item)
        if self.is_empty():
            self.__head = node
        else:
            cur = self.__head
            while cur.next is not None:
                cur = cur.next
            cur.next = node
            node.prev = cur #新添加节点的前驱链接指向原尾节点

    def insert(self, pos, item):
        '''链表指定位置添加元素'''
        node = Node(item)
        cur = self.__head #cur为游标，最终指向指定位置pos节点
        count = 0
        if pos <= 0:
            self.add(item)
        elif pos > (self.length() - 1):
            self.append(item)
        else:
            while count < pos:
                count += 1
                cur = cur.next
            ##循环结束后，cur位于pos节点处
            node.next = cur#新添加节点的后驱链接指向cur所指向的节点
            node.prev = cur.prev#新添加节点的前驱链接指向cur所指节点的前一个节点
            cur.prev.next = node #cur所指节点的前一个节点的后驱链接指向新添加节点
            cur.prev = node #cur所指节点的前驱链接指向新添加节点
            #相同操作
            # cur.prev = node  # cur所指节点的前驱链接指向新添加节点
            # node.prev.next = node  # node所指节点的前一个节点的后驱链接指向新添加节点（新添加的node已经代替代替了cur来的所指向节点的位置）


    def remove(self, item):
        '''删除节点'''
        cur = self.__head
        while cur is not None:
            if cur.elem == item:
                #先判断此节点是否为首节点
                if cur == self.__head: #是首节点
                    self.__head = cur.next #head指向原首节点的下一个节点
                    if cur.next:
                    #判断原链表是否只有一个节点（判断cur.next这个节点是否存在）
                        cur.next.prev = None #原首节点的下一个节点的前驱链接置空
                else:
                    cur.prev.next = cur.next#cur所指向节点的前一个节点的后驱链接指向cur所指向节点的后一个节点
                    if cur.next:
                    #判断此节点是否为尾节点（判断cur.next这个节点是否存在）
                        cur.next.prev = cur.prev#cur所指向节点的后一个节点的前驱链接指向cur所指向节点的前一个节点
                break
            else:
                cur = cur.next


    def search(self, item):
        '''查找节点是否存在'''
        cur = self.__head
        while cur is not None:
            if cur.elem == item:
                return True
            else:
                cur = cur.next
        return False

if __name__ == '__main__':
    dll = SingleLinkList()
    print(dll.is_empty())
    print(dll.length())

    dll.append(1)
    print(dll.is_empty())
    print(dll.length())

    dll.append(2)
    dll.add(0)
    dll.append(3)
    dll.append(4)
    dll.append(5)
    dll.append(6)
    dll.insert(-1, -1) #-1,0,1,2,3,4,5,6
    dll.travel()
    dll.insert(2, 8) #-1,0,8,1,2,3,4,5,6
    dll.travel()
    dll.insert(10, 7) #-1,0,8,1,2,3,4,5,6,7
    dll.travel()
    print(dll.search(8)) #Ture
    dll.search(10) #False
    dll.remove(8)
    dll.travel() #-1,0,1,2,3,4,5,6,7

程序运行结果如下：
在这里插入图片描述
单向循环链表
单链表的一个变形是单向循环链表，链表中最后一个节点的next域不再为None，而是指向链表的头节点。
单向循环链表操作实现：
is_empty() 链表是否为空
length() 链表长度
travel() 遍历整个链表
add(item) 链表头部添加元素
append(item) 链表尾部添加元素
insert(pos , item) 链表指定位置添加元素
remove(item) 删除节点
search(item) 查找节点是否存在

class Node(object):
    '''构造单向循环链表节点'''

    def __init__(self, elem):
        self.elem = elem
        self.next = None


class SingleCycleLinkList(object):
    '''构造循环单向链表'''

    def __init__(self, node=None):
        self.__head = node  ##双下划线表示私有变量
        #判断是否有节点存在（判断是否不是只有NOne）
        if node:
            node.next = node #有一个节点时候，它的next域指向首节点，也就是指向自身

    def is_empty(self):
        '''链表是否为空'''
        return self.__head is None

    def length(self):
        '''链表长度'''
        if self.is_empty(): #判断链表是否为空链表，是则直接返回长度为0
            return 0
        # cur游标，用来移动遍历节点
        cur = self.__head
        # count计数器，记录数量
        count = 1
        while cur.next is not self.__head:#当前游标所指节点的next域不是首节点就继续移动
            count += 1
            cur = cur.next
        return count

    def travel(self):
        '''遍历整个链表'''
        if self.is_empty():#判断是否为特殊情况：链表中没有节点
            return
        # cur游标，用来移动遍历节点
        cur = self.__head
        while cur.next is not self.__head:
            print(cur.elem, end=' ')
            cur = cur.next
        #退出循环，cur指向尾节点，但尾节点元素未打印
        print(cur.elem)
        #print('')

    def add(self, item):
        '''链表头部添加元素'''
        node = Node(item)
        if self.is_empty():
            self.__head = node
            node.next = node
        else:
            cur = self.__head
            while cur.next is not self.__head:
                cur = cur.next
            #退出循环，cur指向尾节点
            node.next = self.__head
            self.__head = node
            #cur.next = node
            cur.next = self.__head

    def append(self, item):
        '''链表尾部添加元素'''
        node = Node(item)
        if self.is_empty():
            self.__head = node
            node.next = node
        else:
            cur = self.__head
            while cur.next is not self.__head:
                cur = cur.next
            # 退出循环，cur指向尾节点
            # node.next = cur.next
            node.next = self.__head
            cur.next = node

    def insert(self, pos, item):
        '''链表指定位置添加元素'''
        node = Node(item)
        pre = self.__head  ##pre为游标，最终指向指定位置pos前一个节点
        count = 0
        if pos <= 0:
            self.add(item)
        elif pos > (self.length() - 1):
            self.append(item)
        else:
            while count < (pos - 1):
                count += 1
                pre = pre.next
            ##循环结束后，pre位于(pos - 1)节点处
            node.next = pre.next
            pre.next = node

    def remove(self, item):
        '''删除节点'''
        if self.is_empty(): #没有节点的情况下
            return
        cur = self.__head
        pre = None
        while cur.next is not self.__head:
            if cur.elem == item:
                # 先判断此节点是否为首节点
                if cur == self.__head:  # 是首节点
                    #是首节点的情况
                    #找尾节点
                    rear = self.__head
                    while rear.next is not self.__head:
                        rear = rear.next
                    #退出循环后，rear指向尾节点
                    self.__head = cur.next
                    rear.next = self.__head
                else:
                    #中间节点
                    pre.next = cur.next
                return 
            else:
                pre = cur
                cur = cur.next
            #退出循环，cur指向尾节点
            if cur.elem == item:
                if cur == self.__head:#链表中只有一个节点
                    self.__head = None
                else:
                    pre.next =cur.next


    def search(self, item):
        '''查找节点是否存在'''
        if self.is_empty():
            return False
        cur = self.__head
        while cur.next is not self.__head:
            if cur.elem == item:
                return True
            else:
                cur = cur.next
            #退出循环，cur指向尾节点
        if cur.elem == item:
            return  True
        return False


if __name__ == '__main__':
    ll = SingleCycleLinkList()
    print(ll.is_empty())
    print(ll.length())

    ll.append(1)
    print(ll.is_empty())
    print(ll.length())

    ll.append(2)
    ll.add(0)
    ll.append(3)
    ll.append(4)
    ll.append(5)
    ll.append(6)
    ll.insert(-1, -1)  # -1,0,1,2,3,4,5,6
    ll.travel()
    ll.insert(2, 8)  # -1,0,8,1,2,3,4,5,6
    ll.travel()
    ll.insert(10, 7)  # -1,0,8,1,2,3,4,5,6,7
    ll.travel()
    print(ll.search(8))  # Ture
    ll.search(10)  # False
    ll.remove(8)
    ll.travel()  # -1,0,1,2,3,4,5,6,7

程序运行结果如下：
在这里插入图片描述

CoderMateng
关注
数据结构链表代码
weixin_37862342的博客
05-16 567
typedef struct Node {/单链表结点结构体定义/ DataType data; struct Node* next; }SLNode; void ListInitiate(SLNode **head) {/单链表初始化/ head = (SLNode)malloc(sizeof(SLNode)); (*head)->next = NULL; } int ListLength(SLNode* head) {/* 求单链表数据元素个数*/ SLNode *p = head; int si
数据结构——链表（单链表）
LGFaiJC的博客
03-26 2046
我们想一想在链表的头部插入数据我们只需要开辟一个链表空间mon然后另它的next指向当前链表的表头的地址，并将mon的地址交给表头的指针是不是就可以插入数据并且将链表连接起来了？我们通过图可以看出尾插数据要开辟一个新的节点然后让原链表的最后一个节点的next指向新开辟出来的节点并将新开辟的节点的next为空。这个就是链表的逻辑结构了，一个节点中有指向下一个节点的指针，这样走下去最后一个节点中放的是空指针NULL，像链条一样一环扣一环。这里开辟一个新的链表空间我们还会用到所有我们用一个函数来实现。
链表基本操作源码
12-28
c 语言 链表基本操作，创建 查找 删除 插入 双向链表源码
数据结构--链表（代码实现）
cat_eat_fish
11-23 1328
链表分类 链表分为单向链表(Singly linked lis)、双向链表(Doubly linked list)、循环链表(Circular Linked list)。 应用： 1).用于数据数目事先无法确定的情况； 2).用于数据数在内存中不连续存放的情况； 组成： 1). 头指针 2). 结点(节点) 2.1 数据域 2.2 指针域...
数据结构 【链表】部分功能实现
m0_62685465的博客
03-18 411
一. 单链表的定义、插入与删除 1.定义一个单链表 typedef struct LNode { ElemType data; struct LNode *next; }LNode, *LinkList; typedef <数据类型> <别名> 用别名来代替该数据类型名 LinkList为指向该单链表的指针。 2.初始化一个空的单链表，与判断单链表是否为空 1.不带头结点的单链表 bool InitList(LinkList &L) { L = N
数据结构学习——链表的简易功能实现
qq_53222216的博客
12-02 721
链表 create 函数 insert 函数 delete函数 以及sort（本函数中采用选择排序的方法）的实现
数据结构——链表的实现
12-29
在这个数据结构——链表的实现中，我们将深入探讨如何用C++来创建一个链表类，并实现搜索、删除、插入和查找等基本操作。 首先，链表的基本思想是使用节点（或称为元素）来存储数据，每个节点包含两部分：数据域和...
算法和数据结构——链表.pdf
08-07
在标题《算法和数据结构——链表.pdf》中提到的“算法”指的是对数据的处理过程和步骤，而“数据结构”是指数据在计算机中的组织方式，二者在计算机科学中是基础且核心的概念。在数据结构的学习中，链表是实现算法的...
数据结构与算法详解——链表篇（附c++实现代码）
JMasker的博客
05-01 3343
链表详解及完整实现
Python 数据结构——链表（一）
最新发布
Ahjol171的博客
07-18 2020
建立链表，链表排序，链表输出，链表随机访问，删除节点，链表插入，在链表中查找元素，返回链表长度
关于链表基本操作的C++源代码
12-27
期末课程设计题目，使用C++实现关于链表的基本操作，本人也是学生，初学，写的不好，仅供参考。
链表的基本操作源代码
weixin_30768661的博客
05-16 260
//链表的基本操含有对链表的建立，插入，删除，查询，输出等基本操作 /在此特别提醒链表的基础尤为重要，在这里重写此代码能够更加深刻的理解了链表的空间的申请， /头节点的建立以及头指针的重要和尾节点存在的必要性 /这个源代码以链表的创建为核心，为了怕麻烦就没有进行优化，但是创建和输出是这个代码的核心。 /希望这个能帮助到初学者，在这有不懂得地方可以看我的随笔，链表的整表的创建，那里有更加详细...
数据结构之（链表）代码
北方的雪之博客专栏
09-08 1073
LinkNode.h #include "stdafx.h" typedef int elemtype;//int可以换成任意基本数据类型 typedef struct lnode//链表结点 { elemtype data; struct lnode *next; int length; }lnode; lnode *create_list();//创建链表 void out_lis
链表代码|数据结构
资资的博客
12-16 256
一、线性链表 线性链表的存储结构 typedef int datatype; typedef struct node { datatype data; struct node *next; }linklist; 头结点与第一个数据结点一定要区分开来 头结点是整个线性链表的第一个结点，它的数据域可以用来存放线性表的长度等附加信息，也可以不存储任何信息。 线性链表的基本运算 运算 函数名...
数据结构:链表的基本操作实现
m0_58311374的博客
04-25 1682
本文实现的是带头结点的链表 一、链表的定义 typedef struct node { ElemType data; struct node* next; }LNode, *LinkList; 二、基本操作实现 //创建空链表 LinkList Creat_LinkList() { LinkList L = (LinkList)malloc(sizeof(LNode)); if (L) { printf("创建成功\n"); L->next = NULL; } else
数据结构循环单链表基本操作（C/C++实现）
JunsIr的技术栈
10-22 2761
数据结构循环单链表基本操作（C/C++实现） 注意：本代码为了测试运行默认含有操作所需数据，如有需要可自己增删改相关数据 涉及基本运算 初始化循环单链表 依次采用尾插法插入元素 输出循环单链表 输出循环单链表的长度 判空 判断循环单链表的第n个元素 输出元素x的位置 在第n个元素位置上插入f元素 输出循环单链表 删除循环单链表的第n个元素 输出循环单链表 释放循环单链表 GitHub地址（包含...
数据结构学习（C语言）之链表代码
DLUT_yan的博客
04-16 9344
（郝斌老师视频课） 简介： 24_链表创建和链表遍历算法的演示 25_判断链表是否为空和求链表长度算法的演示 26_通过链表排序算法的演示再次详细讨论到底什么是算法以及到底什么是泛型【重点】 27_如何学习算法自己的一些感想 28_链表插入和删除算法的演示 29_复习 24_链表创建和链表遍历算法的演示 创建一个节点的结构体： typedef struct Node { int data;//数...
数据结构_链表详细代码
destiny_JL的博客
12-06 1335
#include<stdio.h> #include<stdlib.h> typedef int elemtype; typedef struct node { elemtype data; struct node *next; }*linklist,node; linklist initlinklist() { linklist h=(node*)malloc(sizeof(node)); h->next=NULL; return h; } void inse
数据结构-单链表基本功能的实现
qq_61167424的博客
03-23 2476
链表其实就那么回事儿
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值