精华内容
下载资源
问答
  • python链表操作

    千次阅读 2018-08-22 09:20:53
    链表中的基本要素: 结点(也可以叫节点或元素),每一个结点有两个域,左边部份叫值域,用于存放用户数据;右边叫指针域,一般是存储着到下一个元素的指针 head结点,head是一个特殊的结节,head结点永远指向第一个...

    链表中的基本要素:

    1. 结点(也可以叫节点或元素),每一个结点有两个域,左边部份叫值域,用于存放用户数据;右边叫指针域,一般是存储着到下一个元素的指针
    2. head结点,head是一个特殊的结节,head结点永远指向第一个结点
    3. tail结点,tail结点也是一个特殊的结点,tail结点永远指向最后一个节点
    4. None,链表中最后一个结点指针域的指针指向None值,因也叫接地点,所以有些资料上用电气上的接地符号代表None

    链表的常用方法:

    1. LinkedList() 创建空链表,不需要参数,返回值是空链表
    2. is_empty() 测试链表是否为空,不需要参数,返回值是布尔值
    3. append(data) 在尾部增加一个元素作为列表最后一个。参数是要追加的元素,无返回值
    4. iter() 遍历链表,无参数,无返回值,此方法一般是一个生成器
    5. insert(idx,value) 插入一个元素,参数为插入元素的索引和值
    6. remove(idx)移除1个元素,参数为要移除的元素或索引,并修改链表
    7. size() 返回链表的元素数,不需要参数,返回值是个整数
    8. search(item) 查找链表某元素,参数为要查找的元素或索引,返回是布尔值

     

    python用类来实现链表的数据结构,节点(Node)是实现链表的基本模块,每个节点至少包括两个重要部分。首先,包括节点自身的数据,称为“数据域”(也叫值域)。其次,每个节点包括下一个节点的“引用”(也叫指针)

    下边的代码用于实现一个Node类:

    # Node类
    class Node:
        def __init__ (self, data):
            self.data = data
            self.next = None

    各种操作

    class LinkedList:
        def __init__(self):
            self.head = None
            self.tail = None
        
        def is_empty(self):
            return self.head is None
        
        def append(self,data):
            node = Node(data)
            if self.head is None:
                self.head = node
                self.tail = node
            else:
                self.tail.next = node
                self.tail = node
        
        def iter(self):
            if not self.head:
                return
            cur = self.head
            yield cur.data
            while cur.next:
                cur =cur.next
                yield cur.data
                
        def insert(self, idx, value):
            cur = self.head
            cur_idx = 0
            if cur is None:
                raise Exception("The list is an empty")
            while cur_idx < idx - 1:
                cur = cur.next
                if cur is None:
                    raise Exception('......')
                cur_idx = cur_idx + 1
            node = Node(value)
            node.next = cur.next
            cur.next = node
            if node.next is None:
                self.tail = node
                
        def remove(self, idx):
            cur = self.head
            cur_idx = 0
            if self.head is None:  # 空链表时
                raise Exception('The list is an empty list')
            while cur_idx < idx-1:
                cur = cur.next
                if cur is None:
                    raise Exception('list length less than index')
                cur_idx += 1
            if idx == 0:   # 当删除第一个节点时
                self.head = cur.next
                cur = cur.next
                return
            if self.head is self.tail:   # 当只有一个节点的链表时
                self.head = None
                self.tail = None
                return
            cur.next = cur.next.next
            if cur.next is None:  # 当删除的节点是链表最后一个节点时
                self.tail = cur
    
                
        def size(self):
            current = self.head
            count = 0
            if current is None:
                return 'The list is an empty list'
            while current is not None:
                count += 1
                current = current.next
            return count
        
        def search(self, item):
            current = self.head
            found = False
            while current is not None and not found:
                if current.data == item:
                    found = True
                else:
                    current = current.next
            return found

    验证操作

    if __name__ == '__main__':
        link_list = LinkedList()
        for i in range(150):
            link_list.append(i)
        
    
    print(link_list.is_empty())
    
    link_list.insert(10, 30)

     

    展开全文
  • 链表的定义:链表(linked list)是由一组被称为结点的数据元素组成的数据结构,每个结点都包含结点本身的信息和指向下一个结点的地址。由于每个结点都包含了可以链接起来的地址信息,所以用一个变量就能够访问整个...

    链表的定义:

    链表(linked list)是由一组被称为结点的数据元素组成的数据结构,每个结点都包含结点本身的信息和指向下一个结点的地址。由于每个结点都包含了可以链接起来的地址信息,所以用一个变量就能够访问整个结点序列。也就是说,结点包含两部分信息:一部分用于存储数据元素的值,称为信息域;另一部分用于存储下一个数据元素地址的指针,称为指针域。链表中的第一个结点的地址存储在一个单独的结点中,称为头结点或首结点。链表中的最后一个结点没有后继元素,其指针域为空。

    python代码中实现链表的创建、展示链表数据、添加,追加元素、删除元素、统计链表中的元素个数的操作:

    # 链表中的节点

    class Node:

    def __init__(self, data):

    self.data = data

    self.next = None

    # 链表:节点管理类

    class Link:

    def __init__(self):

    # 链表的表头

    self.head = None

    # 展示链表中的数据

    def show(self):

    temp = self.head

    while temp:

    print(temp.data)

    temp = temp.next

    # 在表头添加元素

    def add(self, item):

    # 创建节点

    node = Node(item)

    # 新节点的下一个元素指针指向表头

    node.next = self.head

    # 新的表头设置为当前节点

    self.head = node

    # 在末尾添加元素

    def append(self, item):

    # 创建节点

    node = Node(item)

    # 判断链表是否为空

    if self.head:

    # 找到最后一个元素

    temp = self.head

    while temp.next:

    temp = temp.next

    # 使用最后一个元素的next指向新节点

    temp.next = node

    else:

    self.head = node

    # 统计链表元素个数

    def length(self):

    count = 0

    temp = self.head

    while temp:

    count += 1

    temp = temp.next

    return count

    # 删除元素

    def remove(self, item):

    # 记录要删除元素的前面的元素

    prev = None

    temp = self.head

    while temp:

    if temp.data == item:

    if temp is self.head:

    self.head = temp.next

    else:

    prev.next = temp.next

    break

    else:

    prev = temp

    temp = temp.next

    # 创建链表

    link = Link()

    # 添加元素

    link.add(1)

    link.add(2)

    link.add(3)

    # 追加元素

    link.append(4)

    link.append(5)

    link.append(6)

    # 删除元素

    link.remove(3)

    print(link.length())

    print()

    link.show()

    展开全文
  • 初始化链表"""import timeclass Node:def __init__(self,value):self.value = valueself.next = Noneclass SingleLinkList:def __init__(self):self.head = Nonedef is_empty(self):&qu...

    """

    初始化链表

    """

    import time

    class Node:

    def __init__(self,value):

    self.value = value

    self.next = None

    class SingleLinkList:

    def __init__(self):

    self.head = None

    def is_empty(self):

    """判断是否为空"""

    return self.head == None

    def travel(self):

    """遍历链表"""

    cur = self.head

    while cur is not None:

    print(cur.value,end=" ")

    cur = cur.next

    def append(self,item):

    """在末尾添加节点"""

    node = Node(item)

    # 如果是空链表

    if self.is_empty():

    self.head = node

    return

    # 当不为空的时候

    cur = self.head

    while cur.next:

    cur = cur.next

    cur.next = node

    # node.next = None

    def insert(self,index,item):

    """插入中间节点"""

    if (self.head is None) and (self.head.next is None):

    return

    cur = self.head

    while cur is not None and index > 1:

    index = index - 1

    cur = cur.next

    node = Node(item)

    node.next = cur.next

    cur.next = node

    def add(self,item):

    """在头部添加节点"""

    node = Node(item)

    node.next = self.head

    self.head = node

    def length(self):

    """获取链表的长度"""

    cur = self.head

    count = 0

    while cur is not None:

    count += 1

    cur = cur.next

    return count

    def search(self,item):

    # 查看item在链表中是否存在

    cur = self.head

    while cur != None:

    if cur.value == item:

    return True

    else:

    cur = cur.next

    return False

    def pop_last(self):

    """弹出链表的最后一个元素"""

    if self.head is None:

    return

    cur = self.head

    if cur.next is None:

    self.head = None

    return

    while cur.next.next is not None:

    cur = cur.next

    cur.next = None

    def pop_head(self):

    """把链表的第一个元素弹出"""

    if self.head is None:

    return

    self.head = self.head.next

    def cycle(self):

    """循环输出链表"""

    cur = self.head

    if cur.next == None:

    cur.next = self.head

    while cur.next != None:

    self.travel()

    time.sleep(3)

    if __name__ == "__main__":

    s = SingleLinkList()

    s.append(100)

    s.append(300)

    s.append(600)

    s.add(500)

    s.add(150)

    head = Node(30)

    head.next = Node(40)

    head.next.next = Node(50)

    s.pop_head()

    s.pop_last()

    s.cycle()

    s.travel()

    展开全文
  • Python 链表的基本操作

    2019-06-16 13:31:15
    Python 链表的基本操作 一、链表简介 链表是一种在存储单元上非连续、非顺序的存储结构。数据元素的逻辑顺序是通过链表中的指针链接次序实现。链表是由一系列的结点组成,结点可以在运行时动态生成。每个结点包含两...

    Python 链表的基本操作

    一、链表简介
    链表是一种在存储单元上非连续、非顺序的存储结构。数据元素的逻辑顺序是通过链表中的指针链接次序实现。链表是由一系列的结点组成,结点可以在运行时动态生成。每个结点包含两部分:数据域与指针域。数据域存储数据元素,指针域存储下一结点的指针。

    二、单链表
    单向链表也叫单链表,是链表中最简单的形式,它的每个节点包含两个域,一个信息域(元素域)和一个链接域。这个链接指向链表中的下一个节点,而最后一个节点的链接域则指向一个空值。

    1.定义节点

    // An LinkList node
    class Node(object):
    	def __init__(self,value):
    		self.value = value
    		self.next = None	
    

    2.定义链表

    // 定义单链表和基本操作
    class LinkList(object):
    	// 初始化链表
    	def __init__(self):
    		self.head = None
    	//判断链表是否为空
    	def isempty(self):
    		return self.head == None
    	//链表长度
    	def GetLength(self):
    		length = 0
    		cur = self.head
    		while cur != None:
    			length += 1
    			cur = cur.next
    		return length
    	// 遍历链表
    	def PrintLinkList(self):
    		cur = self.head
    		while cur != None:
    			print(cur.value)
    			cur = cur.next
    	// 从尾部添加节点
    	def AddNodeFromtail(self, value):
    		NewNode = Node(value)
    		if self.isempty():
    			self.head = NewNode
    		else:
    			cur = self.head
    			while cur.next != None:
    				cur = cur.next
    			cur.next = NewNode
    	//从头部添加节点
    	def AddNodeFromhead(self,value):
    		NewNode = Node(value)
    		cur = self.head
    		NewNode.next = cur
    		self.head = NewNode
    	//指定一个位置插入节点
    	def Insert(self, value, index):
    		NewNode = Node(value)
    		if index <= 0:
    			NewNode.next = self.head
    		elif index > self.GetLength():
    			self.AddNodeFromtail(value)
    		else:
    			cur = self.head
    			for i in range(index-1):
    				cur = cur.next
    			NewNode.next = cur.next
    			cur.next = NewNode
    	//删除指定位置的节点:
    	def DeleteNode(self,index):
    		if isempty():
    			print("this linklist is empty")
    		if index < 0 or index >= self.GetLength():
    			print("error: out of inedx")
    		cur = self.head
    		for i in range(index-1):
    			cur = cur.next
    		cur.next = cur.next.next
    
    展开全文
  • 用于辅助学习并理解Python中的链表(Linked List)的使用规则、范例和简单操作等。
  • Python学习】【数据结构】之链表(python变量标识本质、链表操作)链表Python变量标识本质链表操作 链表 一个简单的链表形式如下: 一个节点分为数据区和链接区,数据区存储数据好说,而链接区需要的是存储地址,...
  • python如何对链表操作

    2020-12-16 20:10:42
    链表 链表(linked list)是由一组被称为结点的数据元素组成的数据结构,每个结点都包含结点本身的信息和指向下一个结点的地址。 由于每个结点都包含了可以链接起来的地址信息,所以用一个变量就能够访问整个结点序列...
  • 5. 合并:引入外部变量cur1, cur2用来操作两个链表,每个节点仍然是2次指针操作,但要注意,每节点指针操作结束后,需要将外部操作变量cur下移。最后当cur1遍历结束,即cur1.next为None时,跳出循环,将cur1.next...
  • python链表两数相加

    2020-04-27 11:46:01
    给出两个非空的链表用来表示两个非负的整数。其中,它们各自的位数是按照***倒序***的方式存储的,并且它们的每个节点只能存储一位数字。 如果,我们将这两个数相加起来,则会返回一个新的链表来表示它们的和(新...
  • 下面小编就为大家带来一篇python数据结构之链表的实例讲解。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • class Node: def __init__(self,dataval=None): self.dataval=dataval self.nextval=None class SLinkList: def __init__(self): self.headval=None # 遍历列表 def traversal_slist(self): ...
  • python实现链表的增删改查操作

    千次阅读 2018-12-10 11:03:47
    # _*_ coding:utf-8 _*_ ''' @author:xianyt ... @func:用python实现链表操作 ''' class Node(object): ''' data:节点保存的数据 _next:保存下一个节点对象 ''' def __init__(self, data, pnext=N...
  • 今天是人生第一次写博客,记录自己学习的每一步,有些写...且链表的长度不是固定的,链表数据的这一特点使其可以非常的方便地实现节点的插入和删除操作 什么意思呢,我们在使用python列表的时候,如果我们需要删除列表
  • 链表是计算机科学里面应用最广泛的数据结构之一。这篇文章主要介绍了使用python实现链表操作,需要的朋友可以参考下
  • python实现单链表的基本操作

    万次阅读 多人点赞 2019-06-28 09:42:15
    单向链表(单链表)是链表的一种,其特点是链表的链接方向是单向的,对链表的访问要通过顺序读取从头部开始。单链表是一种链式存取的数据结构,用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以...
  • python3实现链表的基础操作 实现的步骤: 一、建立链表模型 二、遍 历 链 表 三、获取链表长度 四、追 加 节 点 五、插 入 操 作 六、主 调 函 数 分析: (1)建立链表模型: 首先我们节点的概念如图中的单个方块...
  • Python 链表

    万次阅读 多人点赞 2019-06-03 13:29:17
    数据结构是计算机科学必须掌握的一门学问,很多的教材都是用C语言实现链表,因为C有指针,可以很方便的控制内存,很方便就实现...而在Python中,则可以采用“引用+类”来实现链表链表的定义:是一组数据项的集合...
  • python链表所有操作详解

    千次阅读 2019-03-07 23:01:41
    一.插入操作 1.append操作 把一个元素添加到链表的结尾 a=[1,3,5,4,8,7] ...就是合并链表操作 a=[1,3,5,4,8,7] b=[5,6,8] a.extend(b) [1, 3, 5, 4, 8, 7, 9, 9, 5, 6, 8] 3.insert操作 就是元素插入指定位...
  • 单向链表基本操作python实现

    万次阅读 2018-08-11 20:58:44
    一:基本介绍 单向链表也叫单链表,是链表中最简单的一种形式,它... - 链接域next用来存放下一个节点的位置(python中的标识) - 变量p指向链表的头节点(首节点)的位置,从p出发能找到表中的任意节点。 二:...
  • python 单向链表实现快速排序

    千次阅读 多人点赞 2018-11-27 16:23:24
    python 单向链表实现快速排序 快速排序的基本思想: 从序列当中选择一个基准数 在这里我们选择序列当中第一个数作为基准数 将序列当中的所有数依次遍历,比基准数大的位于其右侧,比基准数小的位于其左侧 重复...
  • 链表中删除操作可以通过修改指针来实现,如下图所示: 插入则是调整,插入点的前后两个指针的指向关系,如下图所示: 在python中每个变量都是指针,例如: 用内置数据结构(list,dict,tuple等)的嵌套/组合,...
  • 我的想法:查看或计算出每个链表的长度,然后通过做10n10^n10n运算,还原出这两个十进制数,然后进行相加,再求出结果的各个位后保存起来,进行输出操作。 提示:无需将原来的十进制数还原出来,而是直接在两个...
  • 为什么需要链表? 顺序表的构建需要预先知道数据大小来申请连续的存储空间,而在进行扩充时又需要进行数据的搬迁,所以使用起来不是很灵活? 而链表可以充分利用计算机内存空间,实现灵活的内存动态管理! 链表的...
  • 【摘要】众所周知,python的功能十分强大,那么python链表反转如何实现?这才是python强大功能的一部分,因为链表是编程工具的核心之一,所以掌握python链表反转如何实现?这才是python强大功能的一部分,环球网校的...
  • 链表的排序python(数据结构与算法)

    千次阅读 2020-02-10 15:08:31
    用常数空间复杂度,对链表进行排序,时间复杂度为:O(nlogn) 归并排序法: 思路: 将链表用二分法划分,然会在用双指针法,对划分的链表排序, 由于链表的特殊性,中间位置的寻找,需单独完成,故最终为方便起见...
  • 本文实例讲述了python双向链表原理与实现方法。分享给大家供大家参考,具体如下: 双向链表 一种更复杂的链表是“双向链表”或“双面链表”。每个节点有两个链接:一个指向前一个节点,当此节点为第一个节点时,指向...
  • 相比于单向链表操作更灵活,可进可退,但相应的也会有占用存储空间大,删除操作繁复等缺点。 # 双向链表 class Node(object): def __init__(self, data): self.data = data self.pre = None self.next = ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 36,562
精华内容 14,624
关键字:

python链表操作

python 订阅