数据结构--链表（单链表、双向单链表、单向循环链表）

最新推荐文章于 2023-03-02 22:02:22 发布
最新推荐文章于 2023-03-02 22:02:22 发布
阅读量1.1k 收藏 9
点赞数
分类专栏： python学习 文章标签： python
原文链接：https://www.cnblogs.com/kumata/p/9147077.html
版权

一、单向链表

单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域 value）和一个链接域(或者称为指针域next)。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。

单向链表图示
在这里插入图片描述
表元素域elem用来存放具体的数据。
链接域next用来存放下一个节点的位置（python中的标识）
变量p指向链表的头节点（首节点）的位置，从p出发能找到表中的任意节点。
链表的基本元素有：
节点：每个节点有两个部分，左边部分称为值域，用来存放用户数据；右边部分称为指针域，用来存放指向下一个元素的指针。
head:head节点永远指向第一个节点
tail: tail永远指向最后一个节点
None:链表中最后一个节点的指针域为None值

节点实现

class SingleNode(object):
    """单链表的结点"""
    def __init__(self,item):
        # _item存放数据元素  数据域(value)
        self.item = item
        # _next是下一个节点的标识
        self.next = None

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

单链表的实现

class SingleLinkList(object):
    """单链表"""
    def __init__(self):
        self._head = None

    def is_empty(self):
        """判断链表是否为空"""
        return self._head == None

    def length(self):
        """链表长度"""
        # cur初始时指向头节点
        cur = self._head
        count = 0
        # 如果初始值设置count = 1 ，那么循环条件就是cur.next != None
        # 尾节点指向None，当未到达尾部时
        while cur != None:
            count += 1
            # 将cur后移一个节点，指向下一个节点
            cur = cur.next    #指针域(next)
        return count

    def travel(self):
        """遍历链表"""
        cur = self._head
        while cur != None:
            print cur.item,
            cur = cur.next
        print ""

头部添加元素
在这里插入图片描述

单链表表头插入元素

   def add(self, item):
        """头部添加元素"""
      #以下情况考虑本身这个单链表是个空，下面的代码也可以覆盖这种情况
        # 先创建一个保存item值的节点
        node = SingleNode(item)
        # 将新节点的链接域next指向头节点，即_head指向的位置
        node.next = self._head
        # 将链表的头_head指向新节点
        self._head = node

尾部添加元素

 def append(self, item):
        """尾部添加元素"""
        node = SingleNode(item)
        # 先判断链表是否为空，若是空链表，则将_head指向新节点
        if self.is_empty():
            self._head = node
        # 若不为空，则找到尾部，将尾节点的next指向新节点
        else:
            cur = self._head
            while cur.next != None:
                cur = cur.next
            cur.next = node

指定位置添加元素
在这里插入图片描述

单链表指定位置添加元素

 def insert(self, pos, item):
        """
        指定位置添加元素
		"""
        # 定义一个指定位置pos，区别于cur
        # 若指定位置pos为第一个元素之前，则执行头部插入
        if pos <= 0:
            self.add(item)
        # 若指定位置超过链表尾部，则执行尾部插入
        elif pos > (self.length()-1):
            self.append(item)
        # 找到指定位置
        else:
            node = SingleNode(item)
            count = 0
            # pre用来指向指定位置pos的前一个位置pos-1，初始从头节点开始移动到指定位置
            pre = self._head
            while count < (pos-1):
                count += 1
                pre = pre.next
            # 先将新节点node的next指向插入位置的节点
            node.next = pre.next
            # 将插入位置的前一个节点的next指向新节点
            pre.next = node

删除节点
在这里插入图片描述

单链表删除节点

 def remove(self,item):
        """删除节点"""
        cur = self._head
        pre = None
        while cur != None:
            # 找到了指定元素
            if cur.item == item:
                # 如果第一个就是删除的节点
                if not pre:    #if cur == self._head   也是可以判断出是否是头结点
                    # 将头指针指向头节点的后一个节点（这种情况也包含了如果链表中只有一个节点的情况）
                    self._head = cur.next
                else:
                    # 将删除位置前一个节点的next指向删除位置的后一个节点，也可以包含了删除最后一个节点的情况
                    pre.next = cur.next
                break  #删除后退出循环
            else:
                # 继续按链表后移节点
                pre = cur
                cur = cur.next

查找节点是否存在

 def search(self,item):
        """链表查找节点是否存在，并返回True或者False"""
        cur = self._head
        while cur != None:
            if cur.item == item:
                return True
            cur = cur.next
        return False

测试

if __name__ == "__main__":
    ll = SingleLinkList()
    ll.add(1)
    ll.add(2)
    ll.append(3)
    ll.insert(2, 4)
    print "length:",ll.length()
    ll.travel()
    print ll.search(3)
    print ll.search(5)
    ll.remove(1)
    print "length:",ll.length()
    ll.travel()

# 节点实现的另一种定义方式，大同小异，方便理解

class Node():                  #value + next
    def __init__ (self, value = None, next = None):
        self._value = value
        self._next = next

    def getValue(self):
        return self._value

    def getNext(self):
        return self._next

    def setValue(self,new_value):
        self._value = new_value

    def setNext(self,new_next):
        self._next = new_next

另一种单链表实现的代码，可以接着上面对比，更方便理解

"""
节点：每个节点有两个部分，左边部分称为值域，用来存放用户数据；右边部分称为指针域，用来存放指向下一个元素的指针。
head:head节点永远指向第一个节点
tail: tail永远指向最后一个节点
None:链表中最后一个节点的指针域为None值
"""
#实现Linked List及其各类操作方法
class LinkedList():
    def __init__(self):      #初始化链表为空表
        self._head = Node() 
        self._tail = None
        self._length = 0

    #检测是否为空
    def isEmpty(self):
        return self._head == None  

    #add在链表前端添加元素:O(1)
    def add(self,value):
        newnode = Node(value,None)    #create一个node（为了插进一个链表）
        newnode.setNext(self._head)   
        self._head = newnode

    #append在链表尾部添加元素:O(n)
    def append(self,value):
        newnode = Node(value)
        if self.isEmpty():
            self._head = newnode   #若为空表，将添加的元素设为第一个元素
        else:
            current = self._head
            while current.getNext() != None:
                current = current.getNext()   #遍历链表
            current.setNext(newnode)   #此时current为链表最后的元素

    #search检索元素是否在链表中    
    def search(self,value):
        current=self._head
        foundvalue = False
        while current != None and not foundvalue:
            if current.getValue() == value:
                foundvalue = True
            else:
                current=current.getNext()
        return foundvalue

    #index索引元素在链表中的位置
    def index(self,value):
        current = self._head
        count = 0
        found = None
        while current != None and not found:
            count += 1
            if current.getValue()==value:
                found = True
            else:
                current=current.getNext()
        if found:
            return count
        else:
            raise ValueError ('%s is not in linkedlist'%value)

    #remove删除链表中的某项元素
    def remove(self,value):
        current = self._head
        pre = None
        while current!=None:
            if current.getValue() == value:
                if not pre:
                    self._head = current.getNext()
                else:
                    pre.setNext(current.getNext())
                break
            else:
                pre = current
                current = current.getNext()

    #insert链表中插入元素
    def insert(self,pos,value):
        if pos <= 1:
            self.add(value)
        elif pos > self.size():
            self.append(value)
        else:
            temp = Node(value)
            count = 1
            pre = None
            current = self._head
            while count < pos:
                count += 1
                pre = current
                current = current.getNext()
            pre.setNext(temp)
            temp.setNext(current)

链表与顺序表的对比
链表失去了顺序表随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大，但对存储空间的使用要相对灵活。

链表与顺序表的各种操作复杂度如下所示：

操作链表顺序表
访问元素O(n)O(1)
在头部插入/删除O(1)O(n)
在尾部插入/删除O(n)O(1)
在中间插入/删除O(n)O(n)

注意虽然表面看起来复杂度都是 O(n)，但是链表和顺序表在插入和删除时进行的是完全不同的操作。链表的主要耗时操作是遍历查找，删除和插入操作本身的复杂度是O(1)。顺序表查找很快，主要耗时的操作是拷贝覆盖。因为除了目标元素在尾部的特殊情况，顺序表进行插入和删除时需要对操作点之后的所有元素进行前后移位操作，只能通过拷贝和覆盖的方法进行。

二、双向链表

一种更复杂的链表是“双向链表”或“双面链表”。每个节点有两个链接：一个指向前一个节点（后继结点），当此节点为第一个节点时，指向空值；而另一个指向下一个节点（前驱结点），当此节点为最后一个节点时，指向空值。

双向链表
在这里插入图片描述

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

实现

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


class DLinkList(object):
    """双向链表"""
    def __init__(self):
        self._head = None

    def is_empty(self):
        """判断链表是否为空"""
        return self._head == None

    def length(self):
        """返回链表的长度"""
        cur = self._head
        count = 0
        while cur != None:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        """遍历链表"""
        cur = self._head
        while cur != None:
            print cur.item,
            cur = cur.next
        print ""

    def add(self, item):
        """头部插入元素"""
        node = Node(item)
        if self.is_empty():
            # 如果是空链表，将_head指向node
            self._head = node
        else:
            # 将node的next指向_head的头节点
            node.next = self._head
            #  将head指向node--->self._head  = node    再将node的P区指向node--->node.next.prev = node
            #换个顺序，将_head的头节点的prev指向node    
            self._head.prev = node  #先将原有的第一个结点的“P区”指向node
            # 再将_head 指向node
            self._head = node  

    def append(self, item):
        """尾部插入元素"""
        node = Node(item)
        if self.is_empty():
            # 如果是空链表，将_head指向node
            self._head = node
        else:
            # 移动到链表尾部
            cur = self._head
            while cur.next != None:
                cur = cur.next
            # 将尾节点cur的next指向node
            cur.next = node
            # 将node的prev指向cur
            node.prev = cur



    def search(self, item):
        """查找元素是否存在"""
        cur = self._head
        while cur != None:
            if cur.item == item:
                return True
            cur = cur.next
        return False

在这里插入图片描述

指定位置插入节点

 def insert(self, pos, item):
        """在指定位置添加节点"""
        if pos <= 0:
            self.add(item)
        elif pos > (self.length()-1):
            self.append(item)
        else:
            node = Node(item)
            cur = self._head
            count = 0
       
            # 移动到指定位置的前一个位置
            while count < (pos-1):
                count += 1
                cur = cur.next
            # 将node的prev指向当前游标cur的结点
            node.prev = cur
            # 将node的next指向cur的下一个节点
            node.next = cur.next
            # 将cur的下一个节点的prev指向node
            cur.next.prev = node
            # 将cur的next指向node
            cur.next = node

循环的部分可以有很多种解题思路：

     # 移动到指定位置            
     #首先将新节点node的前驱与后区部分指向指定的位置（准备插入的位置pos，两个结点之间）
     		while count < pos:
                count += 1
                cur = cur.next
            # 将node的prev指向当前游标cur的上一个结点
            node.prev = cur.prev
            # 将node的next指向cur当前节点
            node.next = cur


         #第一种方式，先将当前cur结点指向的上一个结点的next区指向node，再将cur结点的prev指向node
            # 将cur的上一个节点的next指向node
            cur.prev.next = node
            # 将cur的next指向node
            cur.prev = node
            
         #第二种方式，先将cur结点的prev指向node,再将node.prev指向的cur上一个结点（在原顺序中）的next，指向node
            # 将cur的上一个节点的next指向node
            cur.prev = node
            # 将node.prev的next指向node
            node.prev.next = node

删除元素

def remove(self, item):
        """删除元素"""
        if self.is_empty():
            return
        else:
            cur = self._head
            if cur.item == item:
                # 如果首节点的元素即是要删除的元素
                if cur.next == None:
                    # 如果链表只有这一个节点
                    self._head = None
                else:
                    # 将第二个节点的prev设置为None
                    cur.next.prev = None
                    # 将_head指向第二个节点
                    self._head = cur.next
                return
            while cur != None:
                if cur.item == item:
                    # 将cur的前一个节点的next指向cur的后一个节点
                    cur.prev.next = cur.next
                    # 将cur的后一个节点的prev指向cur的前一个节点
                    cur.next.prev = cur.prev
                    break
                cur = cur.next

"""
删除结点的第二种思路
"""
 def remove(self,item):
 	cur = self.__head
 	while cur != None:
 		
 		if cur.elem == item:
 		# 判断是否是头结点
 			if cur == self.__head:
 				self.__head == cur.next
 				#判断是否只有这一个结点.cur.next为空（false）就是没有下一个节点
 				if cur.next:
 					cur.next.prev = None
 			#不是头结点
 			else:
 				cur.next.prev = cur.next
 				# 判断是否是最后一个节点
 				if cur.next:
 					cur.next.prev = cur.prev
 			break
 		else:
 		pre = cur
 		cur = cur.next

测试

if __name__ == "__main__":
    ll = DLinkList()
    ll.add(1)
    ll.add(2)
    ll.append(3)
    ll.insert(2, 4)
    ll.insert(4, 5)
    ll.insert(0, 6)
    print "length:",ll.length()
    ll.travel()
    print ll.search(3)
    print ll.search(4)
    ll.remove(1)
    print "length:",ll.length()
    ll.travel()

单向循环链表

单链表的一个变形是单向循环链表，链表中最后一个节点的next域不再为None，而是指向链表的头节点。

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

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

class Node(object):
    """节点"""
    def __init__(self, item):
        self.item = item
        self.next = None


class SinCycLinkedlist(object):
    """单向循环链表"""
    def __init__(self):
        self._head = None

    def is_empty(self):
        """判断链表是否为空"""
        return self._head == None

    def length(self):
        """返回链表的长度"""
        # 如果链表为空，返回长度0
        if self.is_empty():
            return 0
        count = 1 #此处的初始化值要注意，为什么不是0呢？ 因为循环条件，最后一次进入不到循环体内了。
        cur = self._head
        while cur.next != self._head:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        """遍历链表"""
        if self.is_empty():
        	# 如果为空，返回的是false
            return
        cur = self._head
        print (cur.item,)
        while cur.next != self._head:
            cur = cur.next
            print (cur.item,)
        print ""


    def add(self, item):
        """头部添加节点"""
        node = Node(item)
        if self.is_empty():
            self._head = node
            node.next = self._head
        else:
            #添加的节点指向_head
            node.next = self._head
            # 移到链表尾部，将尾部节点的next指向node
            cur = self._head
            
            while cur.next != self._head:
                cur = cur.next
            cur.next = node
            #_head指向添加node的
            self._head = node

    def append(self, item):
        """尾部添加节点"""
        node = Node(item)
        if self.is_empty():
            self._head = node
            node.next = self._head
        else:
            # 移到链表尾部
            cur = self._head
            while cur.next != self._head:
                cur = cur.next
            # 将尾节点指向node
            cur.next = node
            # 将node指向头节点_head
            node.next = self._head

    def insert(self, pos, item):
        """在指定位置添加节点"""
        if pos <= 0:
            self.add(item)
        elif pos > (self.length()-1):
            self.append(item)
        else:
            node = Node(item)
            cur = self._head
            count = 0
            # 移动到指定位置的前一个位置
            while count < (pos-1):
                count += 1
                cur = cur.next
            node.next = cur.next
            cur.next = node

    def remove(self, item):
        """删除一个节点"""
        # 若链表为空，则直接返回
        if self.is_empty():
            return
        # 将cur指向头节点
        cur = self._head
        pre = None
        # 若头节点的元素就是要查找的元素item
        if cur.item == item:
            # 如果链表不止一个节点
            if cur.next != self._head:
                # 先找到尾节点，将尾节点的next指向第二个节点
                while cur.next != self._head:
                    cur = cur.next
                # cur指向了尾节点
                cur.next = self._head.next
                self._head = self._head.next
            else:
                # 链表只有一个节点
                self._head = None
        else:
            pre = self._head
            # 第一个节点不是要删除的
            while cur.next != self._head:
                # 找到了要删除的元素
                if cur.item == item:
                    # 删除
                    pre.next = cur.next
                    return
                else:
                    pre = cur
                    cur = cur.next
            # cur 指向尾节点
            if cur.item == item:
                # 尾部删除
                pre.next = cur.next

    def search(self, item):
        """查找节点是否存在"""
        if self.is_empty():
            return False
        cur = self._head
        if cur.item == item:
            return True
        while cur.next != self._head:
            cur = cur.next
            if cur.item == item:
                return True
        return False

if __name__ == "__main__":
    ll = SinCycLinkedlist()
    ll.add(1)
    ll.add(2)
    ll.append(3)
    ll.insert(2, 4)
    ll.insert(4, 5)
    ll.insert(0, 6)
    print ("length:",ll.length())  #print ("length:%d"%(ll.length()))
     ll.travel()
    print ll.search(3)
    print ll.search(7)
    ll.remove(1)
    print "length:",ll.length()
    ll.travel()
北冥有鱼喵喵
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第二章——单链表和循环单链表
weixin_55835175的博客
09-17 2784
线性表——链表 顺序表需要事先占用一整块实现分配大小的存储空间，但是对于某些问题：很多空间只使用一次(甚至根本用不到)，使用顺序表存储空间的利用率往往很低。于是需要一种能够动态管理存储空间的存储结构——链表。 线性表的链式存储结构——链表 线性表的链式存储结构我们简称为链表。其中每个存储结点不仅包含元素本身的信息(称为数据域)，而且包含表示元素之间逻辑关系的信息，在C和C++中用指针实现，称为指针域。 一种最常见，最基本的方法是在每个结点除包有数据域以外只设置一个指针域，用于指向其后继结点，这样构成的链表
链表和单链表
weixin_62728271的博客
01-13 667
一、链表的定义 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是不像顺序表一样连续存储数据，而是在每一个节点（数据存储单元）里存放下一个节点的位置信息（即地址）。 二、单向链表 1、定义：单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。 2、节点实现 class SingleNode(object): """单链表的结点""" ..
单向链表、单向循环链表
松鼠豪的坚果
09-19 510
目录 1 单向链表结构分析 2 节点实现 3 单链表的操作 4 单链表的实现 4.1 头部添加元素 4.2尾部添加元素 4.3 指定位置添加元素 4.4 删除节点 4.5 查找节点是否存在 4.6 测试 5 链表与顺序表的对比 6 单向循环链表 1 单向链表结构分析 单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个...
单链表、双向链表、循环链表
hyt1152860391的博客
07-26 7396
常见链表 学习三种常见的链表结构，他们分别是：单链表、双向链表和循环链表。 单链表 单链表有两个较特殊节点，头结点和尾节点。头结点用来记录链表的基地址，可以用来遍历整条链表。尾结点的指针不是指向下一个节点而是指向一个空地址NULL，表示链表上的最后一个节点。 和数组一样，链表也支持数据的查找、插入和删除操作。但相对于数据的插入删除需要做大量的搬移操作，链表的插入，删除的时间复杂度为O(1)。但是链...
一步一步写算法（之单向链表）
热门推荐
嵌入式-老费，一个分享专业嵌入式知识的blog
10-07 11万+
【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】     有的时候，处于内存中的数据并不是连续的。那么这时候，我们就需要在数据结构中添加一个属性，这个属性会记录下面一个数据的地址。有了这个地址之后，所有的数据就像一
数据结构--数组、单链表和双链表介绍以及双向链表 数组和链表.pdf
04-18
数据结构--数组、单链表和双链表介绍以及双向链表 数据结构是计算机科学中的一种基本概念，指的是数据的组织和存储方式。数组、链表是两种常见的数据结构，下面将对它们进行介绍。 一、数组 数组是数据结构中的一...
list-2_单链表_speakgfp_数据结构_循环链表_
10-02
在本项目中，我们将探讨三种不同的链表类型：单链表、单向循环链表和双向循环链表。下面将详细阐述这些链表的实现和它们的特性。 首先，单链表是一种线性数据结构，每个节点包含两个部分：数据元素和指向下一个节点...
算法-数据结构和算法-8-双向链表.rar
09-16
- 双向循环链表：在双向链表的基础上，首尾节点形成环状，常用于实现循环队列和某些特定的搜索算法。 - 双向链表和栈的结合：在实现某些算法，如LRU缓存淘汰策略时，会用到栈和双向链表的组合。 6. **数据结构的...
数据结构顺序表和链表（超详细）
最新发布
08-14
此压缩包为1、无头+单向+非循环链表增删查改实现// 动态申请一个结点// 单链表打印// 单链表尾插// 单链表的头插// 单链表的尾删// 单链表头删// 单链表查找// 单链表在pos位置之后插入x// 单链表删除pos位置之后的...
航班订票系统（单向，双向循环链表）
03-26
总结，这个航班订票系统利用了数据结构的优势，以单向链表管理航班，以双向循环链表管理乘客，实现了高效的数据存储和操作。通过合理的设计和实现，该系统能够满足用户的基本需求，为实际的航班预订提供便利。
单向链表
maxchenBug的博客
09-18 253
package com.cxy.springdataredis.data; import ch.qos.logback.core.net.SyslogOutputStream; import sun.reflect.generics.reflectiveObjects.LazyReflectiveObjectGenerator; import java.util.Sta...
（python数据结构2）单链表与单向循环链表
淋巴cell学习py之路
06-26 340
1.单链表 """ 单链表的时间复杂度不会变，分散的空间可以利用，但是占用空间大 顺序表的空间必须是连续的 """ class Node(object): def __init__(self,elem): self.elem = elem self.next = None class SingleLinkList(object): def __...
单链表和双链表
doubi7的博客
07-27 985
链表：动态分配内存，内存不连续，定位元素时间复杂度O（N)，插入或删除的时间复杂度O（1）。 优点： （1）插入或删除的速度快 （2）内存利用效率高，不浪费内存（可以不要求空间连续，而且在需要时才创建） （3)动态拓展，不固定长度 缺点： (1):查找的效率低 数组：静态分配内存，内存连续，可以利用下标定位元素，时间复杂度O（1），插入删除元素，时间复杂度O（n）。 优点： （1...
【面试题精选】两数相加
weixin_43958974的博客
09-25 173
题目：两数相加 思路： 设置一个哨兵节点dummy和增长节点cur 定义一些辅助变量x,y,flag,sum x表示链表L1当前节点的值，空节点为0； y表示链表L2当前节点的值，空节点为0； sum表示x+y的和； flag表示sum/10,即向十位的溢出值 while循环，只要链表L1和链表L2不同时为空，就对L1和L2所指的当前节点作如下处理： 计算sum = x + y + flag; 计算flag = sum / 10; 用sum % 10的值在cur后面创建一个新节点； 循环结束
链表—单向链表
weixin_38477351的博客
03-07 415
单向链表
【数据结构-C语言】单向链表，循环单向链表
sakura0908的博客
03-02 2423
顺序表：顺序存储的线性表 链式表：链式存储的线性表，简称链表 由于顺序表的缺点（数据连续存储），顺序存储的数据因为挤在一起而导致需要成片移动，那很容易想到的解决方案是将数据离散地存储在不同内存块中，然后再用指针将他们串起来，这种朴素的思路所形成的链式线性表，就是所谓的链表。顺序表和链表存在的基本样态如下图所示
数据结构（四）——单链表 、带头结点的单链表、循环链表 及其实现
阿修罗道
09-19 2万+
一、 链式存储       以结点的形式存储数据。除了存放一个结点的信息外，还需附设指针。                   数据在内存中存储是不连续的，每个结点只能也只有它能知道下一个结点的存储位置。     二、单链表   单链表是线性表链式
单链表c语言实现,单向链表 c语言实现
weixin_36125445的博客
05-19 291
定义(引用百度百科)单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。场景在实际生产中，有可能在软件启动后，对一些数据进行多态扩容，比如，网卡收发包的时候，从协议栈上产生一个需求的包，需要暂时排队，等网卡把...
C#数据结构：链表改进与双向链表解析
本资源探讨了两种常见的链表改进方案：双向链表和循环链表，并提到了面向对象实现中的LinkedList类的迭代器改进。 11.4.1 双向链表 双向链表是对单向链表的一种扩展，它增加了反向遍历和节点删除的便捷性。在双向...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值