返回顶部

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

算法基础

所消耗的时间从小到大

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  反转链表

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

 

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

题解

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

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 两两交换链表中的节点

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

 

输入：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，因此需要进行如下操作。

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

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

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

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

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 判断链表是否有环

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

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

题解

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 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

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


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

 

输入：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

题解

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/

 

posted @ 2021-05-24 23:52  Crazymagic  阅读(45)  评论(0)    收藏  举报