链表

最新推荐文章于 2022-07-28 21:07:33 发布

leng_yy

最新推荐文章于 2022-07-28 21:07:33 发布

阅读量393

点赞数 1

本文链接：https://blog.csdn.net/leng_yy/article/details/90116286

版权

链表

1 理论

在这里插入图片描述

链表就像一个节点链，其中每个节点包含着数据和指向后续节点的指针。链表还包含一个头指针，它指向链表的第一个元素，但当列表为空时，它指向null或无具体内容。
链表是物理存储单元上非连续的、非顺序的存储结构，数据元素的逻辑顺序是通过链表的指针地址实现，每个元素包含两个结点，一个是存储元素的数据域 (内存空间)，另一个是指向下一个结点地址的指针域。根据指针的指向，链表能形成不同的结构，例如单链表，双向链表，循环链表等。
链表的优点：
链表是很常用的一种数据结构，不需要初始化容量，可以任意加减元素；
添加或者删除元素时只需要改变前后两个元素结点的指针域指向地址即可，所以添加，删除很快；
缺点：
因为含有大量的指针域，占用空间较大；
查找元素需要遍历链表来查找，非常耗时。
适用场景：
数据量较小，需要频繁增加，删除操作的场景
链表与数组：
链表和数组作为算法中的两个基本数据结构，在程序设计过程中经常用到。尽管两种结构都可以用来存储一系列的数据，但又各有各的特点。
数组的优势，在于可以方便的遍历查找需要的数据。在查询数组指定位置（如查询数组中的第4个数据）的操作中，只需要进行1次操作即可，时间复杂度为O(1)。但是，这种时间上的便利性，是因为数组在内存中占用了连续的空间，在进行类似的查找或者遍历时，本质是指针在内存中的定向偏移。然而，当需要对数组成员进行添加和删除的操作时，数组内完成这类操作的时间复杂度则变成了O(n)。
链表的特性，使其在某些操作上比数组更加高效。例如当进行插入和删除操作时，链表操作的时间复杂度仅为O(1)。另外，因为链表在内存中不是连续存储的，所以可以充分利用内存中的碎片空间。除此之外，链表还是很多算法的基础，最常见的哈希表就是基于链表来实现的。基于以上原因，我们可以看到，链表在程序设计过程中是非常重要的。

参考：https://blog.csdn.net/u012531536/article/details/80170893
参考：https://blog.csdn.net/yeyazhishang/article/details/82353846

2 相关编程

1. 实现单链表、循环链表、双向链表，支持增删操作
参考：https://blog.csdn.net/u013109501/article/details/88033722
单链表

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 != 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("")
 """链表头部添加元素"""
    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 != None:
                cur = cur.next
            cur.next = node
 """指定位置添加元素:param pos 从0开始(即将链表的第一个节点记为0节点)"""
    # pos/position:位置，方位 param:参数
    def insert(self, pos, item):
        # pre/previous以前的，在什么之前
        if pos <= 0:
            self.add(item)
        elif pos > (self.length()-1):
            self.append(item)
        else:
            node = Node(item)
            pre = self.__head
            count = 0
            while count < (pos-1):
                count += 1
                pre = pre.next
            node.next = pre.next
            pre.next = node
  """删除节点"""
    def remove(self, item):
        pre = self.__head
        # 判断是不是空链表
        if pre == None:
            return False
        # 判断是不是头结点，包含了只有一个节点情况
        elif pre.elem == item:
            self.__head = pre.next
            # pre = None
            return True
        else:
            while pre.next != None:
                if pre.next.elem == item:
                    pre.next = pre.next.next
                    return True
                else:
                    pre = pre.next
            return False
  """查找节点是否存在"""
    def search(self, item):
        cur = self.__head
        while cur != None:
            if cur.elem == item:
                return True
            else:
                cur = cur.next
        return False

循环链表

 """定义一个节点"""
class Node(object):
    def __init__(self, elem):
        self.elem = elem
        self.next = None
 
 """单向循环链表"""
class SingleLinkList(object):
    def __init__(self, node=None):
        self.__head = node
        if node != None:
            node.next = node
 """链表是否为空"""
    def is_empty(self):
        return self.__head is None
 """链表的长度"""
    def length(self):
        if self.is_empty():
            return 0
        # cur游标，用来移动遍历节点
        cur = self.__head
        # count记录数量,因为循环不会进入最后一个节点所以初始值为1
        count = 1
        while cur.next != self.__head:
            count += 1
            cur = cur.next
        return count
  """遍历整个链表"""
    def travel(self):
        cur = self.__head
        if cur == None:
            return
        else:
            while cur.next != self.__head:
                print(cur.elem, end=" ")
                cur = cur.next
            # 退出循环后cur指向尾节点，但是尾节点没有打印。
            print(cur.elem)
 """链表头部添加元素"""
    def add(self, item):
        node = Node(item)
        if self.is_empty():
            self.__head = node
            node.next = self.__head
            # 或者
            # 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
        else:
            cur = self.__head
            while cur.next != self.__head:
                cur = cur.next
            # 循环结束cur指向最后一个节点
            cur.next = node
            node.next = self.__head
"""指定位置添加元素:param pos 从0开始(即将链表的第一个节点记为0节点)""" 
    # pos/position:位置，方位 param:参数
    def insert(self, pos, item):
        
        # pre/previous以前的，在什么之前
        if pos <= 0:
            self.add(item)
        elif pos > (self.length()-1):
            self.append(item)
        else:
            node = Node(item)
            pre = self.__head
            count = 0
            while count < (pos-1):
                count += 1
                pre = pre.next
            node.next = pre.next
            pre.next = node
 """删除节点"""
    def remove(self, item):
        pre = self.__head
        cur = self.__head
        # 判断是不是空链表
        if cur == None:
            return False
        # 判断是不是头结点
        elif cur.elem == item:
            # 判断是不是只有一个节点
            if cur.next == self.__head:
                self.__head = None
                return True
            else:
                while pre.next != self.__head:
                    pre = pre.next
                self.__head = cur.next
                pre.next = self.__head
                return True
        else:
            while pre.next != self.__head:
                if pre.next.elem == item:
                    pre.next = pre.next.next
                    return True
                else:
                    pre = pre.next
            return False
 """查找节点是否存在"""
    def search(self, item):
        cur = self.__head
        # 判断是否为空链表
        if self.__head == None:
            return False
        # 判断是不是头结点
        elif cur.elem == item:
            return True
        else:
            while cur.next != self.__head:
                if cur.elem == item:
                    return True
                else:
                    cur = cur.next
            # 循环退出后cur指向最后一个节点，但是没有进入最后一个节点
            if cur.elem == item:
                return True
        return False

双向链表

"""节点"""
class Node(object):
    def __init__(self, item):
       self.elem = item
       self.next = None
       self.prev = None
"""双向链表"""
class DoubleLinkList(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
       # counter:记录数量
       counter = 0
       while cur != None:
           counter += 1
           cur = cur.next
       return counter
"""链表尾部添加节点，尾插法"""
   def append(self, item):
       node = Node(item)
       if self.is_empty():
           self.__head = node
       else:
           cur = self.__head
           while cur.next != None:
               cur = cur.next
           cur.next = node
           node.prev = cur
"""链表头部添加节点，头插法"""
   def add(self, item):
       node = Node(item)
       node.next = self.__head
       self.__head = node
       node.next.prev = node
 """任意位置添加节点"""
   def insert(self, pos, item):
       # pos的初始值为0
       if pos <= 0:
           self.add()
       elif pos > (self.length()-1):
           self.append()
       else:
           cur = self.__head
           counter = 0
           while counter != pos:
               counter += 1
               cur = cur.next
           node = Node(item)
           node.prev = cur.prev
           cur.prev.next = node
           node.next = cur
           cur.prev = node
"""遍历整个链表"""
   def travel(self):
       cur = self.__head
       while cur != None:
           print(cur.elem, end=" ")
           cur = cur.next
       print("")
"""根据元素删除节点"""
   def remove(self, item):
       cur = self.__head
       while cur != None:
           if cur.elem == item:
               # 先判断此结点是否是头节点
               # 头节点
               if cur == self.__head:
                   self.__head = cur.next
                   if cur.next != None:
                   # 链表不只有一个节点
                       cur.next.prev = None
               else:
                   cur.prev.next = cur.next
                   if cur.next != None:
                       cur.next.prev = cur.prev
               return True
           else:
               cur = cur.next
       return False
  """根据元素查找节点是否存在"""
   def search(self, item):
       cur = self.__head
       while cur != None:
           if cur.elem == item:
               return True
           else:
               cur = cur.next
       return False

2. 实现单链表反转
参考：https://blog.csdn.net/u013109501/article/details/88035186

class Node(object):
    def __init__(self, data, next=None):
        self.val = data
        self.next = next
 
def fun4(head):
    if head == None:
        return None
    L,M,R = None,None,head
    while R.next != None:
        L = M
        M = R
        R = R.next
        M.next = L
    R.next = M
    return R

3. 实现两个有序的链表合并为一个有序链表
参考：https://blog.csdn.net/u013109501/article/details/88037008

class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None
 
class Solution:
    def mergeTwoLists(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        if l1 is None and l2 is None:
            return None
        new_list = ListNode(0)
        pre = new_list
        while l1 is not None and l2 is not None:
            if l1.val < l2.val:
                pre.next = l1
                l1 = l1.next
            else:
                pre.next = l2
                l2 = l2.next
            pre = pre.next
        if l1 is not None:
            pre.next = l1
        else:
            pre.next = l2
        return new_list.next

4. 实现求链表的中间结点
参考：https://blog.csdn.net/u013109501/article/details/88037655

class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None
import math
class Solution:
   def middleNode(self, head):
     
       # 首先要知道链表一共有多少个结点
       count = 0
       res = {}
       while head != None:
           count += 1
           res[count] = head
           head = head.next
       #j = math.ceil(count/2)
       #if count % 2 == 0:
       #    return res[j+1]
       #else:
       #    return res[j]
       j = math.ceil((count-1)/2) + 1
       return res[j]

练习

1. Linked List Cycle I（环形链表）

英文版：https://leetcode.com/problems/linked-list-cycle/

中文版：https://leetcode-cn.com/problems/linked-list-cycle/

给定一个链表，判断链表中是否有环。
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。

示例 1：
输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：
输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：
输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

解题思路：

检查一个结点此前是否被访问过来判断链表是否为环形链表，哈希表：地址不唯一就返回true。
遍历所有结点并在哈希表中存储每个结点的引用（或内存地址）。如果当前结点为空结点 null（即已检测到链表尾部的下一个结点），那么我们已经遍历完整个链表，并且该链表不是环形链表。如果当前结点的引用已经存在于哈希表中，那么返回 true（即该链表为环形链表）。

复杂度分析
时间复杂度：O(n)O(n)O(n)，对于含有 nnn 个元素的链表，我们访问每个元素最多一次。添加一个结点到哈希表中只需要花费 O(1)O(1)O(1) 的时间。
空间复杂度：O(n)O(n)O(n)，空间取决于添加到哈希表中的元素数目，最多可以添加 nnn 个元素。

节点检查：检查过的节点被标记为同一个值，下一个节点（未被标记）的值等于该值（要找个奇葩的val，保证和链表中的val都不一样），说明该节点一定在被标记的节点中。也就是有环路。
快慢指针：有环快慢指针必定相遇。(快慢指针，相遇则有环，至于为什么快指针每次走两步？可不可以走三步、四步？数学证明是可以的，但走两步能够更快相遇，更快结束)

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def hasCycle(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        slow = fast = head
        while slow and fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            if slow == fast:
                return True
        return False
    def hasCycle(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        if not head:
            return False
        l = []
        while True:
            if id(head) in l:
                return True
            l.append(id(head))
            head = head.next
            if head is None:
                return False

    def hasCycle(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        save = set()
        cur = head 
        while cur is not None:
            if cur in save:
                return True
            else:
                save.add(cur)
                cur = cur.next
        return False   
    def hasCycle(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        list_id = []
        while head:
            if id(head) in list_id:
                return True
            list_id.append(id(head))
            head = head.next
        return False

2. Merge k Sorted Lists（合并 k 个排序链表）
英文版：https://leetcode.com/problems/merge-k-sorted-lists/

中文版：https://leetcode-cn.com/problems/merge-k-sorted-lists/

合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。

示例:
输入:
[
1->4->5,
1->3->4,
2->6
]
输出: 1->1->2->3->4->4->5->6

解题思路

优先级队列
链表两两合并

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        import heapq
        dummy = ListNode(0)
        p = dummy
        head = []
        for i in range(len(lists)):
            if lists[i] :
                heapq.heappush(head, (lists[i].val, i))
                lists[i] = lists[i].next
        while head:
            val, idx = heapq.heappop(head)
            p.next = ListNode(val)
            p = p.next
            if lists[idx]:
                heapq.heappush(head, (lists[idx].val, idx))
                lists[idx] = lists[idx].next
        return dummy.next


# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        if not lists:return 
        n = len(lists)
        return self.merge(lists, 0, n-1)
    def merge(self,lists, left, right):
        if left == right:
            return lists[left]
        mid = left + (right - left) // 2
        l1 = self.merge(lists, left, mid)
        l2 = self.merge(lists, mid+1, right)
        return self.mergeTwoLists(l1, l2)
    def mergeTwoLists(self,l1, l2):
        if not l1:return l2
        if not l2:return l1
        if l1.val < l2.val:
            l1.next = self.mergeTwoLists(l1.next, l2)
            return l1
        else:
            l2.next = self.mergeTwoLists(l1, l2.next)
            return l2

leng_yy

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
链表

链表1 理论链表就像一个节点链，其中每个节点包含着数据和指向后续节点的指针。链表还包含一个头指针，它指向链表的第一个元素，但当列表为空时，它指向null或无具体内容。链表是物理存储单元上非连续的、非顺序的存储结构，数据元素的逻辑顺序是通过链表的指针地址实现，每个元素包含两个结点，一个是存储元素的数据域 (内存空间)，另一个是指向下一个结点地址的指针域。根据指针的指向，链表能形成不同的结...
复制链接

扫一扫