算法思路笔记

def bubble_sort(alist):
    """冒泡排序"""
    for j in range(len(alist)-1,0,-1):
    # j表示每次遍历需要⽐较的次数，是逐渐减⼩的
        for i in range(j):
            if alist[i] > alist[i+1]:
                alist[i], alist[i+1] = alist[i+1], alist[i]
    return alist
li = [54,26,93,17,77,31,31,44,55,20]
print(bubble_sort(li))


def selection_sort(alist):
    """选择排序"""
    n = len(alist)
    # 需要进⾏n-1次选择操作
    for i in range(n-1):
        # 记录最⼩位置
        min_index = i
        # 从i+1位置到末尾选择出最⼩数据
        for j in range(i+1, n):
            if alist[j] < alist[min_index]:
                min_index = j
        # 如果选择出的数据不在正确位置，进⾏交换
        if min_index != i:
            alist[i], alist[min_index] = alist[min_index], alist[i]

def tow_search(nums: list, target: int) -> int:
    # 二分查找样例，对应升序的列表，找到返回索引值找不到返回-1
    left_index = 0
    right_index = len(nums) - 1
    while left_index <= right_index:
        # 中间索引值计算，取整
        mid = (left_index + right_index) // 2
        # 如果要找的数在中间返回中间索引
        if target == nums[mid]:
            return mid
        # 如果要找的数比中间元素小，则取左半边的部分继续查找，即改变右边界索引值，继续循环
        if target < nums[mid]:
            right_index = mid - 1
        # 如果要找的数比中间元素大，则取右半边的部分继续查找，即改变左边界索引值，继续循环
        if target > nums[mid]:
            left_index = mid + 1
    # 找不到返回-1
    return -1
    
    def binary_search(alist, item):
        """二分查找方法一不递归"""
        first = 0
        last = len(alist) - 1
        while first <= last:
            midpoint = int((first + last) / 2)
            print(midpoint)
            if alist[midpoint] == item:
                return True
            elif item < alist[midpoint]:
                last = midpoint - 1
            else:
                first = midpoint + 1
        return False
    testlist = [0, 1, 2, 8, 13, 17, 19, 32, 42, 80]
    print(binary_search(testlist, 8))

def binary_search(alist, item):
    """迭代法二分查找"""
    if len(alist) == 0:
        return False
    else:
        midpoint = len(alist) // 2
        if alist[midpoint] == item:
            return True
        else:
            if item < alist[midpoint]:
                return binary_search(alist[:midpoint], item)
            else:
                return binary_search(alist[midpoint + 1:], item)
testlist = [0, 1, 2, 8, 13, 17, 19, 32, 42, ]
print(binary_search(testlist, 5))

# 斐波那契数组
def Fibonacci(n: int) -> int:
    # 斐波那契数组
    l0 = 0
    l1 = 1
    l = [l0, l1]
    if n == 0:
        return l0
    elif n == 1:
        return l1
    else:
        for i in range(2,n+1):
            l.append(l[i-1]+l[i-2])
    return l[-1]

# 斐波那契数列解法二(本质上斐波那契数列和青蛙跳台阶是类似的，斐波那契数列比青蛙跳台阶迟一个单位)
# 斐波那契数列[1、1、2、3、5、8、13、21、34]
# 青蛙跳台阶[1, 2, 3, 5, 8, 13 ,21, 34]
    def Fibonacci(n: int) -> int:
        if n ==1:
            return 1
        if n ==2:
            return 1
        if n ==3:
            return 2
        else:
            a, b =1, 2
            for i in range(n - 3):
                a, b = b, a + b     
        return b


def fib_iter(n):
    if n<2: return 1
    a,b=1,1
    while n>=2:
        c=a+b
        a=b
        b=c
        n=n-1
    return c


# 青蛙跳台阶
    def jumpFloor(number: int) -> int:
        # 青蛙跳台阶
        #由于一次可以跳1个台阶或2个台阶，所以可得到
        if number < 3:
            return number
        #当台阶大于等于3的时候
        else:
            #定义初始值为1 和 2
            a, b =1, 2
            for i in range(number - 2):
                a, b = b, a + b     #根据f(n) = f(n-1) + f(n-2)，可得状态转移方程如左
        return b

# 字符串以空格为边界反转单词顺序并反转大小写
# 输入："This is a sample",16
# 返回值："SAMPLE A IS tHIS"
    def trans(s, n):
        # write code here
        l = s.split(' ')                    # 将原字符串按照空格分隔成list
        l = l[::-1]                         # 翻转list内的所有单词
        s = ""
        for letter in l:
            letter = letter.swapcase()      # 调整大小写
            s += letter                     # 重新串成一个字符串
            s += ' '
        return s[0:len(s)-1]  


# 链表反转范例
 class ListNode:
 		"""链表类"""
     def __init__(self, x):
         self.val = x
         self.next = None
         
   
   # 链表反转
   #                       head
   #    None--------------->1------------>2---->3---->4---->5---->None
   #   test_hou         test_qian 

   def ReverseList(head: ListNode) -> ListNode: 
       if head == None:
           return None
       test_qian = head
       test_hou = None
       while test_qian:
           test_qian = head.next
           head.next = test_hou
           test_hou = head
           head = test_qian
       return test_hou


# 二叉树的前序遍历所有节点值
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
# @param root TreeNode类 
# @return int整型一维数组
#
class Solution:
    def preorderTraversal(self , root: TreeNode) -> List[int]:
        # write code here
        result = []
        def preorder(root):
            if not root:
                return
            result.append(root.val)
            preorder(root.left)
            preorder(root.right)
        preorder(root)
        return result

# 二叉树的中序便利
class Solution:
    def inorderTraversal(self , root: TreeNode) -> List[int]:
        # write code here
        ##### python默认的递归深度是很有限的，大概是900多的样子，当递归深度超过这个值的时候，就会引发这样的一个异常：RuntimeError: maximum recursion depth exceeded。
# 解决的方式是手工设置递归调用深度，方式为：
# import sys
# sys.setrecursionlimit(100000) #例如这里设置为一百万
        import sys
        sys.setrecursionlimit(100000)
        res=[]
        def zhongxu(root):
            if not root:
                return None
            zhongxu(root.left)
            res.append(root.val)
            zhongxu(root.right)
        zhongxu(root)
        return res

# 二叉树的后序便利
class Solution:
    def postorderTraversal(self , root: TreeNode) -> List[int]:
        # write code here
        import sys
        sys.setrecursionlimit(100000)
        res=[]
        def houxu(root):
            if not root:
                return None
            houxu(root.left)
            houxu(root.right)
            res.append(root.val)
        houxu(root)
        return res



# 运维工程师日志排序问题解法
"""
运维工程师采集到某产品线网运行一天产生的日志n条
现需根据日志时间先后顺序对日志进行排序
日志时间格式为H:M:S.N
H表示小时(0~23)
M表示分钟(0~59)
S表示秒(0~59)
N表示毫秒(0~999)
时间可能并没有补全
也就是说
01:01:01.001也可能表示为1:1:1.1
输入描述
   第一行输入一个整数n表示日志条数
   1<=n<=100000
   接下来n行输入n个时间
 输出描述
   按时间升序排序之后的时间
   如果有两个时间表示的时间相同
   则保持输入顺序
   
 示例：
   输入：
    2
    01:41:8.9
    1:1:09.211
   输出
     1:1:09.211
     01:41:8.9
"""
test_init_str_time = []
test_float_time = []
test_dict = {}
for i in range(int(input())):
    every_str_time = input()
    test_init_str_time.append(every_str_time)
    j = int(every_str_time.split(":")[0]) * 3600 + int(every_str_time.split(":")[1]) * 60 + float(every_str_time.split(":")[2])
    # 如果有两个时间大小一样的情况或者时间输入一模一样的情况，则给后一个时间加上0.00001以区分顺序
    if every_str_time in test_init_str_time:
        j += 0.00001
    test_float_time.append(j)
    test_dict[j] = every_str_time
test4 = sorted(test_float_time)
for v in [test_dict[h] for h in test4]:
    print(v)