算法题汇总

数据结构算法视频：https://www.bilibili.com/video/BV17J411i7zS?p=45

 

1、冒泡排序

 1 def bubble_sort(li):
 2     n = len(li)
 3     # 遍历列表长度减1次
 4     for i in range(1, n):
 5         # 创建一个变量，用来记录本轮冒泡，是否有数据交换位置
 6         status = False
 7         # 每次遍历都获取第一个元素，依次和后面的元素进行比较
 8         for j in range(n - i):
 9             # 判断前元素，和后一个元素的值
10             if li[j] > li[j + 1]:
11                 # 交换当前元素和后一个元素的值
12                 li[j], li[j + 1] = li[j + 1], li[j]
13                 # 只要由数据交换位置，则修改statusd的值
14                 status = True
15         # 每一轮冒泡结束之后，判断当前status是否为Flase,
16         # 如果为Flase，则说明上一轮冒泡没有修改任何数据的顺序（即数据是有序的）
17         if not status:
18             return li
19     return li
View Code

时间复杂度：O(n²) 

 

2、斐波那契

①输出第十个

1 def fib(n):
2     a, b = 1, 1
3     for i in range(n-2):
4         a, b = b, a+b
5     return b
6 
7 # 输出了第10个斐波那契数列
8 print(fib(10))
View Code

②输出前十个

 1 #!/usr/bin/python
 2 # -*- coding: UTF-8 -*-
 3 # 斐波那契数列
 4 
 5 def fib(n):
 6     if n == 1:
 7         return [1]
 8     if n == 2:
 9         return [1, 1]
10     fibs = [1, 1]
11     for i in range(n-2):
12         fibs.append(fibs[-1] + fibs[-2])
13     return fibs
14 
15 # 输出前10个斐波那契数列
16 print(fib(10))
View Code

 

3. 快速排序

https://www.bilibili.com/video/BV17J411i7zS?p=45

 

 

4. 二分法排序

 

 1 def func(alist, item):
 2     n = len(alist)
 3     first = 0
 4     last = n - 1
 5     while first <= last:
 6         mid = (first + last) // 2
 7         if alist[mid] == item:
 8             return True
 9         elif item < alist[mid]:
10             last = mid - 1
11         else:
12             first = mid + 1
13     return False
View Code

 

 

5. leetcode第一题，两数之和返回下标

用哈希做

1 class Solution:
2     def twoSum(self, nums: List[int], target: int) -> List[int]:
3         hashtable = dict()
4         for i, num in enumerate(nums):
5             if target - num in hashtable:
6                 return [hashtable[target - num], i]
7             hashtable[nums[i]] = i
8         return []
View Code

 

 

6. 链表反转

 1 class ListNode:
 2     def __init__(self, x):
 3         self.val = x
 4         self.next = None
 5 
 6 
 7 class Solution:
 8     def reverseList(self, head: ListNode) -> ListNode:
 9         cur, pre = head, None
10         while cur:
11             tmp = cur.next
12             cur.next = pre
13             pre = cur
14             cur = tmp
15         return pre
16 
17 
18 if __name__ == '__main__':
19     l1 = ListNode(3)  # 建立链表3->2->1->9->None
20     l1.next = ListNode(2)
21     l1.next.next = ListNode(1)
22     l1.next.next.next = ListNode(9)
23     s = Solution()
24     l = s.reverseList(l1)
25     print(l)
26     print(l.val, l.next.val, l.next.next.val, l.next.next.next.val)
View Code

 

posted @ 2021-06-21 23:17  mkay  阅读(42)  评论(0)  编辑  收藏  举报