牛客刷题day11（在两个长度相等的数组中寻找中位数，删除链表中重复的元素，矩阵元素查找，链表的奇偶重排，重排链表，反转数字）

牛客刷题day11

1.在两个长度相等的数组中寻找中位数

题目

给定两个有序数组arr1和arr2，已知两个数组的长度都为N，求两个数组中所有数的上中位数。
上中位数：假设递增序列长度为n，若n为奇数，则上中位数为第n/2+1个数；否则为第n/2个数
时间复杂度为O(logN)O(logN)，额外空间复杂度为O(1)O(1)
输入
[1,2,3,4],[3,4,5,6]
返回值
3

解题思路

遍历列表求中位数

核心代码

class Solution:
    def findMedianinTwoSortedAray(self, arr1, arr2):
        len1 = len(arr1)
        len2 = len(arr2)
        if (len1 + len2) % 2 == 0:
            mid = int((len1 + len2) / 2)
        else:
            mid = int((len1 + len2) // 2 + 1)
        m, n = 0, 0
        k = 0
        for i in range(mid):
            if arr1[m] <= arr2[n] and m <= len1:
                k = arr1[m]
                m += 1
            else:
                k = arr2[n]
                n += 1
        return k

2.删除链表中重复的元素

题目

给出一个升序排序的链表，删除链表中的所有重复出现的元素，只保留原链表中只出现一次的元素。
例如：
给出的链表为1→2→3→3→4→4→5, 返回1\to 2\to51→2→5.
给出的链表为1→1→1→2→3, 返回2\to 32→3.
示例1
输入
{1,2,2}
返回值
{1}

解题思路

1.设置伪结点，方便处理
2.双指针prev和curr
3.当遇到当前节点值和下一节点值相等的节点时，进行while循环找到下一个不相等的节点，挂到prev节点上
4.当遇到当前节点值和下一节点值不相等的节点时，prev和curr都移动到下一个节点接着遍历就行

核心代码

class Solution:
    def deleteDuplicates(self, head):
        # write code here
        if not head:
            return head
        newList = ListNode(0)
        newList.next = head
        pre,cur = newList,head
        while cur and cur.next:
            if cur.val == cur.next.val:
                val = cur.val
                while cur and cur.val ==val:
                    cur = cur.next
                pre.next =cur
            else:
                pre = pre.next
                cur =cur.next
        return newList.next

3.矩阵元素查找

题目

已知int一个有序矩阵mat，同时给定矩阵的大小n和m以及需要查找的元素x，且矩阵的行和列都是从小到大有序的。设计查找算法返回所查找元素的二元数组，代表该元素的行号和列号(均从零开始)。保证元素互异。
示例1
输入
[[1,2,3],[4,5,6]],2,3,6
返回值
[1,2]

解题思路

由于给定的二维数组具备每行从左到右递增以及每列从上到下递增的特点，当访问到一个元素时，可以排除数组中的部分元素。我们可以从矩阵的右上角元素开始进行查询，
如果其等于目标元素则直接返回结果；
如果其大于目标元素，证明该元素在改行，则只能往列坐标减少的方向去寻找，其他位置的元素都是大于当前访问的元素的，自然也就大于目标元素；
如果当前访问的元素小于目标元素值，证明该元素在下一行，那么就往行坐标变大的方向去寻找，因为除了已经在先前访问时被排除的部分元素之外，在和当前元素的同一行中，位于当前访问元素前面的元素，也一定小于目标元素，所以可以直接排除。

核心代码

class Solution:
    def findElement(self, mat, n, m, x):
        # write code here
        row =0
        col =m-1
        while row<n and col>=0:
            if mat[row][col]==x:
                return[row,col]
            elif mat[row][col]>x:
                col-=1
            else:
                row+=1
        return [0,0]
        

4.链表的奇偶重排

题目

给定一个单链表，请设定一个函数，将链表的奇数位节点和偶数位节点分别放在一起，重排后输出。
注意是节点的编号而非节点的数值。
示例1
输入
{1,2,3,4,5,6}
返回值
{1,3,5,2,4,6}

解题思路

注意题目要求是节点的编号
我的解题思路就是定义两个指针 分别指向奇偶，然后定义pre指针在每次使用尾插法插入奇数节点后 指向该节点

核心代码

class Solution:
    def oddEvenList(self, head):
        if not head or not head.next or not head.next.next:
            return head
        newList = ListNode(0)
        newList.next = head
        pre = head
        while head and head.next and head.next.next:
            even, old = head.next, head.next.next
            even.next = old.next
            old.next = pre.next
            pre.next = old
            pre = pre.next
            head =even
        return newList.next

5.重排链表

题目

解题思路

1->2->3 ->4->5->6
第一步：将链表分为两个链表
​ 1->2->3 4->5->6

第二步：将第二个链表逆序

​ 1->2->3 6->5->4

第三步：依次连接两个链表 连接形式如下
1->6->2->5->3->4

核心代码

class Solution:
    def reorderList(self, head):
        if not head or not head.next or not head.next.next:
            return head
        newHead =ListNode(0)
        newHead.next =head
        slow = head
        fast = head.next
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
        mid = slow.next
        slow.next = None
        reverseHead = self.reverse(mid)
        while reverseHead:
            temp = reverseHead.next
            reverseHead.next =head.next
            head.next = reverseHead
            head = reverseHead.next
            reverseHead = temp
        return newHead.next

    def reverse(self, head):
        if not head:
            return head
        tail = head
        head = head.next
        tail.next = None
        while head:
            tmp = head.next
            head.next = tail
            tail = head
            head = tmp
        return tail

6.反转数字

题目

将给出的32位整数x翻转。
例1:x=123，返回321
例2:x=-123，返回-321
你有注意到翻转后的整数可能溢出吗？因为给出的是32位整数，则其数值范围为[−2^{31}, 2^{31} − 1]翻转可能会导致溢出，如果反转后的结果会溢出就返回 0。

解题思路

先将数字转为字符串，然后反转

核心代码

class Solution:
    def reverse(self , x ):
        # write code hereif
        if x<0:
            res = int('-'+str(-x)[::-1])
        else:
            res = int(str(x)[::-1])
        if res<-2**31 or res>2**31:
            return 0
        else:
            return res