精华内容
下载资源
问答
  • 链表链表需要多个的节点连接起来每个节点需要保存的为数据,下一个节点的地址,或上一个节点的地址(双向链表)单向链表,有多个节点连接起来,每个链表的起始地址,使用self._head保存,具体是实现代码如下需要一个...

    链表

    链表需要多个的节点连接起来

    每个节点需要保存的为数据,下一个节点的地址,或上一个节点的地址(双向链表)

    单向链表,有多个节点连接起来,

    223

    每个链表的起始地址,使用self._head保存,具体是实现代码如下

    需要一个node类,实现每个节点的信息

    如图

    128

    item 和后继节点位置

    每个链表的基本操作如下:

    is_empty() 判断链表是否为空

    length() 返回链表的长度

    travel() 遍历

    add(item) 在头部添加一个节点

    append(item) 在尾部添加一个节点

    insert(pos, item) 在指定位置pos添加节点

    remove(item) 删除一个节点

    search(item) 查找节点是否存在

    在链表的结构中 __init__()、is_empty()、 length() 的函数代码如图

    286

    遍历、添加到头部和添加到尾部的函数如图:

    678

    在添加节点到头部时,需要把N_node.next指向self._head(原来链表的起始位置),再把链表的起始位置指向新创建的节点;当链表为空时,过程也是如此,就不用再考虑特殊情况了。

    在添加到末尾的位置时,需要考虑节点为空的情况,在添加到末尾的循环条件与遍历的条件不同,在遍历的循环条件为cur != None,在添加的时候

    cur.next != None需要找到最后一个节点,在循环外,把next指向新节点

    插入节点代码如下:

    455

    在插入节点的过程需要考虑插入位置与链表长度的关系,

    在遍历找到插入位置时需要将新节点N_node.next =cur.next 在把cur.next =N_node

    删除及查找的代码如下:

    639

    在删除的函数中需要两个游标来保存删除节点和删除目标节点的前驱节点,并需要判断删除的节点是第一节点,只需要把self._head = cur.next (cur 是第一节点),pre为删除的节点的前一个节点,删除时 pre.next = cur.next 然后退出循环,查找的函数只需要遍历过程中进行一一对比返回即可

    单向循环链表的最后一个节点指向链表的起始位置

    last_node.next = self ._head

    单向循环列表与单向列表的不同点就在最后一个节点,在循环、头节点、尾节点是需要注意条件这里就不多解释了

    双向链表的每个节点包括三个部分,

    前驱节点

    数据区

    后继节点

    如有连续的三个节点

    self. _head node_1 node_2 node_ 3

    三个节点的连接关系如下

    self._head = node_1

    node _1.next = node_2

    node_1.pre = None

    node_2.next=node_3

    node_2.pre=node_1

    node_3.next= None

    node_3.pre =node_2

    双向链表与单向列表相比,在添加,删除时需要注意前驱节点的变化

    注意看截图中的注释

    插入及删除的代码如下:

    371

    457

    展开全文
  • python链表

    万次阅读 2020-08-14 16:07:02
    python链表常用的函数 一个简单地项 class Node: def __init__(self,initdata): self.data = initdata self.next = None def getData(self): return self.data def getNext(self): return self.next ...

     链表的结构是项的集合,其中每个项保持相对于其他项的相对位置。

    python链表常用的函数 

     一个简单地项

    class Node:
        #链表项,必须包含值,和下一个项两个属性,和对应的set get 方法
        def __init__(self,initdata):
            self.data = initdata
            self.next = None
        def getData(self):
            return self.data
        def getNext(self):
            return self.next
        def setData(self,newdata):
            self.data = newdata
        def setNext(self,newnext):
            self.next = newnext
    

    一个链表

    class UnorderedList:
        def __init__(self):
            self.head = None
    
        def isEmpty(self):
            return self.head == None
    
        def add(self,item):
            item1 = Node(item)
            item1.setNext(self.head)
            self.head = item1
    
        def size(self):
            current = self.head
            count = 0
            while current != None:
                count = count + 1
                current = current.getNext()
            return count
    
        def exist(self,item):
            current = self.head
            found = False
            while current != None and not found :
                if current.getData() == item:
                    found = True
                else:
                    current = current.getNext()
            return found
    
        def show_all(self):
            current = self.head
            show_list = []
            while current is not None:
                show_list.append(current.getData())
                current = current.getNext()
            print(show_list)
    
        def delete_item(self,item):
            parent = None
            current = self.head
            found = False
            while current is not None and not found :
                if current.getData() == item:
                    found = True
                else:
                    parent = current
                    current = current.getNext()
            if found:
                if parent is None:
                    parent = self.head
                else:
                    parent.next = current.getNext()
    
    udl = UnorderedList()
    for i in range(10):
        udl.add(i)
    udl.show_all()
    print(udl.exist(11))
    udl.delete_item(7)
    udl.show_all()

    展开全文
  • self.__head = node def is_empty(self): '''链表是否为空,返回头节点是None''' return self.__head == None def length(self): '''链表长度''' # cur游标,用来移动遍历节点 cur = self.__head #游标就是有节点的...

    class Node(object):

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

    self.elem = elem

    self.next = next

    # node1 = Node(20)

    # node2 = Node(10)

    # node1.next = node2 #建立关联 node1.next的属性依然是节点Node类型

    # print('node1.next:',node2.next)

    # print(node1.elem)

    '''

    上面定义了一个节点的类,当然也可以直接使用python的一些结构。比如通过元组(elem, None)

    '''

    # 下面创建单链表,并实现其应有的功能

    class SingleLinkList(object):

    """单链表"""

    def __init__(self, node=None): # 使用一个默认参数,在传入头结点时则接收,在没有传入时,就默认头结点为空

    self.__head = node

    def is_empty(self):

    '''链表是否为空,返回头节点是None'''

    return self.__head == None

    def length(self):

    '''链表长度'''

    # cur游标,用来移动遍历节点

    cur = self.__head #游标就是有节点的属性

    # count记录数量

    count = 0

    while cur != None:

    count += 1

    cur = cur.next

    return count

    def travel(self):

    '''遍历整个列表'''

    cur = self.__head

    while cur != None:

    print(cur.elem, end=' ')

    cur = cur.next

    print("\n")

    def add(self, item):

    '''链表头部添加元素'''

    node = Node(item)

    node.next = self.__head

    self.__head = node

    def append(self, item):

    '''链表尾部添加元素'''

    node = Node(item)

    # 由于特殊情况当链表为空时没有next,所以在前面要做个判断

    if self.is_empty():

    self.__head = node

    else:

    cur = self.__head

    while cur.next != None: #便利到最后一个,吧最后一个的next指向新增的节点

    cur = cur.next

    cur.next = node

    def insert(self, pos, item):

    '''指定位置添加元素'''

    if pos <= 0:

    # 如果pos位置在0或者以前,那么都当做头插法来做

    self.add(item)

    elif pos > self.length() - 1:

    # 如果pos位置比原链表长,那么都当做尾插法来做

    self.append(item)

    else:

    per = self.__head

    count = 0

    while count < pos - 1:

    count += 1

    per = per.next

    # 当循环退出后,pre指向pos-1位置

    node = Node(item)

    node.next = per.next

    per.next = node

    def remove(self, item):

    '''删除节点'''

    cur = self.__head

    pre = None

    while cur != 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 not cur:

    if cur.elem == item:

    return True

    else:

    cur = cur.next

    return False

    if __name__ == "__main__":

    node = Node(100) # 先创建一个节点传进去

    ll = SingleLinkList()

    print("判断列表是否为空:",ll.is_empty())

    print("求列表长度:",ll.length())

    ll.append(3)

    ll.add(999)

    ll.insert(-3, 110)

    ll.insert(99, 111)

    print(ll.is_empty())

    print(ll.length())

    ll.travel()

    ll.remove(111)

    ll.travel()

    展开全文
  • python 链表

    2019-11-03 00:20:24
    链表是由一系列节点组成的元素集合,每个节点包含两部分,数据域item和指向下一个节点的指针next。通过节点之间的相互连接,最终串联成一个链表

    链表是由一系列节点组成的元素集合,每个节点包含两部分,数据域item和指向下一个节点的指针next。通过节点之间的相互连接,最终串联成一个链表

    箭头就是指向

    item 是存的几就是几
    next 这个节点的下一个节点是谁(指向下一个节点)
    在这里插入图片描述

    在这里插入图片描述

    头插发

    在这里插入图片描述

    3要成为新的头
    在这里插入图片描述

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

    在这里插入图片描述

    class Node:
    	def __init__(self,item):
    		self.item = item
    		self.next = None
    
    a = Node(1)
    b = Node(2)
    c = Node(3)
    #怎么把他们链接起来呢 
    a.next = b
    b.next = c 
    
    只需要通过a的节点,就能找到c
    
    
    
    class Node:
        def __init__(self, item):
            #数据域item 头是几
            self.item = item
            #下一个节点指针
            self.next = None
    
    #头结点
    def create_linklist_head(li):
        #头结点
        head = Node(li[0])
        #从1开始,0已经有了
        for element in li[1:]:
            #创建新节点
            node = Node(element)
            #新的节点链接指向
            node.next = head
            #head重新复制指向它
            head = node
        return head
    
    #尾插法
    def create_linklist_tail(li):
    #创建第一个节点
        head = Node(li[0])
        #同时有头和尾都指向它
        tail = head
        for element in li[1:]:
        	#创建新节点
            node = Node(element)
            tail.next = node
            #新的node 称为最后一个
            tail = node
        return head
    
    def print_linklist(lk):
        while lk:
            print(lk.item, end=',')
            lk = lk.next
    
    lk = create_linklist_head([1,2,3,6,8])
    # print(lk.next.item)
    # print(lk.item)
    #lk = create_linklist_tail([1,2,3,6,8])
    print_linklist(lk)
    


    在这里插入图片描述

    在这里插入图片描述

    单向循环链表
    在这里插入图片描述

    如果只有一个结点,node.next指向的是它自己

    长度 
    

    在这里插入图片描述

    append的方法

      就是下面的图片 
      #新结点指向头
      node.next = self.__head
      #原最后一个结点。指向新节点
      cur.next = node
    

    在这里插入图片描述

    #头插法
    在这里插入图片描述

    在这里插入图片描述

    #删除

    在这里插入图片描述

    #单链表链表  从左往右读
    class Node(object):
    	"""双向链表节点"""
    	def __init__(self,item):
    		#数据区
    		self.elem = item
    		#指向后一个节点
    		self.next = None
    #单链表循环
    class LinkList(object):
    	def __init__(self,node=None):
    		#代表头节点
    		self.__head = node
    		#特殊处理回环 如果只有要给结点,node.next指向的是它自己 
    		if node:
    			node.next = node 
    
    	#判断链表是否为空
    	def is_empty(self):
    		return self.__head == None
    
    	def length(self):
    		"""返回链表的长度"""
    		if self.is_empty():
    			return 0 
    
    		else:
    
    			#cur游标移动 count从1开始
    			cur = self.__head
    			#count用来计数
    			count = 1
    			while cur != self.__head:
    				count += 1
    				#让cur游标可以向下移动
    				cur = cur.next
    			return count
    	
    	#遍历整个链表
    	def travel(self):
    		if self.is_empty():
    			return
    		#建立游标等于起始节点
    		else:
    			cur = self.__head
    			while cur.next != self.__head:
    				print(cur.elem,end=" ")
    				cur = cur.next
    			#退出循环,cur指向了尾结点
    			print(cur.elem,end=' ')
    			#换行
    			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 != self.__head:
    				cur = cur.next
    			#退出来就是cur 停留在最后的位置 
    			node.next = self.__head
    			self.__head = node 
    			#最后一个指向新的 形成回环
    			cur.next = node
    	
    
    	def append(self,item):
    		"""链表尾部添加元素"""
    		node = Node(item)  #定义新节点
    		#链表是否为空链表
    		if self.is_empty():
    			#如果为空,新的节点加了进去
    			self.__head = node
    			#处理特殊 为空是第一个结点 node.next =它自己(node)
    			node.next = node 
    		else:
    			#头节点 创建游标
    			cur = self.__head   #设置指向头结点的游标  此时的当前链表第一个节点,就是头节点指向的节点
    			#cur到最后一个节点停下
    			while cur.next != self.__head:
    				cur = cur.next
    			#cur 此时在最后一个位置 
    			#新结点指向头
    			node.next = self.__head
    			#原最后一个结点。指向新节点
    			cur.next = node
    	
    	#插入法  #pos从零开始
    	def insert(self,pos,item):
    		"""在指定位置添加元素"""
    		#指向不是头部元素,self.__head的地址
    		# 为下一个元素,所以pre为下一个元素
    		if pos <= 0:
    			#认为是头插法
    			self.add(item)
    		#假如长度是3 pos大于2要特殊处理  
    		elif pos > (self.length()-1):
    			#尾插法
    			self.append(item)
    		else:
    			cur = self.__head
    			count = 0
    			while count < pos:
    				count+=1
    				cur = cur.next
    			#新节点
    			node = Node(item)
    			#把节点链接到中间任意位置 插入前一个节点
    			node.next = cur
    			node.prev = cur.prev
    			cur.prev.next = node
    			cur.prev = node
    
    	#删除有3个游标
    	def remove(self,item):
    		"""删除元素"""
    		if self.is_empty():
    			return
    
    		else:
    			cur = self.__head
    			pur = None
    			while cur.next != self.__head:
    				#判断cur的数据是否为要删除的数据 
    				if cur.elem == item:
    					
    					#判断此节点是否为头节点
    					#是头节点  现在是删除第一个节点
    					if cur == self.__head:
    						#考虑回环,还需要要给游标拿到尾节点位置 
    						#删除第一个节点
    						#游标 这里直接将rear移动到最后即可 考虑回环 还需要一个游标拿到尾节点位置 还是先等于头
    						rear = self.__head  
    						while rear.next != self.__head:
    							rear = rear.next
    						#退出循环 此时 rear指向最后一个节点了
    						self.__head = cur.next
    						#回环
    						rear.next = self.__head
    						if cur.next != None:
    							#是否只有一个节点
    							cur.next.prev = None
    					else:
    						#其他的节点 
    						pre.next = cur.next
    					return	
    				else:
    					#移动游标 pre 先动  cur后动 
    					pre = cur
    					#cur游标向下移动
    					cur = cur.next
    			#退出循环时候 cur指向最后一个节点    如果当前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
    
    		else:
    			cur = self.__head
    			while cur.next != self.__head:
    				#cur数据是否为查找的数据 item是要查的数据 
    				if cur.elem == item:
    					return True
    				else:
    					cur = cur.next
    			#处理最后一个节点 当前停留的元素
    			if cur.elem == item:
    				return True
    			#遍历完成 
    			return False
    
    if __name__ == '__main__':
    	ll = LinkList()
    	#第一次的
    	print(ll.is_empty())
    	print(ll.length())
    	print("----------------------------------")
    	ll.travel()
    	ll.append(1)
    	print(ll.is_empty())
    	print(ll.length())
    	
    	ll.append(2)	
    	ll.append(3)
    	ll.append(4)
    	ll.append(5)
    	ll.travel()
    	ll.remove(2)
    	ll.travel()
    	ll.remove(4)
    	ll.travel()
    
    

    在这里插入图片描述

    展开全文
  • 单向链表单向链表也叫做单链表,是常见的数据结构链表中最简单的一种形式。它的特点是每个节点包含两个域:数据域域和指针域。节点中指针域指向链表中的下一个节点,而最后一个节点的指针域则指向一个空值。单链表的...
  • 1. 双向链表的定义  每个节点有两个链接:一个指向前一个节点,当此节点为第一个节点时,指向空值;而另一个指向下一个节点,当此节点为最后一个节点时,指向空值。    2. 操作 is_empty() 链表是否为空 ...
  • Python链表全面讲解__小白篇__01 leetcode过程中发现很多题都用的到链表,在这里跟大家share一些我学习过程中对链表所知所学,如果有错误,希望大家***善意指正***。在此谢谢大家,如果非商业转发,请注明出处。...
  • 为什么需要链表? 顺序表的构建需要预先知道数据大小来申请连续的存储空间,而在进行扩充时又需要进行数据的搬迁,所以使用起来不是很灵活? 而链表可以充分利用计算机内存空间,实现灵活的内存动态管理! 链表的...
  • python 链表实现 单链表

    千次阅读 2019-10-03 03:53:09
    1. 链表的定义  链表是一种基础数据结构,是一种线性表,不想顺序表一样连续存储数据,而是在每一个节点(数据存储单元)里存放下一个节点的位置信息(即地址)。  1.1 单链表    表元素域elem用来存放具体...
  • #单链表节点类实现def __init__(self,elem):self.elem=elemself.next=NoneclassSingleLinkList(object):#单链表类实现def __init__(self,node=None):self.__head =nodedefis_empty(self):#判断链表是否为空return ...
  • 我们目前已知,诸如python,这些目前市场上比较高级的语言都不支持指针,但是我们又得用到链表这种结构,因此便有了所谓游标法。 而在没有指针的情况下,对数据空间的分配,无疑成了一个难点,这也正是整个游标法的...
  • 顺序表与链表的优缺点: https://blog.csdn.net/chan0311/article/details/79801473 1.空间开辟 (1)顺序表:一次性开辟连续空间,插入时需要开辟新空间并把原 顺序表拷贝到新空间 (2)链表:每次开辟一个节点,需要时...
  • 链表游标实现

    2017-04-06 19:27:00
    2019独角兽企业重金招聘Python工程师标准>>> ...
  • 如果需要链表而又不能使用指针,这时我们可以使用游标(cursor)实现法来实现链表。 在链表的实现中有两个重要的特点: 数据存储在一组结构体中。每一个结构体包含有数据以及指向下一个结构体的指针。 一个新的...
  • 二、链表 2.1 链表分类 单向链表 也叫单链表 单项循环链表 单链表的一个变形是单向循环链表链表中最后一个节点的next域不再为None,而是指向链表的头节点。 ** 双向链表** 每个节点有两个链接:一个指向前一个...
  • 学习关于python创建双向链表,编写代码以作记录# -*- coding: utf-8 -*-class Node(object):"""节点"""def __init__(self, elem):self.elem = elemself.next = Noneself.prev=Noneclass doubleLinkList(object):'''...
  • 废话不多说,直接贴代码(python 3.6.7):#-*-coding=utf-8-*-class Node(object):"""结点"""def __init__(self,item):self.elem=itemself.next=Noneself.prev=Noneclass DoubleLinkList(object):"""双链表"""def __...
  • 链表的每个节点都有两个指针,一个指向直接后继,一个指向直接前驱。在双向链表的任意一个节点都能很方便的访问其前后节点。其基本结构如下:双向链表结构图1.构造双向循环链表双向链表和单向链表只有在insert、...
  • Python双向链表

    2019-08-11 15:01:03
    Python双向链表 class Node: '''节点''' def __init__(self, elem=None): self.elem = elem self.next = None self.prev = None class DoubleLinkList: '''双向链表''' def __init__...
  • #单向链表中为了在特定位置插入,要先在链表中找到待插入位置和其前一个位置 #双向链表中就不需要两个游标了(当然单向链表中一个游标也是可以只找前一个位置) node =Node(value) count=0 cur= self.__head while ...
  • 003数据结构与算法Python链表为什么需要链表链表的定义单向链表节点实现单链表的操作单链表的实现头部添加元素指定位置添加元素删除节点链表与顺序表的对比单向循环链表操作代码实现双向链表操作代码实现指定位置...
  • python链表

    2021-03-05 00:36:41
    单链表的python实现. 1 #!/usr/bin/env python 2 # -*- coding: utf-8 -*- 3 # @Date : 2018-06-12 11:23:21 4 # @Author : yudanqu (943775910@qq.com) 5 # @Link : https://www.cnblogs.com/yudanqu/ 6 # @...
  • python双向链表

    2020-08-01 20:12:37
    实现双向链表, 仅练习用, 未考虑实际应用部分需要, 函数功能不完善。 """ class Node(object): """节点类""" def __init__(self, elem): self.previous = None self.elem = elem self.next = None class ...
  • python链表、单链表、双向链表、单向循环链表 链表 顺序表的构建需要预先知道数据大小来申请连续的存储空间,而在进行扩充时,又需要进行数据的搬迁,所以使用起来并非很灵活 链表结构可以充分利用计算机内存...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,010
精华内容 804
关键字:

python链表游标

python 订阅