剑指offer (1-10)

1. 面试题03： 数组中的重复数字：

找出数组中重复的数字。

在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

示例 1：
输入：
[2, 3, 1, 0, 2, 5, 3]
输出：2 或 3

限制：
2 <= n <= 100000

class Solution(object):
    def findRepeatNumber(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        dict = {}   # Python的dict和set都是使用hash表实现
        result = []
        for n in nums:
            if n not in dict:
                dict[n] = 1
            else:
                dict[n] += 1
                result.append(n)
        return result[0]
    
    

2. 面试题04：二维数组中的查找

在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

示例:

现有矩阵 matrix 如下：

[
[1, 4, 7, 11, 15],
[2, 5, 8, 12, 19],
[3, 6, 9, 16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30]
]
给定 target = 5，返回 true。

给定 target = 20，返回 false。

解题思路：

若使用暴力法遍历矩阵 matrix ，则时间复杂度为 O(N*M)O(N∗M) 。暴力法未利用矩阵 “从上到下递增、从左到右递增” 的特点，显然不是最优解法。
本题解利用矩阵特点引入标志数，并通过标志数性质降低算法时间复杂度。

-标志数引入： 此类矩阵中左下角和右上角元素有特殊性，称为标志数。

左下角元素： 为所在列最大元素，所在行最小元素。
右上角元素： 为所在行最大元素，所在列最小元素。

标志数性质： 将 matrix 中的左下角元素（标志数）记作 flag ，则有:

若 flag > target ，则 target 一定在 flag 所在行的上方，即 flag 所在行可被消去。
若 flag < target ，则 target 一定在 flag 所在列的右方，即 flag 所在列可被消去。

本题解以左下角元素为例，同理，右上角元素 也具有行（列）消去的性质。
算法流程： 根据以上性质，设计算法在每轮对比时消去一行（列）元素，以降低时间复杂度。

从矩阵 matrix 左下角元素（索引设为 (i, j) ）开始遍历，并与目标值对比：
当 matrix[i][j] > target 时： 行索引向上移动一格（即 i–），即消去矩阵第 i 行元素；
当 matrix[i][j] < target 时： 列索引向右移动一格（即 j++），即消去矩阵第 j 列元素；
当 matrix[i][j] == target 时： 返回 truetrue 。
若行索引或列索引越界，则代表矩阵中无目标值，返回 false。

class Solution(object):
    def findNumberIn2DArray(self, matrix, target):
        """
        :type matrix: List[List[int]]
        :type target: int
        :rtype: bool
        """        
        # 引入标志数，左下角元素
      
        if len(matrix) == 0:
            return False
        
        i = len(matrix) -1
        j = 0
        while i >=0 and j<= len(matrix[0])-1:
            if matrix[i][j] > target:
                i -= 1   # 消掉这一行
            elif matrix[i][j] < target:
                j +=1
            else:
                return True
        return False

3. 面试题05：替换空格

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

示例 1：

输入：s = “We are happy.”
输出：“We%20are%20happy.”

限制：
0 <= s 的长度 <= 10000

两种解法：

class Solution(object):
    def replaceSpace(self, s):
        """
        :type s: str
        :rtype: str
        """
        # 解题1. 新建一个字符串，非空格直接加入，空格替换成20%加入
        
        sNew = ''
        for a in s:
            if a == " ":
                sNew += "%20"
            else:
                 sNew += a
        return sNew
 
        # 解题2. 使用python自带的replace函数，一行解决
    
        #return s.replace(" ","%20")

4. 面试题06：从尾到头打印链表

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。
示例 1：
输入：head = [1,3,2]
输出：[2,3,1]
限制：
0 <= 链表长度 <= 10000

方法一：递归法
解题思路：
利用递归： 先走至链表末端，回溯时依次将节点值加入列表 ，这样就可以实现链表值的倒序输出。

Python 算法流程：

• 递推阶段： 每次传入 head.next ，以 head == None（即走过链表尾部节点）为递归终止条件，此时返回空列表 [] 。
• 回溯阶段： 利用 Python 语言特性，递归回溯时每次返回 当前 list + 当前节点值 [head.val] ，即可实现节点的倒序输出。

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def reversePrint(self, head):
        """
        :type head: ListNode
        :rtype: List[int]
        """
        # 1.方法一：递归法
 
        cur = head
        if cur:
             return self.reversePrint(head.next) + [cur.val]
        else:
             return []

**方法二：**利用栈的思想。
在python里, [] 就代表是栈

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def reversePrint(self, head):
        """
        :type head: ListNode
        :rtype: List[int]
        """
              
        # 2. 方法二:利用栈的思想
        # 在python中：[]就是栈

        stack = []
        cur = head
        while cur:
            stack.append(cur.val)
            cur = cur.next
        return stack[::-1]

5. 面试题21 调整数组顺序使奇数位于偶数前面

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。

示例：

输入：nums = [1,2,3,4]
输出：[1,3,2,4]
注：[3,1,2,4] 也是正确的答案之一。

方法一：直接遍历数组

class Solution(object):
    def exchange(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        # 1.直接解法
        result = []
        temp = []
        for num in nums:
            if num%2 != 0:
                result.append(num)
            else:
                temp.append(num)
        result.extend(temp)
        return result  

方法二：双指针

考虑定义双指针 i , j 分列数组左右两端，循环执行：

指针 i 从左向右寻找偶数；
指针 j 从右向左寻找奇数；
将 偶数 nums[i] 和 奇数 nums[j] 交换。
可始终保证： 指针 i 左边都是奇数，指针 j 右边都是偶数 。

算法流程：
初始化： i , j 双指针，分别指向数组 nums 左右两端；
循环交换： 当 i = j 时跳出；
指针 i 遇到奇数则执行 i = i + 1 跳过，直到找到偶数；
指针 j 遇到偶数则执行 j = j - 1 跳过，直到找到奇数；
交换 nums[i] 和 nums[j] 的值；
返回值： 返回已修改的 nums 数组。

参考链接：https://leetcode-cn.com/problems/diao-zheng-shu-zu-shun-xu-shi-qi-shu-wei-yu-ou-shu-qian-mian-lcof/solution/mian-shi-ti-21-diao-zheng-shu-zu-shun-xu-shi-qi-4/
来源：力扣（LeetCode）

class Solution(object):
    def exchange(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        # 2. 双指针 
        i, j = 0, len(nums)-1
        while i < j:
            while i<j and nums[i] % 2 != 0:
                i = i+1
            while i<j and nums[j] % 2 ==0:
                j = j-1
            nums[i], nums[j] = nums[j],nums[i]
        return nums