剑指offer刷题复习（简单二）

剑指 Offer 11. 旋转数组的最小数字

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一个旋转，该数组的最小值为1。

示例 1：

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

输入：[2,2,2,0,1]
输出：0

解题思路：
java排序返回第一个，python直接用min方法

java

class Solution {
    public int minArray(int[] numbers) {
        
        Arrays.sort(numbers);
        return numbers[0];
    }
}

python

class Solution(object):
    def minArray(self, numbers):
        """
        :type numbers: List[int]
        :rtype: int
        """
        return min(numbers)

剑指 Offer 15. 二进制中1的个数

请实现一个函数，输入一个整数，输出该数二进制表示中 1 的个数。例如，把 9 表示成二进制是 1001，有 2 位是 1。因此，如果输入 9，则该函数输出 2。

示例 1：

输入：00000000000000000000000000001011
输出：3
解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 ‘1’。
示例 2：

输入：00000000000000000000000010000000
输出：1
解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 ‘1’。
示例 3：

输入：11111111111111111111111111111101
输出：31
解释：输入的二进制串 11111111111111111111111111111101 中，共有 31 位为 ‘1’。

解题思路：

java

public class Solution {
    // you need to treat n as an unsigned value
    int count = 0;
    public int hammingWeight(int n) {
        for(int i = 0; i < 32; i++){
            if(((n >>> i) & 1)==1){
                count++;
            }
        }
        return count;
    }
}

python

class Solution(object):
    def hammingWeight(self, n):
        """
        :type n: int
        :rtype: int
        """
        res = 0
        while n:
            res += n & 1
            n >>= 1
        return res

剑指 Offer 17. 打印从1到最大的n位数

输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。

示例 1:

输入: n = 1
输出: [1,2,3,4,5,6,7,8,9]

说明：

用返回一个整数列表来代替打印
n 为正整数
通过次数48,475提交次数61,574

解题思路：输入n代表10的n次方减一个数，依次遍历赋值，java中次方函数

Math.pow()//返回的是double类型

python中是

math.pow()#也是double类型

java
class Solution {
public int[] printNumbers(int n) {
int number = (int)Math.pow(10,n)-1;
int[] res = new int[number];
int math = 1;
for(int i=0;i<number;i++){
res[i] = math;
math++;
}
return res;
}
}
python

class Solution(object):
    def printNumbers(self, n):
        """
        :type n: int
        :rtype: List[int]
        """
        number = math.pow(10,n)-1
        res = []
        for i in range(1,int(number)+1):
            res.append(i)
        return res

剑指 Offer 18. 删除链表的节点

给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。

返回删除后的链表的头节点。

注意：此题对比原题有改动

示例 1:

输入: head = [4,5,1,9], val = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.
示例 2:

输入: head = [4,5,1,9], val = 1
输出: [4,5,9]
解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.

解题思路：
判断当前节点的下一个是不是要删除的，如果是就把当前节点的下一个指向节点，改为下下一个指向节点，如果第一个就是要删除的直接返回p.next

java

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode deleteNode(ListNode head, int val) {
        ListNode p = head;
        if(p.val == val) return p.next;
        while(p.next!=null){
            if(p.next.val == val){
                p.next =p.next.next;
                return head;
            }
            else{
                p = p.next;
            }
        }
        return head;
    }
}

python

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution(object):
    def deleteNode(self, head, val):
        """
        :type head: ListNode
        :type val: int
        :rtype: ListNode
        """
        p = head
        if p.val == val:
            return p.next
        while p.next :
            if p.next.val == val:
                
                p.next = p.next.next
                return head
            else:
                p = p.next

剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

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

示例：

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

提示：

1 <= nums.length <= 50000
1 <= nums[i] <= 10000

解题思路：
类似于双指针，一个从前往后一个从后往前，前后分别是奇数以及偶数不作处理，前后分别是偶数奇数就交换，前一个是奇数后一个也是奇数的话前面的减一，后面是偶数前面也是偶数的话，后面的减一

java

class Solution {
    public int[] exchange(int[] nums) {
        int number = nums.length;
        int[] res = new int[number];
        int l = 0;
        int r = number-1;
        for(int i=0;l<=r;i++){
            if(nums[i]%2==0){
                res[r] = nums[i];
                r--;
            }else{
                res[l] = nums[i];
                l++;
            }
        }
        return res;
    }
}

python

class Solution(object):
    def exchange(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        l = 0
        r = len(nums)-1
        while l<=r:
            if nums[l]%2==0 and nums[r]%2!=0:
                tmp = nums[l]
                nums[l] = nums[r]
                nums[r] = tmp
                l = l + 1
                r = r - 1 
            if nums[l]%2!=0 and nums[r]%2==0:
                l = l + 1
                r = r - 1 
            if nums[l]%2==0 and nums[r]%2==0:
                r = r - 1 
            if nums[l]%2!=0 and nums[r]%2!=0:
                l = l + 1
        return nums

剑指 Offer 22. 链表中倒数第k个节点

输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有6个节点，从头节点开始，它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。

示例：

给定一个链表: 1->2->3->4->5, 和 k = 2.

返回链表 4->5.

解题思路：快满指针，一个先走k步，另一个不走，然后一起走，知道先走的为空。

java

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        ListNode m = head;
        ListNode n = head;

        for(int i=0;i<k;i++){
            m = m.next;
        }
        while(m!=null){
            m = m.next;
            n = n.next;
        }
        return n;
    }
}

python

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

class Solution(object):
    def getKthFromEnd(self, head, k):
        """
        :type head: ListNode
        :type k: int
        :rtype: ListNode
        """
        m = head
        n = head

        for i in range(k):
            m = m.next
        while m :
            m = m.next
            n = n.next
        return n