算法面试通关 — 数组与链表

算法基础

所消耗的时间从小到大

O(1) < O(logn) < O(n) < O(nlogn) < O(n2) < O(n3) < O(2n) < O(n!) < O(nn)

 

 

 

面试常问的时间复杂度（死记硬背）

 

 如何通关Leetcode 进行算法训练

中文网址

https://leetcode-cn.com/

https://leetcode-cn.com/problemset/all/

英文网址

https://leetcode.com/

成就大神诀窍

 数组

 时间复杂度

 数组是段连续的存储， 查询只要一次计算就可获取值O(1)，插入到某个位置需要把后面的元素都依次向后移动一位O(n),删除某个元素需要把后面的元素依次向前移动一位 O(n)

Linked List （链表）

 总结：

数组:

　　内存中是连续的,查找是时间复杂度是o(1). 插入和删除会让后面的元素往后挪动,所以时间复杂度是 o(n)

链表:

　　单链表,只有 next. 双链表,不仅有 next, 还有 previous，插入和删除的复杂度是 o(1) ，查找的话,时间复杂度是 o(n),因为要从头一个一个往后查找.

1  反转链表

• 英文版：https://leetcode.com/problems/reverse-linked-list/
• 中文版：https://leetcode-cn.com/problems/reverse-linked-list/

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

 

?

1 2	输入：head = [1,2,3,4,5] 输出：[5,4,3,2,1]

题解

在遍历链表时，将当前节点的 \textit{next}next 指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前一个节点。在更改引用之前，还需要存储后一个节点。最后返回新的头引用。

?

1 2 3 4 5 6 7 8 9 10

class Solution:     def reverseList(self, head):         """         :type head: ListNode         :rtype: ListNode         """         p, rev = head, None  # 每次循环的时候，这两个值都会改变         while p:             rev, rev.next, p = p, rev, p.next # 在这里还是一条语句没有执行完，所以变量不会存在覆盖的情况         return rev

class Solution1:
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        p, rev = head, None   # 每次循环的时候，这两个值都会改变
        while p.next:
            rev.next = rev
            p = p.next
            rev = p
        return rev

2 两两交换链表中的节点

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）

 

?

1 2 3 4 5 6 7 8

输入：head = [1,2,3,4] 输出：[2,1,4,3]    输入：head = [] 输出：[]    输入：head = [1] 输出：[1]

题解

创建哑结点 dummyHead，令 dummyHead.next = head，这个主要的目的是循环终止的条件。令 temp 表示当前到达的节点，初始时 temp = dummyHead。每次需要交换 temp 后面的两个节点。

如果 temp 的后面没有节点或者只有一个节点，则没有更多的节点需要交换，因此结束交换。否则，获得 temp 后面的两个节点 node1 和 node2，通过更新节点的指针关系实现两两交换节点。

具体而言，交换之前的节点关系是 temp -> node1 -> node2，交换之后的节点关系要变成 temp -> node2 -> node1，因此需要进行如下操作。

?

1 2 3

temp.next = node2 node1.next = node2.next node2.next = node1

完成上述操作之后，节点关系即变成 temp -> node2 -> node1。再令 temp = node1，对链表中的其余节点进行两两交换，直到全部节点都被两两交换。

两两交换链表中的节点之后，新的链表的头节点是 dummyHead.next，返回新的链表的头节点即可。

关键在于先把前两个节点的指针对应关系处理好，然后在跳过前面处理好的节点，一次循环下去

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

class ListNode(object):     def __init__(self, val=0, next=None):         self.val = val         self.next = next   class Solution:     def swapPairs(self, head):         dummyHead = ListNode(0)         dummyHead.next = head         temp = dummyHead         while temp.next and temp.next.next:             node1 = temp.next             node2 = temp.next.next             temp.next = node2             node1.next = node2.next             node2.next = node1             temp = node1         return dummyHead.next

3 判断链表是否有环

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

给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

题解

?

1 2 3 4 5 6 7 8 9

class Solution:     def hasCycle(self, head: ListNode) -> bool:         fast = slow = head         while slow and fast and fast.next:             slow = slow.next             fast = fast.next.next             if slow is fast:                 return True         return False

4 环形链表2　　

给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

?

1 2 3

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

?

1 2 3

输入：head = [1,2], pos = 0 输出：返回索引为 0 的链表节点 解释：链表中有一个环，其尾部连接到第一个节点。

 

?

1 2 3

输入：head = [1], pos = -1 输出：返回 null 解释：链表中没有环。

 

f=a+n(b+c)+b

s = a+b

f=2s

a+n(b+c)+b = 2a+2b

n(b+c)-b=a

n(b+c)-b+c-c=a

(n-1)(b+c)+c=a

c=a

题解

?

1 2 3 4 5 6 7 8 9 10 11 12 13

class Solution(object):     def detectCycle(self, head):         fast, slow = head, head         while True:             if not (fast and fast.next):                 return             fast, slow = fast.next.next, slow.next             if fast == slow:                 break         fast = head         while fast != slow:             fast, slow = fast.next, slow.next         return fast

https://leetcode-cn.com/problems/swap-nodes-in-pairs/solution/python3-liang-liang-jiao-huan-lian-biao-yzftb/