算法问题中的code题目

最新推荐文章于 2024-03-29 17:29:56 发布
最新推荐文章于 2024-03-29 17:29:56 发布
阅读量366 收藏
点赞数
分类专栏： 算法基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/keil_/article/details/87901748
版权

目录

Top K问题

最长公共子串

最长公共子序列

最长递增字串（O(N))

最长无重复子串O(N)

实现sqrt()函数

从数组A中找出所有和为S的两个数的索引

无序数组的中位数  （利用小顶堆）

超过数组个数一半的数

将一个二维的n*n的数组，逆转90度，空间复杂度是O(1)。提示：剥洋葱般，一圈圈的从外向内逆转90度

一个大小为N的数组，里面的值代表的是股价，求一次买入卖出所能够求得最大收益

 

 

Top K问题

#topk 最小
class Solution:
    def find_topk(self, arr, k):
        if len(arr) < k or k < 0:
            return False
        #建立大根堆
        #第一次建立大根堆需要从最后一个非叶子节点开始
        for i in range((k-1)//2, -1, -1):
            self.build_max_head(arr, k, i)
        for j in range(k, len(arr)):
            if arr[j] < arr[0]:
                arr[0] = arr[j]
                self.build_max_head(arr, k, 0)
        for i in range(k-1,-1,-1):
            arr[0], arr[i] = arr[i], arr[0]
            self.build_max_head(arr, i, 0)
        return arr[:k]

    def build_max_head(self, arr, length, root):
        max = root
        left = root*2 + 1
        right = left + 1
        if left < length and arr[left] > arr[max]:
            max = left
        if right < length and arr[right] > arr[max]:
            max = right
        if max != root:
            arr[max], arr[root] = arr[root], arr[max]
            self.build_max_head(arr, length, max)

re = Solution().find_topk([3,4,6,7,8,1,2], 4)
print(re)

最长公共子串

# coding:utf-8
'''
求两个字符串的最长公共子串
思想：建立一个二维数组，保存连续位相同与否的状态
'''
 
def getNumofCommonSubstr(str1, str2):
 
    lstr1 = len(str1)
    lstr2 = len(str2)
    record = [[0 for i in range(lstr2+1)] for j in range(lstr1+1)]  # 多一位
    maxNum = 0          # 最长匹配长度
    p = 0               # 匹配的起始位
 
    for i in range(lstr1):
        for j in range(lstr2):
            if str1[i] == str2[j]:
                # 相同则累加
                record[i+1][j+1] = record[i][j] + 1
                if record[i+1][j+1] > maxNum:
                    # 获取最大匹配长度
                    maxNum = record[i+1][j+1]
                    # 记录最大匹配长度的终止位置
                    p = i + 1
    return str1[p-maxNum:p], maxNum
 
 
if __name__ == '__main__':
    str1 = 'abcdef'
    str2 = 'ydufdsbhgcdeftyh'
 
    res = getNumofCommonSubstr(str1, str2)
    print(res)

最长公共子序列

import numpy

def find_lcseque(s1, s2): 
	 # 生成字符串长度加1的0矩阵，m用来保存对应位置匹配的结果
	m = [ [ 0 for x in range(len(s2)+1) ] for y in range(len(s1)+1) ] 
	# d用来记录转移方向
	d = [ [ None for x in range(len(s2)+1) ] for y in range(len(s1)+1) ] 
 
	for p1 in range(len(s1)): 
		for p2 in range(len(s2)): 
			if s1[p1] == s2[p2]:            #字符匹配成功，则该位置的值为左上方的值加1
				m[p1+1][p2+1] = m[p1][p2]+1
				d[p1+1][p2+1] = 'ok'          
			elif m[p1+1][p2] > m[p1][p2+1]:  #左值大于上值，则该位置的值为左值，并标记回溯时的方向
				m[p1+1][p2+1] = m[p1+1][p2] 
				d[p1+1][p2+1] = 'left'          
			else:                           #上值大于左值，则该位置的值为上值，并标记方向up
				m[p1+1][p2+1] = m[p1][p2+1]   
				d[p1+1][p2+1] = 'up'         
	(p1, p2) = (len(s1), len(s2)) 
	print(numpy.array(d))
	s = [] 
	while m[p1][p2]:    #不为None时
		c = d[p1][p2]
		if c == 'ok':   #匹配成功，插入该字符，并向左上角找下一个
			s.append(s1[p1-1])
			p1-=1
			p2-=1 
		if c =='left':  #根据标记，向左找下一个
			p2 -= 1
		if c == 'up':   #根据标记，向上找下一个
			p1 -= 1
	s.reverse() 
	return ''.join(s) 
 
print(find_lcseque('bcdfg','abdfgh'))

最长递增字串（O(N))

'''
最长连续递增子序列
dp[i]以nums[i]结尾的最长递增子序列的长度
if nums[i] > nums[j], 说明nums[i]能缀到nums[j]后面，
那么dp[i]就能+1了
dp[i+1] = max(dp[i + 1], dp[j] + 1)
'''
 
 
def length_of_lis(nums):
    len_nums = len(nums)
    if len_nums == 0:
        return 0
 
    dp = [1] * len_nums
    for i in range(len_nums - 1):
        for j in range(i + 1):
            # 如果nums[i+1]能缀在nums[j]后面的话，就dp[j]+1
            if nums[i + 1] > nums[j]:
                # 缀完的结果还要看看是不是比我大
                dp[i + 1] = max(dp[i + 1], dp[j] + 1)
    return max(dp)
 
 
if __name__ == '__main__':
    nums = [10, 9, 2, 5, 3, 7, 101, 18]
    res = length_of_lis(nums)
    print(res)

最长无重复子串O(N)

def lengthOfLongestSubstring(s):
        # write your code here
        res = 0
        if s is None or len(s) == 0:
            return res
        d = {}
        tmp = 0
        start = 0
        for i in range(len(s)):
            if s[i] in d and d[s[i]] >= start:
                start = d[s[i]] + 1
            tmp = i - start + 1
            d[s[i]] = i
            res = max(res, tmp)
        return res

print(lengthOfLongestSubstring('abcabcbc'))

实现sqrt()函数

  • 二分法
def sqrt_binary(x):
    low = 0
    high = max(1, x)
    guess = (low + high)/2
    count = 1
    while abs(guess**2 - x) > 0.000000001 and count < 100:
        if guess**2 < x:
            low = guess
        else:
            high = guess
        guess = (low + high) / 2
        count += 1
    return guess
  • 牛顿迭代法：

         原理：https://blog.csdn.net/ccnt_2012/article/details/81837154

         code：https://blog.csdn.net/Everywhere_wwx/article/details/80254286

class Solution(object):
    def mySqrt(self, x):
        """
        :type x: int
        :rtype: int
        """
        re = 1.0
        while abs(re*re - x)abs > 0.0001:
            re = (re + x/re)/2
        return int(re)

从数组A中找出所有和为S的两个数的索引

  • 先快排，前后两指针和查找 O(NlogN)
def getres(nums, target):
    num = sorted(nums)
    low, high = 0, len(nums)-1
    res = []
    while low < high:
        if num[low] + num[high] == target:
            res.append((num[low], num[high]))
            low += 1
            high -=1
        elif num[low] + num[high] < target:
            low += 1
        else:
            high -= 1
    return res

print(getres([1, 4, 3, 2, 6 ,5], 6))
  • 哈希思想O(N)
# 哈希表思想
def getRes_HashMap(nums, target):
    result = []
    for i, value in enumerate(nums):
        if (target - value) in nums[i+1:]:
            result.append((value, target - value))
    return result

print(getRes_HashMap([1, 4, 3, 2, 6 ,5], 6))

无序数组的中位数  （利用小顶堆）

def heap_adjust(parent,heap):   #更新结点后进行调整
    child=2*parent+1
    while len(heap)>child:
        if child+1<len(heap) and heap[child+1]<heap[child]:
            child+=1
        if heap[parent]<=heap[child]:
            break
        heap[parent],heap[child]=heap[child],heap[parent]
        parent,child=child,child*2+1
 
def find(nums):
    k=len(nums)//2 +1
    heap=nums[:k]
    for i in range(k,-1,-1):   #前n/2个元素建堆
        heap_adjust(i,heap)
    for j in range(k,len(nums)):
        if nums[j]>heap[0]:
            heap[0]=nums[j]
            heap_adjust(0,heap)
    #奇数时是最中间的数，偶数时是最中间两数的均值
    return heap[0] if len(nums)%2==1 else float(heap[0]+min(heap[1],heap[2]))/2
 
print(find([1,2,8,9,3,5,4,6,7,0]))
print(find([4,5,3,7,2,6,1]))

超过数组个数一半的数

def Morethanhalfnum(nums):
    l1 = len(nums)
    if l1 <= 1:
        return nums
    a, b = nums[0], 1
    for i in range(1, l1):
        if a == nums[i]:
            b += 1
        elif b == 0:
            a = nums[i]
            b += 1
        else:
            b -= 1
    count = 0
    for j in range(l1):
        if nums[j] == a:
            count += 1
    if count>l1/2:
        return a
    else:
        return 0

print(Morethanhalfnum([1,2,3,2,2,2,5,4,2]))

将一个二维的n*n的数组，逆转90度，空间复杂度是O(1)。提示：剥洋葱般，一圈圈的从外向内逆转90度

data=[[i for i in range(4)] for raw in range(4)]
for ele in data:
    print(ele)

a=len(data)
for i in range(a):#外层循环
    for j in range(i+1,len(data[i])): #内层循环
        #交换数据
        temp=data[i][j]
        data[i][j]=data[j][i]
        data[j][i]=temp
        
for ele in data:
    print(ele)

一个大小为N的数组，里面的值代表的是股价，求一次买入卖出所能够求得最大收益

def best_time(nums):
    l1 = len(nums)
    if l1 == 1:
        return 0
    max = 0
    min = nums[0]
    for i in range(l1):
        if nums[i] < min:
            min = nums[i]
        elif max < nums[i]-min:
            max = nums[i] - min
    return max

in_nums = [7,1,5,3,6,4]

print(best_time(in_nums))

二叉树遍历

前序

# 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 __init__(self):
        self.res = []
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        # if not root:
        #     return None
        # self.res.append(root.val)
        # self.preorderTraversal(root.left)
        # self.preorderTraversal(root.right)
        # return self.res
        res, stack = [], []
        if root:
            stack.append(root)
        while stack:
            node = stack.pop()
            res.append(node.val)
            if node.right:
                stack.append(node.right)
            if node.left:
                stack.append(node.left)
        return res

中序

# 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 __init__(self):
        self.res = []
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return None
        # self.inorderTraversal(root.left)
        # self.res.append(root.val)
        # self.inorderTraversal(root.right)
        # return self.res
        stack, node = [], root
        res = []
        while stack or node:
            while node:
                stack.append(node)
                node = node.left
            node = stack.pop()
            res.append(node.val)
            node = node.right
        return res

后序

# 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 __init__(self):
        self.res = []
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return None
        # self.postorderTraversal(root.left)
        # self.postorderTraversal(root.right)
        # self.res.append(root.val)
        # return self.res
        stack, res = [root], []
        while stack:
            node = stack.pop()
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
            res.append(node.val)
        return res[::-1]

层次遍历

# 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 levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        levels = []
        if not root:
            return levels
        
        def everylevel(root, level):
            if len(levels) == level:
                levels.append([])
            levels[level].append(root.val)
            if root.left:
                everylevel(root.left, level+1)
            if root.right:
                everylevel(root.right, level+1)
        everylevel(root,0)
        return levels

链表快排

作者：算法才是灵魂
链接：https://www.nowcoder.com/discuss/220011?type=0&order=0&pos=51&page=1
来源：牛客网

class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None
 
class Solution:
    def sortList(self, head: ListNode) -> ListNode:
        if head == None or head.next == None:
            return head
        leftH = ListNode(0)
        resL = leftH
        rightH = ListNode(0)
        resR = rightH
        midNode = head
        head = head.next
        while head != None:
            if head.val < midNode.val:
                leftH.next = head
                leftH = leftH.next
            else:
                rightH.next = head
                rightH =rightH.next
            head = head.next
        leftH.next = None
        rightH.next = None
        L = self.sortList(resL.next)
        R = self.sortList(resR.next)
        midNode.next = R
        if L == None:
            return midNode
        tmp = L
        while tmp.next != None:
            tmp = tmp.next
        tmp.next = midNode
        return L

 

管妖妖
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
code_算法python_
10-04
标题中的"code_算法python_"表明我们关注的焦点是使用Python语言解决算法问题。描述中提到的"求解数组中同时满足行最小值和列最大值"是一个典型的矩阵操作问题，可能涉及到数据处理和优化算法。 在编程领域，尤其是...
经典算法题收集一
小仙儿
04-30 2608
约瑟夫环问题
76. 最小覆盖子串 滑动窗口
qq_45638271的博客
07-20 492
给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 “” 。 注意： 对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。 如果 s 中存在这样的子串，我们保证它是唯一的答案。 示例 1： 输入：s = “ADOBECODEBANC”, t = “ABC” 输出：“BANC” 示例 2： 输入：s = “a”, t = “a” 输出：“a” 示例 3: 输入: s = “a”, t = “
29道面试基础算法题，试试看会不会
Android茶话会
05-25 7464
本文主要整理了一些面试常见的算法题，涵盖 数组、字符串、哈希表、链表、二叉树。
经典的10个常见的算法问题及(java、python)代码示例，你知多少，卷起来吧
qq_28245087的博客
06-23 3121
以下是10道算法题，包括斐波那契数列、回文字符串、冒泡排序、找到数组中的最大值和最小值、二叉树的深度、字符串中出现次数最多的字符、快速排序、找到数组中两个数的和等于目标值、堆排序以及二叉树的前序遍历、中序遍历和后序遍历。在Python中，使用递归的方式实现三种遍历，分别将遍历的结果存储在。这两个函数都接受一个整数数组和一个目标值参数，并返回数组中两个数的索引，使得这两个数的和等于目标值。，使用字典（dictionary）记录已经遍历过的数和它们的索引，以便在后面的遍历中查找目标数的补数。
2020最新-精选基础算法100题（面试必备）
热门推荐
ATFWUS的博客
05-18 28万+
0x01.概述 作为一个程序员，算法能力必不可少，虽然不一定是算法工程师，但是算法还是彰显着个人的编码能力，面试中也经常会被问到，甚至会被要求临场做算法题，所以，还是好好积累吧。 个人其实对算法挺有兴趣的，从3月份开始，陆陆续续刷了一些算法题，把一些有意义的记录下来了，也顺便写了一些题解，个人认为，还是挺有收获的。 之前写了一篇算法文章的目录，不过后来就忘了实时去更新了，于是现在，想把之前做过的一些有意义的算法题分享出来，刚好整理了100篇比较有意义的。希望对大家有所帮助。 0x02.说明 关
2017年华为算法比赛题目
11-29
在《HUAWEI_Code_Craft_2017_Preliminary_Contest_Question_en_v1.3.zip》和《HUAWEI_Code_Craft_2017_Preliminary_Contest_Question_zh_v1.3.zip》这两个压缩包中，包含了比赛的初步竞赛题目。这些题目可能涵盖数据...
Algorithms:记录算法学习的一些题目和code
04-30
在IT行业中，算法是解决问题和优化程序的核心工具。"Algorithms:记录算法学习的一些题目和code"这个项目显然是为了帮助学习者系统地整理和实践算法知识，特别关注Java语言的实现。下面，我们将深入探讨算法的基本...
code.dennyzhang.com：算法和编码问题
01-29
在code.dennyzhang.com中，你可能会发现针对LeetCode题目的解题策略和代码示例，这些可以帮助你在实际编程挑战中积累经验，提高解决问题的能力。 "AlgorithmCSS"可能是指使用CSS（层叠样式表）来实现特定的算法或...
基于C语言中的一些算法和面试题
03-29
在IT领域，C语言作为一门基础且强大的..."Notes_of_C-code"文件很可能是包含这些问题的详细解答和示例代码，对于学习和复习C语言算法及面试题非常有帮助。建议读者结合此资源进行深入研究，不断巩固和提升自己的能力。
算法题汇总
qq_24095055的博客
08-09 1627
算法
一些算法问题
星尘逸风的博客
09-30 1026
算法是比较复杂又基础的学科，每个学编程的人都会学习大量的算法。而根据统计，以下这18个问题是面试中最容易遇到的 1、请简单解释算法是什么? ·——算法是一个定义良好的计算过程，它将一些值作为输入并产生相应的输出值。简单来说，它是将输入转换为输出的一系列计算步骤。 算法就是用数学量化思维来解决现实中的问题，本质上是在输入输出中间的过程，将待处理.分析数据通过算法得到目标result 2、解释什么是快...
常见的算法问题
weixin_33953249的博客
06-25 2532
主要算法题目录如下，可能题目有重复，欢迎大家与我交流！ 一、贪心算法 Problem1删数问题　　【解题报告】 Problem2旅行家的预算 Problem3线段覆盖 Problem4背包问题 Problem5任务调度 Problem6果子合并 Problem7射击竞赛 Problem8任务安排 Problem9最小差距 二、分治算法 Problem1一元三次方程的解 P...
数据结构与算法：8种算法经典问题
分享计算机基础，android，C/C++，音视频等内容
07-21 1303
本文主要讲解8种算法经典问题
算法基础（一）（共有25道例题，大多数为简单题）
mabaizi的博客
02-25 2275
此为基础篇的（一）
【算法】基础算法中的十大经典问题（视频笔记）
Java
09-15 1936
/** * 分治算法：汉诺塔 */ public class Hannoitower { public static void main(String[] args) { hannoitower(3,'A','B','C'); } /** * 递归汉诺塔 * @param num 盘得个数 * @param a 代表 a塔 * @param b 代表 b塔 * @param c 代表 c塔 */
150道基础算法分类总结（2022）
小朱小朱绝不认输的博客
03-02 3017
在刷了一部分leetcode算法题之后，想要回头系统复习一下，发现刷的比较乱，特此整理一下，方便后续二刷，主要是对各种类型算法的一个分类，以及比较典型的题目的整理。 学习说明 题目来源lettcode 参考代码是用Java写的 供自己方便学习 算法分类 1. 二叉树 树也是一种非常重要的数据结构，因为很多容器的底层都设计到树，所以树也成了面试常问的重点了。特别是二叉树及二叉搜索树的算法。 二叉树的考点 题目来源 扩展 题解参考 二叉树的遍历（递归和迭代实现） 102. 二叉树的层序遍历
经典算法题汇总
qq_36696761的博客
09-14 5953
算法题经典汇总 1. 判断一颗二叉树是否为二叉搜索树和完全二叉树 // 二叉搜索树：每个节点左边节点小于右边节点，左子树的最大值一定小于根节点，小于右子树的最大值；通过中序遍历，严格递增 // 完全二叉树：层序遍历，除了最后的一层，每层都是满的。采用层序遍历，一旦出现null，则队列中剩余的节点必须为叶子节点 import java.util.*; /* * public class TreeNode { * int val = 0; * TreeNo...
必会的10个经典算法题(附解析答案代码Java/C/Python看这一篇就够)
最新发布
03-29 438
常见的数据结构与算法题目，涵盖了数组、链表、栈、队列、二叉树、哈希表、字符串、图、排序和查找等方面的考察点。每个题目都附带有LeetCode的链接，可以点击链接了解更多题目详情。
算法设计经典问题集：代码实现与解析
算法设计与分析经典问题源代码涵盖了多个挑战性的编程题目，这些题目涉及了计算机科学中的多种核心概念和策略。以下是一些关键知识点的详细解析： 1. **N皇后问题**（包括八皇后问题扩展）：这是著名的回溯法示例，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值