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

最新推荐文章于 2021-07-21 13:43:46 发布

zhenliang_Horn

最新推荐文章于 2021-07-21 13:43:46 发布

阅读量136

点赞数

分类专栏：代码文章标签： leetcode 算法

本文链接：https://blog.csdn.net/qq_30312047/article/details/108309611

版权

代码专栏收录该内容

70 篇文章 0 订阅

订阅专栏

剑指 Offer 24. 反转链表

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

限制：

0 <= 节点个数 <= 5000

解题思路：
在这里插入图片描述

java

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode p = head;
        ListNode q = null;
        while(p!=null){
            ListNode t = p.next;
            p.next = q;
            q = p;
            p = t;
        }
        return q;
    }
}

python

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

class Solution(object):
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        p = head
        q = None
        while p:
            t = p.next
            p.next = q
            q = p
            p = t
        return q

剑指 Offer 25. 合并两个排序的链表

输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。

示例1：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4
限制：

0 <= 链表长度 <= 1000

注意：本题与主站 21 题相同：https://leetcode-cn.com/problems/merge-two-sorted-lists/

通过次数51,372提交次数69,326

在这里插入图片描述

java

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode res = new ListNode(0);
        ListNode p = res;
        while(l1!=null && l2!=null){
            if(l1.val<=l2.val){
                res.next = l1;
                l1 = l1.next;
                
            }
            else{
                res.next = l2;
                l2 = l2.next;
               
            }
            res = res.next;
        }
        if(l1==null && l2!=null){
            res.next = l2;
        }
        if(l1!=null && l2==null){
            res.next = l1;    
        }
        return p.next;
    }
}

python

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

class Solution(object):
    def mergeTwoLists(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        p = ListNode(0)
        res = p
        while l1 and l2:
            if l1.val <= l2.val:
                res.next = l1
                l1 = l1.next
            else:
                res.next = l2
                l2 = l2.next
            res = res.next
        if not l1:
            res.next = l2
        else:
            res.next = l1
        return p.next

剑指 Offer 27. 二叉树的镜像

请完成一个函数，输入一个二叉树，该函数输出它的镜像。在这里插入图片描述
示例 1：

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

在这里插入图片描述

java

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode mirrorTree(TreeNode root) {
        if(root==null) return null;
        TreeNode tmp = mirrorTree(root.left);
        root.left = mirrorTree(root.right);
        root.right = tmp;
        return root;

    }
}

python

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def mirrorTree(self, root):
        """
        :type root: TreeNode
        :rtype: TreeNode
        """
        if not root:
            return 
        tmp = root.left
        root.left = self.mirrorTree(root.right)
        root.right = self.mirrorTree(tmp)
        return root

剑指 Offer 28. 对称的二叉树

请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。
在这里插入图片描述

在这里插入图片描述

java

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root==null){
            return true;
        }else{
            return isS(root.left,root.right);
        }
    }
    boolean isS(TreeNode L,TreeNode R){
            if(L==null && R==null){
                return true;
            }
            if(L==null || R==null || L.val!=R.val){
                return false;
            }
            return isS(L.left,R.right) && isS(L.right,R.left);
        }
}

python

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        def isS(L,R):
            if not L and not R:
                return True
            if not L or not R or L.val!=R.val:
                return False
            return isS(L.left,R.right) and isS(L.right,R.left)

        if not root :
            return True
        return isS(root.left,root.right)

剑指 Offer 29. 顺时针打印矩阵

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。

示例 1：

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]
示例 2：

输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]

限制：

0 <= matrix.length <= 100
0 <= matrix[i].length <= 100

在这里插入图片描述

java

class Solution {
    public int[] spiralOrder(int[][] matrix) {
        if(matrix.length == 0) return new int[0];
        int r = matrix[0].length -1 ;
        int low = matrix.length - 1;
        int l = 0;
        int top = 0;
        int x = 0;
        int[] res = new int[(r + 1) * (low + 1)];

        while(true){
            for(int i=l;i<=r;i++){
                res[x++] = matrix[top][i];
            }
            top++;
            if(top>low) break;
            for(int i = top;i<=low;i++){
                res[x++] = matrix[i][r];
            }
            r--;
            if(l>r) break;
            for(int i = r;i>=l;i--){
                res[x++] = matrix[low][i];
            }
            low--;
            if(top>low) break;
            for(int i = low;i>=top;i--){
                res[x++] = matrix[i][l];
            }
            l++;
            if(l>r) break;


        }
        return res;
    }
}

python

class Solution(object):
    def spiralOrder(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: List[int]
        """
        if not matrix:
            return []
        l = 0
        r = len(matrix[0])-1
        top = 0
        low = len(matrix)-1
        res = []
        while True:
            for i in range(l,r+1):
                res.append(matrix[top][i])
            top = top+1
            if top>low: 
                break
            for i in range(top,low+1):
                res.append(matrix[i][r])
            r = r - 1
            if r<l: 
                break
            for i in range(r,l-1,-1):
                res.append(matrix[low][i])
            low = low - 1 
            if low < top: 
                 break
            for i in range(low,top-1,-1):
                res.append(matrix[i][l])
            l = l + 1
            if l>r: 
                break
        return res

剑指 Offer 30. 包含min函数的栈

定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。

示例:

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.min(); --> 返回 -3.
minStack.pop();
minStack.top(); --> 返回 0.
minStack.min(); --> 返回 -2.

提示：

各函数的调用总次数不超过 20000 次

解题思路：
定义两个队列或者栈，向A压入的时候判断能不能也向B压入，出队列的时候，如果A出入的和B最后一个一样，那么B也出，返回top的时候只用返回A的最后一个，min返回B的最后一个
在这里插入图片描述

java

class MinStack {
    Stack<Integer> A, B;
    /** initialize your data structure here. */
    public MinStack() {
        A = new Stack<>();
        B = new Stack<>();
    }
    
    public void push(int x) {
        A.add(x);
        if(B.empty() || B.peek() >= x){
            B.add(x);
        }
    }
    
    public void pop() {
        if (A.pop().equals(B.peek())){
            B.pop();
        }
    }
    
    public int top() {
        return A.peek();
    }
    
    public int min() {
        return B.peek();
    }
}

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(x);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.min();
 */

python

class MinStack(object):

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.A = []
        self.B = []


    def push(self, x):
        """
        :type x: int
        :rtype: None
        """
        self.A.append(x)
        if not  self.B or self.B[-1]>=x:
            self.B.append(x)


    def pop(self):
        """
        :rtype: None
        """
        if self.A.pop() == self.B[-1]:
            self.B.pop()


    def top(self):
        """
        :rtype: int
        """
        return self.A[-1]

    def min(self):
        """
        :rtype: int
        """
        return self.B[-1]



# Your MinStack object will be instantiated and called as such:
# obj = MinStack()
# obj.push(x)
# obj.pop()
# param_3 = obj.top()
# param_4 = obj.min()