letecode练习一：数组和队列(python实现)

最新推荐文章于 2022-02-03 12:42:48 发布

weixin_41741008

最新推荐文章于 2022-02-03 12:42:48 发布

阅读量314

点赞数

分类专栏： letecode

本文链接：https://blog.csdn.net/weixin_41741008/article/details/98187895

版权

letecode 专栏收录该内容

55 篇文章 0 订阅

订阅专栏

letecode练习一：数组和队列

一、概念

数组：数组是具有相同的数据类型且按一定次序排列的一组变量的集合体。

队列：链表是一种物理储存单元上非连续、非顺序的储存结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。。

二、优缺点

数组:

    优点：使用方便 ，查询效率 比链表高，内存为一连续的区域 
    缺点：大小固定，不适合动态存储，不方便动态添加
链表：

   优点：可动态添加删除   大小可变   
   缺点：只能通过顺次指针访问，查询效率低

补充：

顺序表的优点:查找方便,适合随机查找
顺序表的缺点:插入、删除操作不方便，因为插入、删除操作会导致大量元素的移动

链接表的优点:插入、删除操作方便，不会导致元素的移动，因为元素增减，只需要调整指针。

顺序表的缺点:查找方便，不适合随机查找

三、常见考题

（一）反转链表：就比如把1—>2->3->4转化为4->3->2->1

法一：从头到尾遍历链表，每到一个新元素时，定义两个指针p和q，p指向当前元素的上一个元素，q指向当前元素的下一个元素。把第一个节点连在第二个节点的后面，并将p和q均向右移动一位

class Solution(object):

def reverseList(self, phead):
p=phead

q=p.next ##p和q分别指代当前节点和下一个节点

p.next=None ##把第一个节点和之后的节点断开

while q: ##从第二次个节点开始

r=q.next ##先保存下一个节点的值

q.next=p ##把第一个节点连在第二个节点的后面

p,q=q,r ##p,q分别往后移

return p

法一的优化(注意：python中多元赋值的时候，右边的值不会随着赋值而改变)

class Solution:
def reverseList(self, head):

    pre, cur = None, head
    while cur:
        cur.next, pre, cur = pre, cur, cur.next
    return pre

(二)两两节点进行反转：和链表反转类似，关键在于　有三个指针，分别指向前后和当前节点。不同点是两两交换后，移动节点步长为２

创建三个指针：

pre指向开始交换的节点的上一个节点

a指向需要交换的第一个节点，即head.next

b指向需要交换的第二个节点，即head.next.next

循环链表，通过head不断交换a/b位置即可。

class Solution(object):
def swapPairs(self, head):
pre,pre.next=self,head
while pre.next and pre.next.next:
a=pre.next
b=a.next
pre.next,b.next,a.next=b,a,b.next###把b的位置换成a，b后面连a，a后面重新接b的后面，即把a,b调换成b,a

     pre=a###同时更换pre指针
     return self.next

(三)给定一个链表，判断链表中是否有环。

思路：定义一个快指针和慢指针，快指针一次走两步，慢指针一次走一步，若两指针能够相遇则存在环，否则不存在环。

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

（四）给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回 null。为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。

思路：分两个步骤，首先通过快慢指针的方法判断链表是否有环；

接下来如果有环，则寻找入环的第一个节点。具体的方法为，首先，设头结点到入环结点的距离为a，入环结点到相遇结点的距离为b，相遇结点到入环结点的距离为c。然后，当f以s的两倍速度前进并和s相遇时，f走过的距离是s的两倍，即有等式：a+b+c+b = 2(a+b) ，可以得出 a = c ，所以说，让fast和slow分别从相遇结点和头结点同时同步长出发，他们的相遇结点就是入环结点。

在这里插入图片描述

class Solution(object):
def detectCycle(self, head):
slow=fast=head
while slow and fast and fast.next:
slow=slow.next
fast=fast.next.next
if slow is fast:
print(‘has Cycle’)
slow=head####相遇slow指向head
while slow is not fast:
slow=slow.next
fast=fast.next
return slow
return None
print(‘no cycle’)
（五）给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。

k 是一个正整数，它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

示例 :

给定这个链表：1->2->3->4->5

当 k = 2 时，应当返回: 2->1->4->3->5

当 k = 3 时，应当返回: 3->2->1->4->5