力扣刷题笔记 链表及其相关题目（含ACM模式）

最新推荐文章于 2024-08-18 18:53:46 发布
最新推荐文章于 2024-08-18 18:53:46 发布
阅读量356 收藏 3
点赞数
文章标签： leetcode 笔记 链表 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/sangedianhao/article/details/134169434
版权

《代码随想录》学习笔记，原链接：https://programmercarl.com/

链表理论基础

（1）链表的定义

（2）链表的操作

203.移除链表元素

707.设计链表

 206.反转链表

24.两两交换链表中的节点

19.删除链表的倒数第N个节点

面试题 02.07.链表相交

142.环形链表II

链表理论基础

（1）链表的定义

链表是一种通过指针串联在一起的线性结构，每个节点由两部分组成：数据域和指针域。链表在内存中不是连续分布，而是通过指针连接各个节点。

链表包括单链表、双链表和循环链表：

  • 单链表：每个节点包括一个数据域val和一个指针域next，节点的定义如下：
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val    # 数据域
        self.next = next    # 指针域

【注】由于在Python中不存在null和NULL，所以最后一个节点的指针域指向为None。

  • 双链表：既可以向前，也可以向后查询，即有两个指针域。

  • 循环链表：首尾相连。

（2）链表的操作

  • 删除节点

  • 添加节点

203.移除链表元素

 为了保证删除head节点和删除其他节点时的操作完全相同，因此设置一个虚拟头节点。如下所示，是在这个链表中，移除元素1。

  • 核心代码模式
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        dummyHead = ListNode(None, head)  # 构建虚拟头结点，初始化为next = head指向第一个节点
        current = dummyHead # 设定当前访问的节点current

        while current.next: # 遍历整个列表，不能使用current
            if current.next.val == val: # 找到要删除的节点，此时current指向该节点的前一个位置
                current.next = current.next.next
            else:   # 这里必须使用else判断，不能直接将current后移一位
                current = current.next  # 访问下一个节点

        return dummyHead.next # 返回删除后的列表，由于head可能已经被删除，因此不能直接返回head

【注】python中使用None来表示空（空 ≠ 0个值），没有null或NULL这个关键字。

  • ACM模式
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
class Solution:
    def removeElements(self, head, val):
        dummyHead = ListNode(None, head)  # 构建虚拟头结点，初始化为next = head指向第一个节点
        current = dummyHead # 设定当前访问的节点current

        while current.next: # 遍历整个列表，不能使用current。python中使用None来表示空（空 ≠ 0个值），没有null或NULL这个关键字
            if current.next.val == val: # 找到要删除的节点，此时current指向该节点的前一个位置
                current.next = current.next.next
            else:   # 这里必须使用else判断，不能直接将current后移一位
                current = current.next  # 访问下一个节点

        return dummyHead.next # 返回删除后的列表，由于head可能已经被删除，因此不能直接返回head

# 创建链表
def creat_list(lenth):
    head = ListNode(None)
    current = head
    for i in range(lenth):
        val = int(input(f"输入第 {i + 1} 个节点的值: "))
        current.next = ListNode(val)
        current = current.next

    # 删除头节点
    head = head.next

    return head

# 输入链表长度lenth
lenth = int(input("输入链表的长度："))
# 输入要删除的值val
val = int(input("输入要删除的值val："))

# 移除链表元素
head = creat_list(lenth)
solution = Solution()
result = solution.removeElements(head, val)

# 输出删除后的元素
result_list = []
while result:
    result_list.append(result.val)
    result = result.next
print(result_list)

707.设计链表

  • 核心代码模式
# 创建单链表
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

class MyLinkedList:

    # 初始化创建一个虚拟头结点
    # def creat_list(lenth):
    #     head = ListNode(None)
    #     current = head
    #     for i in range(lenth):
    #         val = int(input(f"输入第 {i + 1} 个节点的值: "))
    #         current.next = ListNode(val)
    #         current = current.next
    
    #     # 删除头节点
    #     head = head.next
    #     return head
    
    def __init__(self): 
        self.dummy_head = ListNode(None)    # self将dummy_head和lenth变成在整个类的任意位置都可以调用的变量
        self.lenth = 0

    # 链表中下标为 index 的节点的值
    def get(self, index: int) -> int:
        if index < 0 or index >= self.lenth:    # 判断要查询的节点下标，是否超出链表范围
            return -1

        current = self.dummy_head    # 初始化当前节点的位置为dummy_head，注意要加self
        for i in range(0, index):
            current = current.next  # 找到要获取的节点的前一个节点

        return current.next.val     # 获取index节点的值

    # 将一个值为 val 的节点插入到链表中第一个元素之前
    def addAtHead(self, val: int) -> None:
        new_head = ListNode(val, None)  # 新建一个值为val的节点

        new_head.next = self.dummy_head.next # 将新建的节点添加到列表中，注意要加self
        self.dummy_head.next = new_head

        self.lenth += 1 # 链表长度+1

    # 将一个值为 val 的节点追加到链表中作为链表的最后一个元素
    def addAtTail(self, val: int) -> None:
        new_tail = ListNode(val, None)  # 新建一个值为val的节点

        current = self.dummy_head  # 初始化当前节点的位置为dummy_head，注意要加self
        while current.next:
            current = current.next
        current.next = new_tail # 将新建的节点加到最后一个节点的后面

        self.lenth += 1 # 链表长度+1

    # 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。
    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0 or index > self.lenth: # 此处不能是index >= self.lenth
            return
        
        new_node = ListNode(val, None)  # 新建一个值为val的节点
        current = self.dummy_head   # 初始化当前节点的位置为dummy_head，注意要加self

        for i in range(index):
            current = current.next  # 找到要index节点的前一个节点
        new_node.next = current.next
        current.next = new_node

        self.lenth += 1 # 链表长度+1

    # 如果下标有效，则删除链表中下标为 index 的节点
    def deleteAtIndex(self, index: int) -> None:
        if index < 0 or index >= self.lenth:    # 判断要删除的节点下标，是否超出链表范围
            return 
        
        current = self.dummy_head   # 初始化当前节点的位置为dummy_head，注意要加self
        
        for i in range(index):
            current = current.next  # 找到要删除的index节点的前一个节点
        current.next = current.next.next    # 删除节点
        self.lenth -= 1


# Your MyLinkedList object will be instantiated and called as such:
# obj = MyLinkedList()
# param_1 = obj.get(index)
# obj.addAtHead(val)
# obj.addAtTail(val)
# obj.addAtIndex(index,val)
# obj.deleteAtIndex(index)
  • ACM模式
# 创建单链表节点
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next


class MyLinkedList:

    # 初始化创建一个虚拟头结点
    # def creat_list(lenth):
    #     head = ListNode(None)
    #     current = head
    #     for i in range(lenth):
    #         val = int(input(f"输入第 {i + 1} 个节点的值: "))
    #         current.next = ListNode(val)
    #         current = current.next

    #     # 删除头节点
    #     head = head.next
    #     return head

    def __init__(self):
        self.dummy_head = ListNode(None)  # self将dummy_head和lenth变成在整个类的任意位置都可以调用的变量
        self.lenth = 0

    # 链表中下标为 index 的节点的值
    def get(self, index: int) -> int:
        if index < 0 or index >= self.lenth:  # 判断要查询的节点下标，是否超出链表范围
            return -1

        current = self.dummy_head  # 初始化当前节点的位置为dummy_head，注意要加self
        for i in range(0, index):
            current = current.next  # 找到要获取的节点的前一个节点

        return current.next.val  # 获取index节点的值

    # 将一个值为 val 的节点插入到链表中第一个元素之前
    def addAtHead(self, val: int) -> None:
        new_head = ListNode(val, None)  # 新建一个值为val的节点

        new_head.next = self.dummy_head.next  # 将新建的节点添加到列表中，注意要加self
        self.dummy_head.next = new_head

        self.lenth += 1  # 链表长度+1

    # 将一个值为 val 的节点追加到链表中作为链表的最后一个元素
    def addAtTail(self, val: int) -> None:
        new_tail = ListNode(val, None)  # 新建一个值为val的节点

        current = self.dummy_head  # 初始化当前节点的位置为dummy_head，注意要加self
        while current.next:
            current = current.next
        current.next = new_tail  # 将新建的节点加到最后一个节点的后面

        self.lenth += 1  # 链表长度+1

    # 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。
    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0 or index > self.lenth:  # 此处不能是index >= self.lenth
            return

        new_node = ListNode(val, None)  # 新建一个值为val的节点
        current = self.dummy_head  # 初始化当前节点的位置为dummy_head，注意要加self

        for i in range(index):
            current = current.next  # 找到要index节点的前一个节点
        new_node.next = current.next
        current.next = new_node

        self.lenth += 1  # 链表长度+1

    # 如果下标有效，则删除链表中下标为 index 的节点
    def deleteAtIndex(self, index: int) -> None:
        if index < 0 or index >= self.lenth:  # 判断要删除的节点下标，是否超出链表范围
            return

        current = self.dummy_head  # 初始化当前节点的位置为dummy_head，注意要加self

        for i in range(index):
            current = current.next  # 找到要删除的index节点的前一个节点
        current.next = current.next.next  # 删除节点
        self.lenth -= 1

# 获取要进行的操作，以及对应的输入参数列表
def param_input():
    functions = []
    params = []

    # 输入要调用的函数列表
    while True:
        function_name = input("输入函数字符串（按Enter结束输入）：")
        if function_name == "": # 按Enter结束整个列表的输入
            break
        functions.append(function_name)

    # 输入函数对应的输入参数
    while True:
        param_name = input("请输入一行元素（用逗号隔开，按Enter结束输入）：")
        if param_name == "":
            break
        param_name = [int(x) for x in param_name.split(',')]
        params.append(param_name)

    return functions, params

# 构建链表对象
solution = MyLinkedList()
# 获取要进行的操作列表
functions, params = param_input()
# 设计链表
for i in range(len(functions)):
    if functions[i] == "get":
        result = solution.get(params[i][0])
        print(result)
    elif functions[i] == "addAtHead":
        result = solution.addAtHead(params[i][0])
        print(result)
    elif functions[i] == "addAtTail":
        result = solution.addAtTail(params[i][0])
        print(result)
    elif functions[i] == "addAtIndex":
        result = solution.addAtIndex(params[i][0], params[i][1])
        print(result)
    else:
        result = solution.deleteAtIndex(params[i][0])
        print(result)

 206.反转链表

  • 核心代码模式
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next


# 双指针法
# class Solution:
#     def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
#         pre, cur = None, head   # 初始化当前节点和前一个节点
#         while cur:  # 这里不能写cur.next != None，否则会在cur访问到最后一个节点时，直接跳出循环。
#             temp = cur.next # 暂时保存当前节点的下一个节点
#             cur.next = pre
#             # 更新指针指向的节点
#             pre = cur
#             cur = temp

#         return pre

# 递归法
class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        return self.reverse_node(None, head)    # 调用类内函数要使用self，初始化pre和cur的参数

    def reverse_node(self, pre: ListNode, cur: ListNode) -> Optional[ListNode]:
        # 递归结束条件
        if cur is None:
            return pre  # 返回反转后的链表
        temp = cur.next
        # 翻转两个节点的指向
        cur.next = pre

        # 递归调用
        return self.reverse_node(cur, temp)
  • ACM模式
# Definition for singly-linked list.
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

# 双指针法
# class Solution:
#     def reverseList(self, head):
#         pre, cur = None, head   # 初始化当前节点和前一个节点
#         while cur:  # 这里不能写cur.next != None，否则会在cur访问到最后一个节点时，直接跳出循环。
#             temp = cur.next # 暂时保存当前节点的下一个节点
#             cur.next = pre
#             # 更新指针指向的节点
#             pre = cur
#             cur = temp

#         return pre

# 递归法
class Solution:
    def reverseList(self, head):
        return self.reverse_node(None, head)    # 调用类内函数要使用self，初始化pre和cur的参数

    def reverse_node(self, pre, cur):
        # 递归结束条件
        if cur is None:
            return pre  # 返回反转后的链表
        temp = cur.next
        # 翻转两个节点的指向
        cur.next = pre

        # 递归调用
        return self.reverse_node(cur, temp)

# 创建链表
def creat_list(lenth):
    dummy_head = ListNode(None, None)

    current = dummy_head
    for i in range(lenth):
        val = int(input("输入链表第{}个节点的值：".format(i + 1))) # 获取第i个节点值
        current.next = ListNode(val, None)  # 创建第i个节点，并将其接入链表
        current = current.next

    head = dummy_head.next

    return head

# 输出链表
def output_list(head):
    result = []
    temp = head
    while temp:
        result.append(temp.val)
        temp = temp.next
    return result

# 创建链表
lenth = int(input("输入要创建的链表长度lenth："))
head = creat_list(lenth)

# 反转链表
solution = Solution()
result = solution.reverseList(head)

# 输出反转后的结果
result = output_list(result)
print(result)

24.两两交换链表中的节点

  • 核心代码模式
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        dummy_head = ListNode(None, head) # 构建虚拟头节点
        cur = dummy_head    # 将cur初始为指向虚拟头节点

        while cur.next != None and cur.next.next != None:   # 判断cur之后是否还剩余2个及以上节点
            temp = cur.next # 构建一个临时指针

            cur.next = cur.next.next  # 0 指向 2
            temp.next = cur.next.next # 1 指向 3
            cur.next.next = temp    # 2 指向 1

            cur = cur.next.next # cur向后移动两位
        
        return dummy_head.next

 

  • ACM模式
# Definition for singly-linked list.
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

class Solution:
    def swapPairs(self, head):
        dummy_head = ListNode(None, head)  # 构建虚拟头节点
        cur = dummy_head  # 将cur初始为指向虚拟头节点

        while cur.next != None and cur.next.next != None:  # 判断cur之后是否还剩余2个及以上节点
            temp = cur.next  # 构建一个临时指针

            cur.next = cur.next.next  # 0 指向 2
            temp.next = cur.next.next  # 1 指向 3
            cur.next.next = temp  # 2 指向 1

            cur = cur.next.next  # cur向后移动两位

        return dummy_head.next

# 创建链表
def creat_list(lenth):
    dummy_head = ListNode(None, None)

    current = dummy_head
    for i in range(lenth):
        val = int(input("输入链表第{}个节点的值：".format(i + 1))) # 获取第i个节点值
        current.next = ListNode(val, None)  # 创建第i个节点，并将其接入链表
        current = current.next

    head = dummy_head.next

    return head

# 输出链表
def output_list(head):
    result = []
    temp = head
    while temp:
        result.append(temp.val)
        temp = temp.next
    return result

# 创建链表
lenth = int(input("输入要创建的链表长度lenth："))
head = creat_list(lenth)

# 两两交换链表中的节点
solution = Solution()
result = solution.swapPairs(head)

# 输出结果
result = output_list(result)
print(result)

19.删除链表的倒数第N个节点

  • 核心代码模式
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        dummy_head = ListNode(None, head)   # 构建虚拟头节点，其next值在构建时直接初始化
        slow =  fast = dummy_head   # 创建快、慢指针
 
        for i in range(n + 1):  # 删除倒数第n个节点，让fast先移动n + 1个位置
            fast = fast.next
        # 找到倒数第n个节点的前一个节点
        while fast:    
            slow = slow.next
            fast = fast.next
        
        slow.next = slow.next.next  # 删除倒数第n个节点
    
        return dummy_head.next  # 由于链表第一个节点可能被删除，因此返回的是dummy_head.next而不是head

  • ACM模式 
# Definition for singly-linked list.
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

class Solution:
    def removeNthFromEnd(self, head, n):
        dummy_head = ListNode(None, head)  # 构建虚拟头节点，其next值在构建时直接初始化
        slow = fast = dummy_head  # 创建快、慢指针

        for i in range(n + 1):  # 删除倒数第n个节点，让fast先移动n + 1个位置
            fast = fast.next
        # 找到倒数第n个节点的前一个节点
        while fast:
            slow = slow.next
            fast = fast.next

        slow.next = slow.next.next  # 删除倒数第n个节点

        return dummy_head.next  # 由于链表第一个节点可能被删除，因此返回的是dummy_head.next而不是head

# 创建链表
def creat_list(lenth):
    dummy_head = ListNode(None, None)

    current = dummy_head
    for i in range(lenth):
        val = int(input("输入链表第{}个节点的值：".format(i + 1))) # 获取第i个节点值
        current.next = ListNode(val, None)  # 创建第i个节点，并将其接入链表
        current = current.next

    head = dummy_head.next

    return head

# 输出链表
def output_list(head):
    result = []
    temp = head
    while temp:
        result.append(temp.val)
        temp = temp.next
    return result

# 创建链表
lenth = int(input("输入要创建的链表长度lenth："))
head = creat_list(lenth)
n = int(input("输入要删除的倒数第n个节点："))

# 删除链表的倒数第N个节点
solution = Solution()
result = solution.removeNthFromEnd(head, n)

# 输出结果
result = output_list(result)
print(result)

面试题 02.07.链表相交

  • 核心代码模式
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        curA, curB = headA, headB   # 构建两个指针，分别用于访问两个链表
        lenthA, lenthB = 0, 0   # 记录两个链表的长度

        # 统计链表A的长度
        while curA:
            curA = curA.next
            lenthA += 1
        
        # 统计链表B的长度
        while curB:
            curB = curB.next
            lenthB += 1

        # 重新初始化两个指针
        curA, curB = headA, headB
        
        # 让curB指向较长的那个链表
        if lenthA > lenthB:
            # 交换curA和curB指向的链表
            curA, curB = curB, curA
            lenthA, lenthB = lenthB, lenthA
        
        # 让curB和curA的位置相对于链尾对齐
        for _ in range(lenthB - lenthA):
            curB = curB.next
        
        # 找到两个链表的相交位置
        while curA:
            if curA == curB:
                return curA

            curA = curA.next
            curB = curB.next

        # 未找到链表相交的位置
        return None

142.环形链表II

  • 核心代码模式
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
        fast = slow = head  # 双指针法，构建快慢指针，fast每次移动两个节点，slow每次移动一个节点

        # 判断链表是否本身为空链表
        if fast is None:
            return None

        # fast每次走两步，slow每次走一步，两者速度差为1
        while fast.next and fast.next.next:
            fast = fast.next.next
            slow = slow.next

            # 找到slow和fast之间的相遇点
            if slow == fast:
                index1 = fast
                index2 = head
                # 找到链表的入环第一个节点
                while index1 != index2:
                    index1 = index1.next
                    index2 = index2.next

                # 返回入环点的序号
                return index1
        
        # 链表无环
        return None

ACM模式输入输出攻略 | C++篇
qq_46046431的博客
02-28 2万+
本文内容干货非常非常多，从笔试面试环境的要点，到C++输入输出的具体函数，再到几乎覆盖全部情况的ACM模式写法，最后也给出了链表和二叉树的定义和输入输出。
【实战】ACM 选手图解 LeetCode 环形链表
用有趣有味的方式，学习有价值的编程知识。
02-15 595
图解 LeetCode 141：环形链表。
代码随想录之链表相交
Derrick_itRose的博客
04-13 197
求出两个链表的差，将较长的链表的指向头指针的指针向后移动差值的次数，此时再将指向两个链表的指针同时向后移动，如果指针相同，就返回相应的位置。评论中对该解法的评论：走到尽头见不到你，于是走过你来时的路，等到相遇时才发现，你也走过我来时的路。1.指针 pA 指向 A 链表，指针 pB 指向 B 链表，依次往后遍历。这是笔者能想到的最基本的思路，再结合代码随想录完成相应的代码。2.如果 pA 到了末尾，则 pA = headB 继续遍历。4.比较长的链表指针指向较短链表head时，长度差就消除了。
LeetCode刷题（ACM模式）-02链表
qq_42994487的博客
05-27 3402
LeetCode刷题（ACM模式）-02链表
数据结构（Python实现）------ 链表
Avery123123的博客
12-23 696
数据结构（Python实现）------ 链表数据结构（Python实现）------ 链表单链表基本概念添加操作 - 单链表删除操作 - 单链表设计链表双指针技巧基本概念环形链表相交链表删除链表的倒数第N个节点 数据结构（Python实现）------ 链表 单链表 基本概念 添加操作 - 单链表 如果我们想在给定的结点 prev 之后添加新值，我们应该： 与数组不同，我们不需要将所有元素...
141.环形链表
不如去睡觉
07-21 358
题干： 给你一个链表的头节点 head ，判断链表中是否有环。 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。 如果链表中存在环 ，则返回 true 。 否则，返回 false 。 题解： 就是判断链表中是否有环。用快慢指针法，分别定义 fast 和 slow指针，slow从头指针head开始，fas
火了！北大学霸爆肝3个月的算法小抄完整笔记，GitHub疯狂转发
代码界的扛把子
10-25 114
这位学霸在刷题和打ACM比赛中总结出了经验和套路，又疯狂爆肝3个月，对面试中的常考算法知识点给出通用解题思路和代码模板，已经有不少人通过这份小抄逆风翻盘。算法≠算法面试，内容那么多，常考的却不多，很多同学明明刷了500+的题，但面试中依然跪，主要就是没刷到重点。添加图片注释，不超过 140 字（可选）添加图片注释，不超过 140 字（可选）添加图片注释，不超过 140 字（可选）添加图片注释，不超过 140 字（可选）添加图片注释，不超过 140 字（可选）添加图片注释，不超过 140 字（可选）
【笔记】二叉树
ericma12的博客
12-09 682
本系列总计六篇文章，是 [基于STL实现的笔试题常考七大基本数据结构] 该文章在《代码随想录》和《labuladong的算法笔记》题目中的具体实践，每篇的布局是这样的：开头是该数据结构的总结，然后是在不同场景的应用，以及不同的算法技巧。本文是系列最后一篇，第六篇，介绍了树的相关题目，重点是要掌握二叉树、多叉树的构造、遍历（递归、非递归、层次），以及二叉树、二叉搜索树的属性，体会递归算法的本质是二叉树。
面试重点算法题
tzyshiwolaogongya的博客
06-13 1313
面试机考没有输入输出，下面标红色的较难 ！！！做每题之前都要想一下这道题为什么会想到用这种方法！！！ 一、图论 最短路径：leetcode743（djkstra）、399（floyd）；poj1847、1062（djkstra）、2240（floyd、bellman）、3259（bellman） 拓扑排序：leetcode210（模板题）、310；poj1094（模板题）、2585（进阶应...
原创 | 初学者友好！最全算法学习资源汇总（附链接）
数据派THU
08-24 1763
在计算机发展飞速的今天，也许有人会问，“今天计算机这么快，算法还重要吗？”其实永远不会有太快的计算机，因为我们总会想出新的应用。虽然在摩尔定律的作用下，计算机的计算能力每年都在飞快增长，...
数据结构第一章作业答案参考（C语言）
12-23
第一章 绪论作业答案（共50分） 一、分析如下程序中 (1)~ (10)各语句的频度。（每个1分，共10分） Ex( ) { int i , j , t ; (1) for( i=1 ; i<10 ; i++) //n = (2) printf(“\n %d” , i ); //n = (3) for(i=1; i<=2; i++) //n = (4) printf(“\n”); //n = (5) for(i=1; i<=9; i++) //n = { (6) for(j=1; j <= i ; j++) //n = { (7) t = i * j ; //n = (8) printf(“]”,t); //n = } (9) for(j=1; j 0) { if(x > 100) {x -= 10 ; y -- ;} else x ++ ; } 问if 语句执行了多少次？（2分） y--执行了多少次?（2分） x ++执行了多少次?（2分） 三、回答问题（共25分） 书中16页的起泡排序如下： void bubble_sort(int a[],int n){ //将a中整数序列重新排列成自小至大有序的整数序列。 for(i=n-1,change=TRUE;i>=1&&change;--i){ change=FALSE; for(j=0;ja[j+1]{a[j]<-->a[j+1];change=TRUE; } } }//bubble_sort 1.（共15分）分析该算法的最佳情况 ，最坏情况和平均情况下各自的时间复杂度（给出分析思路与过程）。 (1) 最佳情况的时间复杂度分析（5分）： (2) 最坏情况的时间复杂度分析（5分）： (3) 平均情况的时间复杂度分析（5分）： 2.（共10分）比较与C语言书中的起泡排序异同，并从时空效率角度说明谁更优。 四、完成如下选择题（每3分，共9分）。 1. 设f为原操作，则如下算法的时间复杂度是（ ）。 for (i = 1; i*i=1;i--) for(j=1;jA[j+1]) A[j]与A[j+1]对换; 其中n为正整数，则算法在最坏情况下的时间复杂度为（ ）。 A．O(n) B．O(nlog2n) C. O(n3) D. O(n2)
环形链表
canvasa的博客
08-11 190
OJ链接：环形链表 思路一：快慢指针 我们定义两个指针，初始位置都放在头节点的地方，然后快慢指针一起走，快指针一次走两步（需要注意边界条件），慢指针一次走一步，如果快指针走到nullptr，该链表就不带环；如果快慢指针相遇，该链表就带环。例如：两个人在操场跑步，一个人的速度是另一个人的两倍，如果跑的快的人追上跑的慢的人，那么快的人必然超过慢的人一圈。那么在链表中，也是一样的。 代码 /** * Definition for singly-linked list. * struct List.
【Hot100】LeetCode—142. 环形链表 II
最新发布
weixin_44382896的博客
08-18 344
【代码】【Hot100】LeetCode—142. 环形链表 II。
《ACM竞赛-C/C++入门》 C语言-32
03-25
尹成老师带你步入C语言基础的殿堂，讲课生动风趣、深入浅出，全套视频内容充实，整个教程以C语言为核心，完整精彩的演练了C语言操作流程以及各种精彩的小项目等，提高竞赛能力，非常适合同学们学习！
链表分割、删除重复结点、回文、相交链表、环形链表OJ
Mmmmmmmrr的博客
04-28 315
链表分割： 链接: link. 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前 给定一个链表的头指针 ListNode* pHead，请返回重新排列后的链表的头指针。注意：分割以后保持原来的数据顺序不变。 /* struct ListNode { int val; struct ListNode *next; ListNode(in...
JAVA OJ练习第10题——环形链表
weixin_45662626的博客
11-23 357
给定一个链表，判断链表中是否有环。 示例： 输入：head = [3,2,0,-4] 输出：true 解释：链表中有一个环，其尾部连接到第二个节点。 思路： 设定一个fast一次走两步，slow一次走一步，当fast=slow时，此时证明单链表中有环。 小思考： 本题给出的思路是fast是slow的二倍，那么请思考一下，fast可不可以是slow的三倍？四倍？甚至更多倍呢？ 答案肯定是可以的呢，...
[LeeCode 138]复制带随机指针的链表
caser130的博客
11-05 227
复制带随机指针的链表 给定一个链表，每个节点包含一个额外增加的随机指针，该指针可以指向链表中的任何节点或空节点。 要求返回这个链表的 深拷贝。 我们用一个由 n 个节点组成的链表来表示输入/输出中的链表。 每个节点用一个 [val, random_index] 表示： -----val：一个表示 Node.val 的整数。 -----random_index：随机指针指向的节点索引（范围从 0 到 n-1）；如果不指向任何节点，则为 null 。 来源：力扣（LeetCode 138） 链接：https:
ACM学习历程16——List链表的应用之简单约瑟夫问题
u010480899的博客
08-25 1998
约瑟夫问题是list链表的应用之一，问题描述：N个人围成一个圆圈，每个人都有唯一的一个编号，编号从1到N，从编号为1的人开始报数，依次报到K，报数为K的人出列，他的下一个又从1开始报数，直到所有的人都出列，求这个出列的序列。结合上一篇博客，这里使用list链表，给出一个可行的解答代码。 注：n为人数,p为要报的数。 #include #include using namespace std;
C++解OJ题--环形链表
老胡的博客
11-10 1103
  害怕犯错而不去犯错才是最大的错误！   哈哈，登场的时候先抒情一下！今天又解了一道算法题，一起来看看吧
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值