背包问题插入排序快排 TSP问题(hamiltonian 回路) Python实现

本文链接：https://blog.csdn.net/neuldp/article/details/53730923

这篇博客介绍了如何使用Python解决经典的计算机科学问题，包括0-1背包问题、插入排序算法、快速排序算法，并探讨了旅行商问题（TSP，即汉密尔顿回路问题）的Python实现。博主分享了实验过程中的代码和思路，为读者提供了优化算法的参考。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

#encoding:UTF-8  

r"""
knapsack problem

insertion sort
quick sort


"""
goods = [
# (5, 10)
(4, 9)
,(3, 6)
,(5, 1)
,(2, 4)
,(5, 1)
# ,(4, 9)
# ,(4, 20)
# ,(3, 6)
# ,(4, 20)
# ,(2, 4)
# ,(5, 10)
# (2, 6)
# ,(2, 3)
# ,(6, 5)
# ,(5, 4)
# ,(4, 6)
]
# 19
# goods = [
# (4, 20)
# ,(3, 6)
# ,(4, 20)
# ,(2, 4)
# ]
# 40
# goods = [
# (2, 6)
# ,(2, 3)
# ,(6, 5)
# ,(5, 4)
# ,(4, 6)
# ]
# 15
# [(weight, value)]

def knapsack(capacity = 10):
    r"""
    .. [1] http://www.hawstein.com/posts/dp-knapsack.html
    """
    # bag = []
    # d = {i:[] for i in range(len(goods))}       
    # in weight i of bag, total max value is d[i]
    d = [0 for _ in range(capacity)]

    for w,v in goods:
        for i in range(capacity-1, 0, -1):
            # d[i] = d[i-1]
            if i >= w:
                d[i] = max([d[i], d[i-w] + v])
            # else:
            #     d[i] = d[i-1]
            print(d[i])

    print(d)
    return d

def InsertionSort(parameter_list):
    r"""
    Input: array a of n elements (keys), a[1], a[2],..., a[n].
    Output: array a with keys in non-decreasing order

    """
    for j in range(1, len(parameter_list)):
        i = j-1
        while i>0 and parameter_list[i] > parameter_list[i+1]:
            parameter_list[i], parameter_list[i+1] = parameter_list[i+1], parameter_list[i]
            i -= 1
    return parameter_list

def InsertionSort2(parameter_list):
    r"""shift the left array
    """
    for j in range(1, len(parameter_list)):
        key = parameter_list[j]
        i = j-1
        while i>0 and parameter_list[i] > key:
            parameter_list[i+1] = parameter_list[i]
            i -= 1
        parameter_list[i+1] = key #!!!i+1
    return parameter_list


def quick_sort(parameter_list):

    if len(parameter_list) == 0:
        # print("error")
        return
    if len(parameter_list) == 1:
        # print(parameter_list[0])
        yield parameter_list[0]

    if parameter_list[0] < parameter_list[-1]:
        pivot = parameter_list[0]
        left = [i for i in parameter_list if i < pivot]
        right = [i for i in parameter_list if i > pivot]
        for item in quick_sort(left):
            yield item
        # quick_sort(left)      #recursion in Generator are limited
        for i in parameter_list:
            if i == pivot:
                yield pivot
        # quick_sort(right)
        for item in quick_sort(right):
            yield item
    # return parameter_list

def path_sort(num, l, r):
    flag = l
    for i in range(l+1, r+1):
        if num[flag] > num[i]:
            tmp = num[i]
            del num[i]
            num.insert(flag, tmp)
            flag += 1
    return flag

def quick_sort_stack(parameter_list):
    result = []
    result_len = len(parameter_list)
    func_stack = []     # for sublist store
    func_stack.append(parameter_list)
    start = 0
    end = len(parameter_list) - 1

    while len(result) != result_len and len(func_stack) != 0:
        parameter_list = func_stack.pop()
        if type(parameter_list) != list:
            result.append(parameter_list)
            continue
        if len(parameter_list) == 1:
            result.append(parameter_list[0])
            continue
        if  len(parameter_list) == 0:
            continue
        if parameter_list[0] < parameter_list[-1]:
            # pivot = parameter_list[0]
            # left = [i for i in parameter_list if i < pivot]
            # right = [i for i in parameter_list if i > pivot]
            pivot = parameter_list[0]
            left = [i for i in parameter_list if i < pivot]
            right = [i for i in parameter_list if i > pivot]
            func_stack.append(right)
            func_stack += [pivot for i in parameter_list if i == pivot]
            # result.append(pivot)
            func_stack.append(left)


            # result.append(pivot)
            # func_stack.append(left)
            # !change right and left to decent and increase!
    return result


def bucket(lst):
    buckets = [0] * ((max(lst) - min(lst))+1)
    for i in range(len(lst)):
        buckets[lst[i] - min(lst)] += 1
    res = []
    for i in range(len(buckets)):
        if buckets[i] != 0:
            res += [i + min(lst)] * buckets[i]
    return res

def sift_down(arr, start, end):
    root = start
    while True:

        child = 2 * root + 1
        if child > end:
            break        
        if child + 1 <= end and arr[child] < arr[child + 1]:
            child += 1

        if arr[root] < arr[child]:            
            arr[root], arr[child] = arr[child], arr[root]            
            root = child
        else:            
            break


def heap_sort(arr):    
    first = len(arr) // 2 - 1
    for start in range(first, -1, -1):
        sift_down(arr, start, len(arr) - 1)

    for end in range(len(arr) -1, 0, -1):
        arr[0], arr[end] = arr[end], arr[0]
        sift_down(arr, 0, end - 1)

def main():
    print("knapsack problem")
    # knapsack()
    # print(InsertionSort([1,3,6,2,8,4,12,8,22]))
    print(InsertionSort2([1,3,6,2,8,4,12,8,22]))
    print( list(quick_sort([1,3,6,2,8,4,12,8,22]) ) )
    print(quick_sort_stack([1,3,6,2,8,4,12,8,22]))
    print(bucket([1,3,6,2,8,4,12,8,22]))
    l = [1,3,6,2,8,4,12,8,22]
    heap_sort(l)
    print(l)





if __name__ == '__main__':
    main()