python 字符串排序 leetcode_LeetCode in python--排序篇

排序的题目较少，简单题和中等题写在一篇，一共9个题。

提纲

给出一个区间的集合，请合并所有重叠的区间。

示例 :

输入: [[1,3],[2,6],[8,10],[15,18]]

输出: [[1,6],[8,10],[15,18]]

解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

思路

先按区间的第一个元素大小进行排序，然后将第一个区间放入res列表中， 如果当前区间的第一个数比res中最后一个区间的第二个数小，则更新结果中的最后一个区间，否则，将当前区间加入结果列表中。

代码

class Solution(object):

def merge(self, intervals):

""":type intervals: List[List[int]]:rtype: List[List[int]]"""

if len(intervals) <= 1:

return intervals

intervals.sort(key=lambda x:x[0]) # 根据每个区间的第一个数对列表排序

res = [intervals[0]] # 用于保存得到的结果

for i in range(1, len(intervals)):

if intervals[i][0] <= res[-1][1]:

res[-1][1] = max( res[-1][1], intervals[i][1])

else:

res.append(intervals[i])

return res

给定一个包含红色、白色和蓝色，一共 n 个元素的数组，

此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。

注意:

不能使用代码库中的排序函数来解决这道题。

示例:

输入: [2,0,2,1,1,0]

输出: [0,0,1,1,2,2]

思路

三路快排，0移动到最左边，2移动到最右边，遇到1则跳过。

代码

class Solution(object):

def sortColors(self, nums):

""":type nums: List[int]:rtype: None Do not return anything, modify nums in-place instead."""

left = 0

right = len(nums) - 1

i = 0

while i <= right:

if nums[i] == 2:

nums[i], nums[right] = nums[right], nums[i]

right -= 1

elif nums[i] == 0:

nums[i], nums[left] = nums[left], nums[i]

left += 1

i += 1

else:

i += 1

对链表进行插入排序。插入排序演示动画

插入排序的动画演示如上。从第一个元素开始，该链表可以被认为已经部分排序(用黑色表示)。每次迭代时，从输入数据中移除一个元素(用红色表示)，并原地将其插入到已排好序的链表中。

插入排序算法：插入排序是迭代的，每次只移动一个元素，直到所有元素可以形成一个有序的输出列表。

每次迭代中，插入排序只从输入数据中移除一个待排序的元素，找到它在序列中适当的位置，并将其插入。

重复直到所有输入数据插入完为止。

示例 ：

输入: 4->2->1->3

输出: 1->2->3->4

思路

用指针p逐一向后遍历，申请一个虚拟头结点dummyHead，指向头结点，便于在头结点插入。当p的值小于等于下一个结点的值，指针p右移；当p的值大于下一节点的值，那么将p的下一个节点取出，从前往后扫描，在第一个比它的值大的节点之前插入该节点。

代码

class Solution(object):

def insertionSortList(self, head):

""":type head: ListNode:rtype: ListNode"""

if not head or not head.next:

return head

dummyHead = TreeNode(0)

dummyHead.next = head

p = head

while p.next:

if p.val <= p.next.val:

p = p.next

else:

temp = p.next

q = dummyHead

p.next = p.next.next

while q.next and q.next.val < temp.val:

q = q.next

temp.next = q.next

q.next = temp

return dummyHead.next

在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。

示例 :

输入: 4->2->1->3

输出: 1->2->3->4

思路

使用归并排序。使用快慢指针寻找链表中点，并分解链表；递归融合两个有序链表。

代码

class Solution(object):

def sortList(self, head):

""":type head: ListNode:rtype: ListNode"""

if head is None:

return None

return self.minute(head)

def minute(self, head):

"""快慢指针分解链表"""

if head.next is None:

return head

quick, slow, temp = head, head, head

while quick is not None and quick.next is not None:

temp = slow

slow = slow.next

quick = quick.next.next

temp.next = None # 这一步就是将整个链表从中间分开 失去这一步 后面将无限循环

i = self.minute(head)

j = self.minute(slow)

return self.Combined(i, j)

def Combined(self, i, j):

"""合的过程就是从i 和 j开始比较 就是从开头和中间开始比较 将两个相比小的排在head后最后返回head即可"""

TempNode = ListNode(0)

temp = TempNode

while i is not None and j is not None:

if i.val <= j.val:

temp.next = i

i = i.next

else:

temp.next = j

j = j.next

temp = temp.next

if i is not None:

temp.next = i

if j is not None:

temp.next = j

return TempNode.next

给定一组非负整数，重新排列它们的顺序使之组成一个最大的整数。

示例 :

输入: [3,30,34,5,9]

输出: 9534330

思路

如何比较两个数合并后的大小，顺序拼接两个字符串，如果a+b>b+a，那么a在前面。

代码

class Solution(object):

def largestNumber(self, nums):

""":type nums: List[int]:rtype: str"""

def compare(a,b):

return int(b + a) - int(a + b)

nums = sorted([str(i) for i in nums],cmp = compare)

ans = ''.join(nums).lstrip('0') #lstrip是去除左边的0

return ans or '0'

给定一个整数数组，判断数组中是否有两个不同的索引 i 和 j，使得 nums [i] 和 nums [j] 的差的绝对值最大为 t，并且 i 和 j 之间的差的绝对值最大为 ķ。

示例 1:

输入: nums = [1,2,3,1], k= 3, t = 0

输出: true

示例 2:

输入: nums = [1,0,1,1], k=1, t = 2

输出: true

示例 3:

输入: nums = [1,5,9,1,5,9], k = 2, t = 3

输出: false

思路

将数值依次放入set中，当长度>k，就把set中最左边的元素删除。

代码

class Solution(object):

def containsNearbyAlmostDuplicate(self, nums, k, t):

""":type nums: List[int]:type k: int:type t: int:rtype: bool"""

a = set()

for i in range(len(nums)):

if t == 0:

if nums[i] in a:

return True

else:

for item in a:

if abs(nums[i] - item) <= t:

return True

a.add(nums[i])

if len(a) == k+1:

a.remove(nums[i - k])

return False

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的一个字母异位词。

示例 1:

输入: s = "anagram", t = "nagaram"

输出: true

示例 2:

输入: s = "rat", t = "car"

输出: false

思路

考虑字母出现的频率是否相等。首先，两个字符串长度不相等，返回False；然后将字符串s放在set中，消除重复元素，遍历这些元素，如果s中字母的个数和t中字母的个数不相等，返回False。

代码

class Solution(object):

def isAnagram(self, s, t):

""":type s: str:type t: str:rtype: bool"""

if len(s) != len(t):

return False

for i in set(s):

if s.count(i) != t.count(i):

return False

return True

给定一位研究者论文被引用次数的数组(被引用次数是非负整数)。编写一个方法，计算出研究者的 h指数。

h 指数的定义: “h 代表“高引用次数”(high citations)，一名科研人员的 h 指数是指他(她)的 (N 篇论文中)至多有 h 篇论文分别被引用了至少 h 次。(其余的 N - h篇论文每篇被引用次数不多于 h 次。)”

示例：

输入: citations = [3,0,6,1,5]

输出: 3

解释: 给定数组表示研究者总共有 5 篇论文，每篇论文相应的被引用了 3, 0, 6, 1, 5 次。

由于研究者有 3 篇论文每篇至少被引用了 3 次，其余两篇论文每篇被引用不多于 3 次，所以她的 h 指数是 3。

思路

将数组从小到大排序，遍历数组，判断当前值是否满足H指数。

代码

class Solution(object):

def hIndex(self, citations):

""":type citations: List[int]:rtype: int"""

citations.sort() #从小到大排列

h = len(citations)

index = 0

while index < len(citations):

if citations[index] >= h:

return h

index += 1

h -=1

return 0

给定一个无序的数组 nums，将它重新排列成 nums[0] < nums[1] > nums[2] < nums[3]... 的顺序。

示例 :

输入: nums = [1, 5, 1, 1, 6, 4]

输出: 一个可能的答案是 [1, 4, 1, 5, 1, 6]

思路

对数组进行排序，奇数索引位置放入大于中位数的数，偶数索引放入小于中位数的数，穿插排序。

代码

class Solution(object):

def wiggleSort(self, nums):

nums.sort()

half = len(nums[::2])

nums[::2], nums[1::2] = nums[:half][::-1], nums[half:][::-1]