python链表的基础概念和基础用法详解

本文为大家分享了python链表的基础概念和基础用法,供大家参考,具体内容如下

一、什么是链表

链表是由多个不同的节点组成,每个节点通过指针区域关联到一起
链表的头指针,指向了头节点,通过头指针可以找到其他节点信息

二、什么是节点

链表由节点组成,每个节点又包含两个部分,一个是元素区域,一个是指针区域。
元素区域存储的是,当前节点的数值,指针区域指向下一个节点的对象。在C语言中,指针应该是指向下一个元素的的内存地址,因python中不研究指针,这里用下一个节点的对象代替。这样我们就能通过指针区域,找到下一个节点的信息,从而得到下一个节点的值了。

三、为什么引入链表的概念

1.先说说数组这种数据结构吧,数组是一块大的连续内存空间。每次初始化需要开辟一大块内存空间,空间利用率比较低。而链表则不同,链表的节点可以随机分布在任何位置,只需通过指针穿引起来即可。
2.在连续的内存空间中,插入一个元素时,所有其他元素的位置也变动了。插入元素、删除元素时候,效率比较低。
链表是非连续的内存空间,每个节点单独存在自己的内存空间,通过指针指向下一个节点。
如果在某个地方插入一个节点,只需要改变指针的指向即可,不用其他元素都变动。

四、链表的基本操作

# 实现头部插入 尾部插入 根据索引插入 删除节点并print 打印
# 定义一个节点
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class SingleLinkList:

    def __init__(self):
        self.head = None
        self.tail = None

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

    def length(self):
        """求当前链表的长度
        :return:
        """
        count = 0
        cur = self.head

        while cur is not None:
            count += 1
            cur = cur.next

        return count

    def insert_head_node(self, data):
        """链表头部添加元素
        :param data: 要保存的数据
        :return:
        """
        node = Node(data)
        node.next = self.head
        self.head = node

    def append_node(self, data):
        """链表尾部添加元素,有多种实现方式
        :param data:
        :return:
        """
        # 第一种方式  时间复杂度为O(n)的处理方式
        node = Node(data)
        # 如果链表为空,需要特殊处理
        if self.is_empty():
            self.head = node
        else:
            cur = self.head
            while cur.next is not None:
                cur = cur.next
            # 退出循环时, cur指向尾节点
            cur.next = node

        # 第二种 引入一个tail指针 默认当前链表为一个空链表,不停的去append节点

        # node = Node(data)
        # if self.is_empty():  # 当第一次添加节点到空链表中的时候,头指针和尾指针同时指向新节点
        #     self.head = node
        #     self.tail = node

        # else:
        # 当再次添加节点到链表中的时候, 头指针始终指向头节点,尾指针始终执行未节点,如果一直向未节点追加节点,只需移动tail指针即可
        #     self.tail.next = node
        #     self.tail = node

    def insert_node(self, pos, data):
        """指定位置添加元素
        :param pos:
        :param data:
        :return:
        """
        # 1, 在头部添加
        if pos <= 0:
            self.insert_head_node(data)
        # 2, 在尾部添加
        elif self.length() >= pos:
            self.append_node(data)
        # 3, 指定位置添加
        else:
            count = 0
            while count < (pos - 2):
                count += 1
                self.head = self.head.next

            # 这时候self.head 表示当前插入前一个节点
            # self.head.next 表示当前插入的后一个节点
            node = Node(data)
            self.head.next = node
            node.next = self.head.next

    def delete_node(self, data):
        """删除节点
        :param data:
        :return:
        """
        cur = self.head     # 记录当前节点的位置
        pre = None          # 记录当前节点位置的前置节点
        while cur is not None:
            # 找到了要删除的元素
            if cur.data == data:
                # 在头部找到了要删除的元素
                if cur == self.head:
                    self.head = cur.next
                    return True
                else:
                    pre.next = cur.next
                    return True
            else:
                # 不是要找的元素, 移动光标
                pre = cur
                cur = cur.next

    def search_node(self, data):
        """查找节点是否存在
        :return:
        """
        cur = self.head
        while cur is not None:
            if cur.data == data:
                return True
            cur = cur.next
        return False

    def reveres_node(self):
        """链表反转
        :return:
        """
        if self.is_empty():
            return
        j = 0
        while j < self.length() - 1:
            cur = self.head
            for i in range(self.length() - 1):
                cur = cur.next
                if cur.next is None:
                    x = cur.data
                    self.delete_node(cur.data)
                    self.insert_node(j, x)
            j += 1
        return self.head

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • python双向链表实现实例代码

    示意图: python双向链表实现代码: 复制代码 代码如下: #!/usr/bin/python# -*- coding: utf-8 -*- class Node(object):    def __init__(self,val,p=0):        self.data = val        self.next = p        self.prev = p class LinkList(object):    def __init__(self):        self.he

  • Python单链表的简单实现方法

    本文实例讲述了Python单链表的简单实现方法,分享给大家供大家参考.具体方法如下: 通常来说,要定义一个单链表,首先定义链表元素:Element.它包含3个字段: list:标识自己属于哪一个list datum:改元素的value next:下一个节点的位置 具体实现代码如下: class LinkedList(object): class Element(object): def __init__(self,list,datum,next): self._list = list self.

  • python数据结构链表之单向链表(实例讲解)

    单向链表 单向链表也叫单链表,是链表中最简单的一种形式,它的每个节点包含两个域,一个信息域(元素域)和一个链接域.这个链接指向链表中的下一个节点,而最后一个节点的链接域则指向一个空值. 表元素域elem用来存放具体的数据. 链接域next用来存放下一个节点的位置(python中的标识) 变量p指向链表的头节点(首节点)的位置,从p出发能找到表中的任意节点. 节点实现 class Node(object): """单链表的结点""" def __i

  • 使用python实现链表操作

    一.概念梳理 链表是计算机科学里面应用应用最广泛的数据结构之一.它是最简单的数据结构之一,同时也是比较高阶的数据结构(例如棧.环形缓冲和队列) 简单的说,一个列表就是单数据通过索引集合在一起.在C里面这叫做指针.比方说,一个数据元素可以由地址元素,地理元素.路由信息活着交易细节等等组成.但是链表里面的元素类型都是一样的,是一种特殊的列表. 一个单独的列表元素叫做一个节点.这些节点不像数组一样都按顺序存储在内存当中,相反,你可以通过一个节点指向另外一个节点的指针在内存不同的地方找到这些元素.列表最

  • Python单向链表和双向链表原理与用法实例详解

    本文实例讲述了Python单向链表和双向链表原理与用法.分享给大家供大家参考,具体如下: 链表是一种数据结构,链表在循环遍历的时候效率不高,但是在插入和删除时优势比较大. 链表由一个个节点组成. 单向链表的节点分为两个部分:存储的对象和对下一个节点的引用.注意是指向下一个节点. 而双向链表区别于单向链表的是它是由三个部分组成:存储的对象.对下一个节点的引用.对上一个节点的引用,可以实现双向遍历. 单向列表的结构如下图: head是头节点,tail是尾节点,每个节点由Data存储对象和Next对下

  • 用python介绍4种常用的单链表翻转的方法小结

    如何把一个单链表进行反转? 方法1:将单链表储存为数组,然后按照数组的索引逆序进行反转. 方法2:使用3个指针遍历单链表,逐个链接点进行反转. 方法3:从第2个节点到第N个节点,依次逐节点插入到第1个节点(head节点)之后,最后将第一个节点挪到新表的表尾. 方法4: 递归(相信我们都熟悉的一点是,对于树的大部分问题,基本可以考虑用递归来解决.但是我们不太熟悉的一点是,对于单链表的一些问题,也可以使用递归.可以认为单链表是一颗永远只有左(右)子树的树,因此可以考虑用递归来解决.或者说,因为单链表

  • 浅谈Python单向链表的实现

    链表由一系列不必在内存中相连的结构构成,这些对象按线性顺序排序.每个结构含有表元素和指向后继元素的指针.最后一个单元的指针指向NULL.为了方便链表的删除与插入操作,可以为链表添加一个表头. 删除操作可以通过修改一个指针来实现. 插入操作需要执行两次指针调整. 1. 单向链表的实现 1.1 Node实现 每个Node分为两部分.一部分含有链表的元素,可以称为数据域:另一部分为一指针,指向下一个Node. class Node(): __slots__=['_item','_next'] #限定N

  • python实现单向链表详解

    本文研究的主要是Python中实现单向链表的相关内容,具体如下. 什么是链表 链表顾名思义就是-链 链表是一种动态数据结构,他的特点是用一组任意的存储单元存放数据元素.链表中每一个元素成为"结点",每一个结点都是由数据域和指针域组成的.跟数组不同链表不用预先定义大小,而且硬件支持的话可以无限扩展. 链表与数组的不同点: 数组需要预先定义大小,无法适应数据动态地增减,数据小于定义的长度会浪费内存,数据超过预定义的长度无法插入.而链表是动态增删数据,可以随意增加. 数组适用于获取元素的操作

  • Python数据结构与算法之链表定义与用法实例详解【单链表、循环链表】

    本文实例讲述了Python数据结构与算法之链表定义与用法.分享给大家供大家参考,具体如下: 本文将为大家讲解: (1)从链表节点的定义开始,以类的方式,面向对象的思想进行链表的设计 (2)链表类插入和删除等成员函数实现时需要考虑的边界条件, prepend(头部插入).pop(头部删除).append(尾部插入).pop_last(尾部删除) 2.1 插入: 空链表 链表长度为1 插入到末尾 2.2 删除 空链表 链表长度为1 删除末尾元素 (3)从单链表到单链表的一众变体: 带尾节点的单链表

  • Python 实现链表实例代码

    Python 实现链表实例代码 前言 算法和数据结构是一个亘古不变的话题,作为一个程序员,掌握常用的数据结构实现是非常非常的有必要的. 实现清单 实现链表,本质上和语言是无关的.但是灵活度却和实现它的语言密切相关.今天用Python来实现一下,包含如下操作: ['addNode(self, data)'] ['append(self, value)'] ['prepend(self, value)'] ['insert(self, index, value)'] ['delNode(self,

随机推荐