算法刷题

最新推荐文章于 2023-04-11 22:20:13 发布
skysenlin
最新推荐文章于 2023-04-11 22:20:13 发布
阅读量253
点赞数
文章标签： python
本文链接：https://blog.csdn.net/skysenlin/article/details/109189422
版权
参考网址：https://wx.zsxq.com/dweb2/login
##/*-------------------------------------*/
##/* 从 0 学算法第一周总结：1 万字 30 多幅图
##/*https://mp.weixin.qq.com/s/Ay-N6S920BosVqvpSgGrfg
##/*-------------------------------------*/
"""
1 星球使用方法
2 程序员还需要学算法吗？
3 从零学算法大纲
Day 1 冒泡排序
1.1 学习算法需要什么基础
1.2 算法入门参考资料
1.3 算法进阶参考资料
1.4 算法入门最基本思路
1.5 今日打卡题
1.6 精选回答
Day 2: 选择排序
2.1 作业点评
2.2 今日打卡题
2.3 精选回答
2.3 作业点评
Day 3：什么是一个算法？
3.1 今日打卡题
3.2 精选回答1
3.3 精选回答2
3.4 精选回答3
3.5 参考资料
Day 4：Hailstone 练习题
4.1 今日打卡题
4.2 精选回答 1
4.3 精选回答 2
4.4 Collatz 猜想
Day 5：数组中插入元素
5.1 今日打卡题
5.2 精彩回答
Day 6 ：LeetCode 求中心索引
6.1 今日打卡题
6.2 精彩回答
6.3 不高效解
6.4 算法分析总结
Day 7 ：如何培养算法思维？
7.1 经历描述
7.2 经验总结
7.3 追求目标
7.4 精选回答
Day 8 ：两数之和
8.1 今日打卡题
8.2 精选回答
8.3 分析总结
8.4 不高效解 1
8.5 不高效解 2
Day 9：什么是哈希表？
9.1 今日打卡题
9.2 精彩回答
"""


##/*-------------------------------------*/
##/* 小白入门必看，最详细的循环神经网络介绍！
##/*https://mp.weixin.qq.com/s/phz1EPjPIqoyj6fM-eH_iw
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* Python 求中心索引，第二种方法不可取！
##/*https://mp.weixin.qq.com/s/Bz0qd_Z6ul8_qmq40MzOUw
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* Day 1 冒泡排序
##/*https://mp.weixin.qq.com/s/hnCnIPAIUydqxCOJD0Lxiw
#https://wx.zsxq.com/dweb2/index/group/init  【作业汇总】
##/*-------------------------------------*/
import numpy as np
def bubble_sort(our_list):
    '''
    Function: 将列表从小到大排列
    Parameters: sortborder,记录需要交换的最后元素位置，此位置元素以排好序，不需要遍历
                lastexchangeindex, 每次遍历会将最大元素放到最后，故每次最后的元素不需要再和其他值对比
      
    Return:经过标准化的数据
    ''' 
    n=len(our_list)
    lastexchangeindex=0  #记录最后一次交换元素的位置
    sortborder=n-1  #无序数列边界
    for i in range(n):
        flag=True
        for j in range(0,sortborder):
            if our_list[j]>our_list[j+1]:
                our_list[j],our_list[j+1]=our_list[j+1],our_list[j]
                flag=False  #有元素交换，则将标记置为False
                lastexchangeindex=j
        sortborder=lastexchangeindex
        if flag:
            break
    return our_list
                
#try
our_list=list(np.random.randint(100, size=5)) 

our_list=[62, 78, 18, 45, 6]
print(our_list)
n=len(our_list)
lastexchangeindex=0  #记录最后一次交换元素的位置
sortborder=n-1  #无序数列边界
for i in range(n):
    flag=True
    for j in range(0,sortborder):
        print("j:{}".format(j))
        if our_list[j]>our_list[j+1]:
            print(our_list[j],our_list[j+1])
            our_list[j],our_list[j+1]=our_list[j+1],our_list[j]
            flag=False  #有元素交换，则将标记置为False
            lastexchangeindex=j
            print("flag:",flag,"lastexchangeindex:{}".format(lastexchangeindex),"our_list:",our_list)
        print("*"*30)
    sortborder=lastexchangeindex
    if flag:
        break
    print("i:{}".format(i))
    print("-"*30)
      
[62, 78, 18, 45, 6]
[62, 18, 78, 45, 6]
[62, 18, 45, 78, 6]
[62, 18, 45, 6, 78]

##/*-------------------------------------*/
##/* Day 2: 选择排序
##/*https://articles.zsxq.com/id_xc6xtdw3wn6o.html
##/*-------------------------------------*/
def select_fun(list1):
    n = len(list1)
    count = 0  # 统计更改次数
    for i in range(n-1):  # 开启循环，只需要循环n-1次即可,
        min_index = i
        for j in range(i+1, n):  # j 输入i后面的数字
            if list1[j] < list1[min_index]:  # 如果发现后面存在比最小值档还小的数
                min_index = j  # 这里暂时不更改位置，等循环结束后再更改
        if min_index != i:  # 判断当前的最小值是不是i所在位置
            list1[i], list1[min_index] = list1[min_index], list1[i]
            count += 1
    print('交换次数', count)
    return list1


if __name__ == '__main__':
    list2 = [3, 5, 6, 1, 2]
    print(select_fun(list2))
    
    
list1 = [3, 5, 6, 1, 2]
n = len(list1)
count = 0  # 统计更改次数
for i in range(n-1):  # 开启循环，只需要循环n-1次即可,
    min_index = i
    print(min_index,i)
    for j in range(i+1, n):  # j 输入i后面的数字
        print(j,list1[j],list1[min_index],list1[j] < list1[min_index])
        if list1[j] < list1[min_index]:  # 如果发现后面存在比最小值档还小的数
            min_index = j  # 这里暂时不更改位置，等循环结束后再更改
            print("min_index:",min_index)
        print("*"*5)
    if min_index != i:  # 判断当前的最小值是不是i所在位置
        print(list1)
        list1[i], list1[min_index] = list1[min_index], list1[i]
        print(list1)
        count += 1
    print("-"*30)
print('交换次数', count)

"""
用Python实现常见的四种排序算法
https://baijiahao.baidu.com/s?id=1635285231673698375&wfr=spider&for=pc
"""
#/*-------------------------------------*/
#1. 快速排序
#/*-------------------------------------*/
def quicksort(seq):
    if len(seq)<2:
        return seq
    else:
        base=seq[0]
        left =[elem for elem in seq[1:] if elem<base]
        right=[elem for elem in seq[1:] if elem>base]
        return quicksort(left)+[base]+quicksort(right)
seq=[9,8,7,6,5,4,3,2]
random.shuffle(seq)
print(quicksort(seq))


base=seq[0]
left =[elem for elem in seq[1:] if elem<base]
right=[elem for elem in seq[1:] if elem>base]
#---左边left试图理解start---
seq_s=seq[1:]
i_list=[]
for i in range(len(seq_s)):
    if seq_s[i]>base:
        i_list.append(seq_s[i])
        
for j in i_list:
    seq_s.remove(j)

print(seq_s)      
#---左边left试图理解end--- 

#/*-------------------------------------*/
#2. 冒泡排序
#/*-------------------------------------*/
def bouble_sort(sequence):
    seq=sequence[:]
    length=len(seq)-1
    i=j=0
    flag=1
    while i <length:
        j=0
        while j <length-i:
            if seq[j]>seq[j+1]:
                seq[j],seq[j+1]=seq[j+1],seq[j]
                flag=0
            j+=1
            
        if flag:
            break
        i+=1
    return seq


seq=[9,8,7,6,5,4,3,2]
random.shuffle(seq)
print(seq)

#试图理解
length=len(seq)-1
i=j=0
flag=1
while i <length:
    print("start:",i,j,flag,seq)
    j=0
    while j <length-i:
        print("middd:",i,j,flag,seq)
        if seq[j]>seq[j+1]:
            seq[j],seq[j+1]=seq[j+1],seq[j]
            flag=0
            print("ififi:",i,j,flag,seq)
        j+=1
        
    if flag:
        break
    i+=1
    print("enden:",i,j,flag,seq)
    print("*"*30)


#/*-------------------------------------*/
#3. 选择排序
#/*-------------------------------------*/
def find_minimal_index(seq):
    min_elem=seq[0]
    count=0
    min_elem_index=count
    for elem in seq[1:]:
        count+=1
        if elem<min_elem:
            elem,min_elem=min_elem,elem
            min_elem_index=count
    return min_elem_index

def select_sort(sequence):
    #选择排序
    seq=sequence[:]
    length=len(seq)
    for i in range(length):
        index=find_minimal_index(seq[i:])
        seq[index+i],seq[i]=seq[i],seq[index+i]
    return seq


#试图理解
seq=[9,8,7,6,5,4,3,2]
random.shuffle(seq)
print(seq)


length=len(seq)
for i in range(length):
    index=find_minimal_index(seq[i:])
    seq[index+i],seq[i]=seq[i],seq[index+i]


#min_elem_index
min_elem=seq[0]
count=0
min_elem_index=count
for elem in seq[1:]:
    print("start:",count,min_elem_index,elem)
    count+=1
    if elem<min_elem:
        elem,min_elem=min_elem,elem
        min_elem_index=count
        print("ififi:",count,min_elem_index,elem)
    print("*:"*30)

#/*-------------------------------------*/
#4.插入排序
#/*-------------------------------------*/
    #插入排序
def insert_sort(lists):
    count=len(lists)
    for i in range(1,count):
        key=lists[i]
        j=i-1
        while j>=0:
            if lists[j]>key:
                lists[j+1]=lists[j]
                lists[j]=key
            j-=1
    return lists
    
#试图理解
seq=[9,8,7,6,5,4,3,2]
#insert_sort(seq)
    
count=len(seq)
for i in range(1,count):
    key=seq[i]
    print("i:",i,"key:",key)
    j=i-1
    while j>=0:
        print("j:",j,"seq[j]:",seq[j])
        if seq[j]>key:
            seq[j+1]=seq[j]
            seq[j]=key
            print(seq)
        j-=1
    print("-"*30)
#/*-------------------------------------*/
'''
用于获取接近某个值的列表
https://www.jianshu.com/p/764ccdd12171
'''
#/*-------------------------------------*/



def ls_to_int(ls):
    '''
    将列表字符元素转换为整数并排序
    :param ls:需要转换的列表
    :return:转换后的列表
    '''
    ls = list(map(int, ls))
    ls = list(sorted(ls, reverse=True))
    return ls


def remove_ls(ls, ls_add):
    '''
    去除找到的元素
    :param ls: 原表
    :param ls_add: 原表中提取的一部分数值组成的新列表
    :return: 去除ls_add后的ls
    '''
    for i in range(len(ls_add)):
        remove_value = ls.index(ls_add[i])
        ls.pop(remove_value)
    return ls


def get_ls_equal_num(ls, num):
    '''
    获取一个列表中的一组数，让他们相加的结果接近于给定数
    :param ls: 列表
    :param num: 接近值
    :return: 排序在前的，并接近给定值的一组数列表
    '''
    ls_add = []
    x = 0
    for i in range(len(ls)):
    # print('-' * 30 + str(i))
    x = sum(ls_add)
    # print('x的当前值{}'.format(x))
    if x > num:
    ls_add.remove(ls[i - 1])
    # print('弹出的值{}'.format(ls[i - 1]))
    ls_add.append(ls[i])
    # print('加入当前的ls[i]值{}'.format(ls[i]))
    # 判断最后一个值
    if sum(ls_add) > num:
    ls_add.pop()
    return ls_add


ls = ['1', '30', '30', '30', '30', '1', '27', '23', '1', '17', '15', '11', '9', '7', '6', '2', '2', '2', '1', '1']

print(ls)


def get_all_close2num(ls):
    '''
    获取所有接近30的列表
    :param ls: 需要查找的列表
    :return: 所有接近值列表的列表
    '''
    ls = ls_to_int(ls)
    ls_ = []
    while len(ls) > 0:
    ls_add = get_ls_equal_num(ls, 30)
    # print(ls_add)
    ls_.append(ls_add)
    ls = remove_ls(ls, ls_add)
    return ls_


ls = get_all_close2num(ls)
print(ls)

##/*-------------------------------------*/
##/* Day 3：什么是一个算法？
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* Day 4：Hailstone 练习题
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* Day 5：数组中插入元素
##/*
##/*-------------------------------------*/
"""
Day5 #自实现数组元素插入#
1、下标处理：正/负数绝对值大于数组长度则添加在数组末尾和首位，负数绝对值小于数组长度则用index+len(list)来处理
2、None值判断及优化：若插入位置刚好是None值，则直接替换
(PS：元素的插入需要考虑扩容问题，如果原本数组已满，则需要扩容。实际上许多API底层也是用最原始的方式去实现的，只是封装起来了就成了方便调用的API，建议可以的话尝试自己的方式去实现；顺便想下，如果把它封装起来需要优化哪些地方。)
"""
##/*-------------------------------------*/
##/* Day 6 ：LeetCode 求中心索引
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* Day 7 ：如何培养算法思维？
##/*https://t.zsxq.com/EiiayVf
##/*-------------------------------------*/


##/*-------------------------------------*/
##/* Day 8 ：两数之和
##/*
##/*-------------------------------------*/


##/*-------------------------------------*/
##/* Day 9：什么是哈希表？
##/*
##/*-------------------------------------*/


##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* Day 9 ：什么是哈希表？
##/*https://mp.weixin.qq.com/s/vwpUVwSY05z4H_5wq8utNw
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* Day11 作业帖：宝石与石头 https://t.zsxq.com/A6AEyZ3
##/*
##/*-------------------------------------*/


##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* Day 14 作业题：反转单链表
##/*https://articles.zsxq.com/id_0d6nfhcogdft.html
#3种方法，3幅图，1个gif，把它讲的明明白白
#https://mp.weixin.qq.com/s/MmR8E6fWjyY9jlVjb-IHUA
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* Day 16：算法时间复杂度举例
##/*https://mp.weixin.qq.com/s/-ym9vBW2ZAUM44n45hH2Pw
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* Day10-Day17的算法刷题精华周报发出来了，大家觉得有帮助，能给振哥点个在看或分享朋友圈吗？谢谢。
##/*https://mp.weixin.qq.com/s/HG7qiJLFleHo-vGkFFOqzQ

##/*-------------------------------------*/

##/*-------------------------------------*/
##/* Python 100例
##/*https://mp.weixin.qq.com/s/h2BtBadqLRtI26bcTR1nqQ
##/*-------------------------------------*/


##/*-------------------------------------*/
##/* Day 18：二分查找算法
##/*https://mp.weixin.qq.com/s/yr1fHmZ4vk_rRviCryUwsw
##/*https://mp.weixin.qq.com/s/2QxBdypiyQHZGBGvWlZ19g
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* Day 19：合并两个有序数组
##/*https://mp.weixin.qq.com/s/4Z33sNW_hoNok3R3_wFDeQ
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* Day20 作业：写出归并排序算法
##/*https://mp.weixin.qq.com/s/AzhAeGZtJErn-Qo97xlrQQ
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* Day 22 ：使用递归以相反的顺序打印字符串
##/*https://mp.weixin.qq.com/s/gj_rDw-R9tJ30vfqwhTSMg
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* Pandas 数据分析： 3 种方法实现一个实用小功能
##/*https://mp.weixin.qq.com/s/r5hLb0ctOYervjePi6wLLg
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/


##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/


##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/


##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/


##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/


##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/


##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/

##/*-------------------------------------*/
##/* 
##/*
##/*-------------------------------------*/