【复习】剑指offer(11-20)

最新推荐文章于 2023-03-12 21:06:36 发布

原创最新推荐文章于 2023-03-12 21:06:36 发布 · 185 阅读

0 ·

CC 4.0 BY-SA版权

数据结构与算法专栏收录该内容

22 篇文章

订阅专栏

博客介绍了多个常见算法问题，包括二进制中1的个数、数值的整数次方、调整数组顺序、链表操作、树的子结构判断、二叉树镜像变换、矩阵打印以及含min函数的栈等，还给出了各问题的输入输出要求。

11 二进制中1的个数

输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

# -*- coding:utf-8 -*-
import sys
class Solution:
    def NumberOf1(self, n):
        # write code here
        count=0
        n=int(n)
        if n<0:
            n= n & 0xffffffff
        while n:
                n=(n-1)& n
                count+=1
        return count

12 数值的整数次方

给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

# -*- coding:utf-8 -*-
class Solution:
    def Power(self, base, exponent):
        # write code here
        return base**exponent

13 调整数组顺序使奇数位于偶数前面

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

# -*- coding:utf-8 -*-
class Solution:
    def reOrderArray(self, array):
        # write code here
        arr=array
        n=len(arr)
        ord,even=[],[]
        #n=len(arr)
        for i in range(n):
            if arr[i]%2==1:
                ord.append(arr[i])
            else:
                even.append(arr[i])
        return ord+even

14 链表中倒数第k个结点

输入一个链表，输出该链表中倒数第k个结点。

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def FindKthToTail(self, head, k):
        # write code here
        l=[]
        current=head
        while current!=None:
            l.append(current)
            current=current.next
        if  k>len(l) or k<1:
            return
        return l[-k]

15 反转链表

输入一个链表，反转链表后，输出新链表的表头。

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    # 返回ListNode
    def ReverseList(self, pHead):
        # write code here
        if not pHead or not pHead.next:
            return pHead
        last=None
        while pHead:
            temp=pHead.next
            pHead.next=last
            last=pHead
            pHead=temp
        return last

16 合并两个排序的链表

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    # 返回合并后列表
    def Merge(self, pHead1, pHead2):
        # write code here
        mergeHead=ListNode(1)
        p=mergeHead
        while pHead1 and pHead2:
            if pHead1.val >=pHead2.val:
                mergeHead.next=pHead2
                pHead2=pHead2.next
            else:
                mergeHead.next=pHead1
                pHead1=pHead1.next
            mergeHead=mergeHead.next
        if pHead1:
                mergeHead.next=pHead1
        elif pHead2:
                mergeHead.next=pHead2
        return p.next

17 树的子结构

输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def HasSubtree(self, pRoot1, pRoot2):
        # write code here
        if not pRoot1  or not pRoot2 :
            return False
        return self.is_subtree(pRoot1,pRoot2) or self.HasSubtree(pRoot1.left,pRoot2) or self.HasSubtree(pRoot1.right,pRoot2)

    def is_subtree(self,pRoot1,pRoot2):
        if not pRoot2:
            return True
        if not pRoot1 or pRoot1.val!= pRoot2.val:
            return False
        return self.is_subtree(pRoot1.left,pRoot2.left) and self.is_subtree(pRoot1.right,pR

18 二叉树的镜像

操作给定的二叉树，将其变换为源二叉树的镜像。

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回镜像树的根节点
    def Mirror(self, root):
        # write code here
        if not root:
            return None
        else:
            root.left,root.right=root.right,root.left
        self.Mirror(root.left)
        self.Mirror(root.right)

19 顺时针打印矩阵

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

# -*- coding:utf-8 -*-
class Solution:
    # matrix类型为二维列表，需要返回列表
    def printMatrix(self, matrix):
        # write code here
        res=[]
        n=len(matrix) #行数
        m=len(matrix[0]) #列数
        if n==1 and m==1:
            res=[matrix[0][0]]
            return res
        for i in range(min(n,m)+1//2):
            [res.append(matrix[i][j]) for j in range(i,m-i) if matrix[i][j] not in res]
            [res.append(matrix[k][m-1-i]) for k in range(i,n-i) if matrix[k][m-1-i] not in res]
            [res.append(matrix[n-i-1][l]) for l in range(m-i-1,i-1,-1) if matrix[n-i-1][l] not in res]
            [res.append(matrix[q][i]) for q in range(n-i-1,i-1,-1)if matrix[q][i] not in res]
        return res

20 包含min函数的栈

定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。

# -*- coding:utf-8 -*-
class Solution:
    def __init__(self):
        self.stack=[]
        self.min_stack=[]
    def push(self, node):
        # write code here
        self.stack.append(node)
        if not self.min_stack or node <= self.min_stack[-1]:
            self.min_stack.append(node)
    def pop(self):
        # write code here
        if self.min_stack[-1]== self.stack[-1]:
            self.min_stack.pop()
        self.stack.pop()
    def top(self):
        # write code here
        return self.stack[-1]
    def min(self):
        # write code here
        return self.min_stack[-1]