qq_40146935的博客

原创 旋转出最小的数字

class Solution: def minArray(self, numbers: List[int]) -> int: temp = numbers[0] for i in range(len(numbers)): if temp > numbers[i]: temp = numbers[i] return temp

原创 求1-n的和

1、递归2、迭代3、逻辑递归法class Solution: def sumNums(self, n: int) -> int: if n < 1: return 0 return n + self.sumNums(n - 1)s = Solution()print(s.sumNums(5))def sumNums(n): if n == 1: return 1 n += sumNums(n - 1

原创 从尾到头打印链表

class Node(): def __init__(self,data): self.data = data self.next = Noneclass stack(): def __init__(self): self.slist = [] def add(self,data): self.slist.append(data) def popdata(self): return self.

原创 链表中倒数第k个结点

#思路：遍历整个链表，把链表中的元素放在列表中，索引第n-k个元素class Node(): def __init__(self,data): self.data = data self.next = Noneclass singleList(): def __init__(self): self._head = None # 尾插法建立列表 def append(self,data): if self._

原创 二维元素中元素的查找

# 从右上角开始查找def func(target,matrix): rows = len(matrix) cols = len(matrix[0]) x = 0 y = cols - 1 while x < rows and y >= 0: if target == matrix[x][y]: return True elif target < matrix[x][y]: .

原创 查找k个最小的数

使用冒泡排序def find_num(nums,k): for i in range(len(nums)): for j in range(len(nums)-1): if nums[j] >nums[j+1]: nums[j],nums[j+1]=nums[j+1],nums[j] return nums[:k]nums = [2,6,3,1]print(find_num(nums, 2))...

原创 查找重复的数字

from typing import Listclass Solution: def findRepeatNumber1(self, nums: List[int]) -> int: """ """ dic = set() for val in nums: if val in dic: print(val) dic.add(val) # retur

原创 和为s的正整数序列

from typing import Listdef findContinuousSequence(target: int) -> List[List[int]]: i = 1 # 滑动窗口的左边界 j = 1 # 滑动窗口的右边界 sum = 0 # 滑动窗口中数字的和 res = [] while i <= target // 2: if sum < target: # 右边界向右移动

原创 DFS

graph = { "A":["B","C"], "B":["A","C","D"], "C":["A","B","D","E"], "D":["B","C","E","F"], "E":["C","D"], "F":["D"],}def DFS(graph,s): stack = [] stack.append(s) seen = set() # 集合 seen.add(s) while (len(stack)&g

原创 BFS算法

BFSgraph = { "A":["B","C"], "B":["A","C","D"], "C":["A","B","D","E"], "D":["B","C","E","F"], "E":["C","D"], "F":["D"],}def BFS(graph,s): queue = [] queue.append(s) seen = set() # 集合 seen.add(s) while (len(queu

原创 四边形面积

n = int(input("请输入一个整数"))a = input().split(" ")length = [int(a[i]) for i in range(n)]dict1 = {}for i in range(n): dict1[length[i]] = length .count(length[i])a=sorted(dict1.items(),key=lambda item:item[0],reverse= True)print(a)tem=[]for j in

原创 无重复字符子串

无重复字符子串def substring(s): # 哈希集合，记录每个字符是否出现过 occ = set() n = len(s) # 右指针，初始值为-1，相当于字符串的左边界的左侧，还没开始移动 rk ,ans = -1,0 for i in range(n): if i !=0: # 左指针向右移动一格，移除前一个字符 occ.remove(s[i-1]) while r

原创 全排列

from typing import Listclass Solution: def permuteUnique(self, nums: List[int]) -> List[List[int]]: # 第一次调用i= 0,二次调用i =1 三次调用i = 2 def dfs(nums, size, depth, path, used, res): if depth == size: res.append(path.

原创 双指针

class Solution: def removeDuplicates(self, nums: List[int]) -> int: left = 0 right = 1 for i in range(len(nums)): if nums[left] == nums[right]: right +=1 else: left +=1

原创 反转链表

class Node(): def __init__(self,data): self.data = data self.next = Noneclass List(): def __init__(self): self._head = None # 尾插法插入元素 def append(self, data): # 在单链表后插入元素，需要一个指针遍历到最后一个结点 p = sel

原创 实现NMS算法

# python3import numpy as npdef py_nms(dets, thresh): """Pure Python NMS baseline.""" #x1、y1、x2、y2、以及score赋值 x1 = dets[:, 0] y1 = dets[:, 1] x2 = dets[:, 2] y2 = dets[:, 3] scores = dets[:, 4] # print(scores) #每一个候选框的

原创 字符串匹配

class Solution: def isValid(self, s: str) -> bool: if len(s) % 2 == 1: return False pairs = { ")": "(", "]": "[", "}": "{", } stack = list() # 建立一个顺序栈 for ch in

原创 算法day3

class Solution: def climbStairs(self, n: int) -> int: dp = [0 for _ in range(n+1)] dp[1] = 1 # 到第一台阶有多少种方法 dp[2] = 2 # 到第二台阶有多少种方法 for i in range(3,n+1): dp[i] = dp[i-1] + dp[i-2] # 到第i个状态的方法数量

原创 算法day3

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。示例输入: 123输出: 321输入: -123输出: -321输入: 120输出: 21class Solution: def reverse(self, x: int) -> int: str_x = str(x) if str_x[0] == "-": x = int(" - " + str_x[1:][::-1]) else:

原创 循环列表

# 实现一个顺序循环队列class LOOP_Queue(): def __init__(self,Maxsize=6): # M是分配空间的大小 self.queue = [None]*6 self.Maxsize = Maxsize self.front = 0 self.rear = 0 def enqueque(self,data):#入队 if (self.rear + 1)% self.Maxsi

原创 链栈

# 使用顺序栈实现十进制转换成其他进制操作class Node(): # 结点类 def __init__(self,data): self.data = data self.next = Noneclass ListStack(): def __init__(self):# 初始化空栈 self._top = None def is_empty(self): if self._top == None:

原创 顺序栈实现进制转换

# 使用顺序栈实现十进制转换成其他进制操作class sstack(): def __init__(self): # 初始化一个空栈 self.slist= [] def is_empty(self):# 判断栈是否为空 if self.slist == []: return 1 else: return 0 def pushstack(self,data): # 入栈

原创 链队列

原创 循环队列

原创 栈的应用

原创 顺序栈和链栈的基本操作

原创 栈的定义和特点

原创 栈和队列的特点

原创 单链表

# head->10->20->30->40# 创建结点class Node(): #结点类 def __init__(self,data): self.data=data self.next = None# 创建单链表class Singlelinklist(): def __init__(self): self._head = None def is_empty(self): if

原创 # 用列表实现顺序表的基本操做

# 用列表实现顺序表的基本操做class seqlist(): def __init__(self,max_space=30): self.max_space = max_space #max_space最大分配空间 self.sl = max_space*[0] # 申请一个列表 self.length = 0 # 记录实际元素的个数 def appenddata(self,data):#追加元素data if self.

原创 链表合并

不改变原列表

原创 顺序表合并

def merge(l1,l2,l3): i = 0 j = 0 while i<len(l1) and j<len(l2): if l1[i] <= l2[j]: l3.append(l1[i]) i+=1 else: l3.append(l2[j]) j+=1 if i>=len(l1): l3.ext..

原创 线性结构链表

原创 线性结构顺序表

保证了物理上的相邻关系，体现逻辑上的前驱后继关系

原创 算法day2

题目 合并两个有序列表def merge_list(list1,list2): result = [] while list1 and list2: if list1[0] <= list2[0]: result.append(list1[0]) del list1[0] else: result.append(list2[0]) del list2[0

原创 面经day1

1.smooth L1为什么有效优点：更强的鲁棒性

原创 算法Day1

冒泡排序def bubble_sort(our_list): n = len(our_list) sortBorder = n - 1 # 无序数列边界 for i in range(n): for j in range(0,sortBorder): # 索引 后边有j+1 if our_list[j] > our_list[j+1]: our_list[j],our_list[j+1] =

原创 目标检测（标注数据读取与存储）

应用：使用XML工具进行标签数据读取与存储