算法题训练（1）

最新推荐文章于 2022-07-27 22:33:04 发布

原创最新推荐文章于 2022-07-27 22:33:04 发布 · 357 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法题学习记录

学习笔记专栏收录该内容

33 篇文章

订阅专栏

第一题：二维数组中的查找

题目：在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
算法思想：矩阵是有序的，从左往右依次递增，从上往下依次递增，那么我们取左下角的数开始进行查找，如果该整数大于该值，则右移，如果该整数小于该值，则上移；若找到该值，则返回True，否则返回False。
算法代码如下：

def Find(target,arry):
    hang = len(arry)-1
    lie = len(arry[0])-1
    i = hang
    j = 0
    while j<=lie and i>=0:
        if target<arry[i][j]:
            i-=1
        elif target>arry[i][j]:
            j+=1
        else:
            return True
    return False


a  = Find(4,[[1,2,3],[4,5,6],[7,8,9]])
print(a)
#结果：True

第二题：从尾到头打印链表

题目：输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。
算法思想：输入一个链表，定义一个栈，将链表中的结点依次存入该栈中，当所有的结点都存入栈中，则开始出栈，满足后进先出的条件，则可成功实现链表的倒序。
算法代码如下：

class Solution:
    # 返回从尾部到头部的列表值序列，例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        res = []
        while listNode:
            res.append(listNode.val)
            listNode = listNode.next
        return res[::-1]

第三题：重建二叉树

题目：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
算法思想：首先我们根据前序遍历能够知道根节点，也能够通过pop（）知道根节点在中序遍历中的位置，通过中序遍历的根节点，从而将根的两边分为了左子树和右子树，根据这种思想，进行递归，首先我们得判断该二叉树是否为空，通过len（）即可得知。
算法代码如下：

class Solution:
    # 返回构造的TreeNode根节点
    def reConstructBinaryTree(self, pre, tin):
        # write code here
        if len(pre) == 0:
            return None
        root = TreeNode(pre[0])
        index = tin.index(root.val)
        root.left = self.reConstructBinaryTree(pre[1:index+1],tin[:index])
        root.right = self.reConstructBinaryTree(pre[index+1:],tin[index+1:])
        return root

第四题：两数之和

题目：给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。
例如：Given nums = [2, 7, 11, 15], target = 9,
Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].
算法思想：我们可以通过差值来解决，首先我们通过len（）得到数组的长度，接着遍历我们给定的数组，然后用我们的目标值依次减去数组中的此时遍历的数，然后判断差值是否在存在于数组中，如果有，则将该数的索引值赋给y，如果y的值不等于遍历数组此时的x值，则返回x，y值，即为两个数的索引值。
算法代码如下：

class Solution:
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """       
        n = len(nums)
        for x in range(n):
            b = target-nums[x]
            if b in nums:
                y = nums.index(b)
                if y!=x:
                    return x,y

a = Solution()
sum = a.twoSum([3,4,5],9)
print(sum)
#运行结果：（1，2）

第五题：用两个栈实现队列

题目：用两个栈来实现一个队列，完成队列的Push和Pop操作。队列中的元素为int类型。
算法思路：首先我们定义两个栈，将数组中的元素依次入栈A，然后将栈A中的所有元素出栈进入栈B，最后将栈B中的元素出栈，即可实现队列的先进先出。
算法代码如下：

# -*- coding:utf-8 -*-
class Solution:
    def __init__(self):
        self.stackA = []
        self.stackB = []
    def push(self, node):
        self.stackA.append(node)
        
        # write code here
    def pop(self):
        if len(self.stackB)!=0:
            return self.stackB.pop()
        else:
            while len(self.stackA)>1:
                self.stackB.append(self.stackA.pop())
            return self.stackA.pop()

第六题：跳台阶

题目：一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
算法思路：设跳法的总数为x，首先我们进行举例，当n = 1时，x为1，当n = 2时，x为2，当n = 3时，x为3，当n=4时，x为5，由此可见我们可以看出这是一个斐波那契数列的规律，所有我们可以通过斐波那契数列的方法来计算得到x。
算法代码如下：

class Solution:
    def jumpFloor(self, number):
        # write code here
        a,b = 0,1
        for i in range(number+1):
        	a,b = b,a+b
        return a

第七题：二进制中1的个数

题目：输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
算法思路：针对Python语言，有投机取巧的方法，因为python封装了很多内置函数，所有我们可以直接用轮子，比如十进制转换成二进制，我们可以用bin（），比如计算1出现的个数，我们可以用count（），针对负数，我们需要将其变成补码，补码是除符号位，其余所有的1变为0，0变为1，然后末尾加1，所以我们可以用到2**32+这个负数，计算机系统一般是用到32位，但其实这个是根据python版本来决定的。
算法代码如下：

# -*- coding:utf-8 -*-
class Solution:
    def NumberOf1(self, n):
        return bin(n).replace("0b","").count("1") if n>=0 else bin(2**32+n).replace("0b","").count("1")

第八题：链表中的倒数第k个结点

题目：输入一个链表，输出该链表中倒数第k个结点。
算法思路：Python中的List相当于一个顺序表，我们通过遍历链表，从头结点开始存入，然后用指针指向next结点，然后继续存入到List中，当我们需要输出链表的倒数第k个结点，那么我们通过List的[-k]就可以得到了。
算法代码如下：

class Solution:
    def FindKthToTail(self, head, k):
        res = []
        while head:
            res.append(head)
            head = head.next
        if k>len(res) or k<1:
            return None
        return res[-k]

第九题：反转链表

题目：输入一个链表，反转链表后，输出新链表的表头。
算法思路： pHead始终指向要反转的结点，last指向反转后的首结点，每一次反转结点，把pHead结点的next指向last，last指向pHead成为反转后的首结点，再把pHead向前移动一个结点直到None结束。
算法代码如下：

class Solution:
    def ReverseList(self,pHead):
        if not pHead or not pHead.next:
            return pHead

        last = None
        while pHead:
            tmp = pHead.next
            pHead.next = last
            last = pHead
            pHead = tmp
        return last

第十题：合并两个排序的链表

题目：输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
算法思路：首先我们将两个指针位于链表的首结点处，比较两个链表的首结点，小的结点作为新链表的尾节点处，然后把小结点所在链表的指针向前移动一步，继续和另外一条链表的指针所在的位置比较，小的结点继续添加到新链表尾节点的next位置，依次迭代，直到其中一条链表为空，则遍历另外一条链表，依次添加到新链表上。
算法代码如下：

class Solution:
	def Merge(self,pHead1,pHead2):
		dummy = ListNode(0)
		pHead = dummy
		while pHead1 and pHead2:
			if pHead1.val >= pHead2.val:
				dummy.next = pHead2
				pHead2 = pHead2.next
			else:
				dummy.next = pHead1
				pHead1 = pHead1.next
			dummy = dummy.next
		if pHead1:
			dummy.next = pHead1
		elif pHead2:
			dummy.next = pHead2
		return pHead.next