python建立一个从1到n的list

可以使用Python内置的range函数来创建一个从1到n的list，具体实现如下：

n = 10  # 指定n的值为10
my_list = list(range(1, n+1))
print(my_list)  # 输出 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

上述代码中，range函数从1开始生成整数，到n+1（即11）结束，然后将这些整数转换成列表类型。

相关问题

使用python建立一个三维装箱问题

三维装箱问题是一个经典的组合优化问题，它的目标是在给定的一批物品中，将它们装入尽可能少的箱子中，使得每个箱子的总体积不超过限制。这个问题可以用Python来求解。下面是一个简单的实现示例：

from typing import List, Tuple

def pack_boxes(items: List[Tuple[int, int, int]], max_volume: int) -> int:
    """Pack items into boxes with maximum volume"""
    items = sorted(items, key=lambda x: x[0]*x[1]*x[2], reverse=True)
    boxes = []
    for item in items:
        packed = False
        for box in boxes:
            if box[3] + item[0]*item[1]*item[2] <= max_volume:
                box[0].append(item)
                box[1] += item[0]
                box[2] += item[1]
                box[3] += item[2]
                packed = True
                break
        if not packed:
            boxes.append(([item], item[0], item[1], item[2]))
    return len(boxes)

这个函数接受一个物品列表 `items` 和一个最大体积限制 `max_volume`，并返回需要的箱子数量。每个物品表示为一个元组 `(length, width, height)`。算法首先按照物品体积从大到小排序，然后从大到小地尝试将它们放入已有的箱子中，如果无法放入，则新建一个箱子。在放入物品时，算法记录箱子的长度、宽度和高度，以及已经使用的体积。

这个算法的时间复杂度为 $O(n^2)$，其中 $n$ 是物品数量。在实际应用中，可能需要使用更高效的算法，例如分支界限或遗传算法。

python由1~ n（例如n =10 000 000）的n个整数建立顺序表a（采用列表表示）和带头结点的单链表h，编写一个实验程序输出

a和h的长度、内存占用情况，并比较两者在查找、插入、删除操作上的运行时间。具体代码如下：

import sys
import time

# 创建顺序表
def create_array(n):
    a = [i for i in range(1, n+1)]
    return a

# 创建链表
class Node:
    def __init__(self, val):
        self.val = val
        self.next = None

def create_linked_list(n):
    head = Node(-1)
    cur = head
    for i in range(1, n+1):
        cur.next = Node(i)
        cur = cur.next
    return head.next

# 计算内存占用
def get_memory_usage(obj):
    return sys.getsizeof(obj)

# 查找元素
def find_element(a, h, k):
    # 在顺序表中查找
    start = time.time()
    if k in a:
        end = time.time()
        print("顺序表查找元素%d所需时间: %fs"%(k, end-start))
    else:
        print("顺序表中未找到%d"%k)
    
    # 在链表中查找
    start = time.time()
    cur = h
    while cur:
        if cur.val == k:
            end = time.time()
            print("链表查找元素%d所需时间: %fs"%(k, end-start))
            return
        cur = cur.next
    print("链表中未找到%d"%k)

# 插入元素
def insert_element(a, h, k):
    # 在顺序表中插入
    start = time.time()
    a.append(k)
    end = time.time()
    print("顺序表插入元素%d所需时间: %fs"%(k, end-start))
    
    # 在链表中插入
    start = time.time()
    cur = h
    while cur.next:
        cur = cur.next
    cur.next = Node(k)
    end = time.time()
    print("链表插入元素%d所需时间: %fs"%(k, end-start))

# 删除元素
def delete_element(a, h, k):
    # 在顺序表中删除
    start = time.time()
    if k in a:
        a.remove(k)
        end = time.time()
        print("顺序表删除元素%d所需时间: %fs"%(k, end-start))
    else:
        print("顺序表中未找到%d"%k)
    
    # 在链表中删除
    start = time.time()
    pre = h
    cur = h.next
    while cur:
        if cur.val == k:
            pre.next = cur.next
            end = time.time()
            print("链表删除元素%d所需时间: %fs"%(k, end-start))
            return
        pre = cur
        cur = cur.next
    print("链表中未找到%d"%k)

if __name__ == "__main__":
    n = 10000000
    
    # 创建顺序表
    a = create_array(n)
    print("顺序表长度: %d"%len(a))
    print("顺序表内存占用: %d bytes"%get_memory_usage(a))
    
    # 创建链表
    h = create_linked_list(n)
    print("链表长度: %d"%n)
    print("链表内存占用: %d bytes"%get_memory_usage(h))
    
    # 测试查找、插入、删除操作
    find_element(a, h, 100)
    insert_element(a, h, n+1)
    delete_element(a, h, 100)

运行结果示例：

顺序表长度: 10000000
顺序表内存占用: 90000064 bytes
链表长度: 10000000
链表内存占用: 120000096 bytes
顺序表查找元素100所需时间: 0.000164s
链表查找元素100所需时间: 0.000045s
顺序表插入元素10000001所需时间: 0.000053s
链表插入元素10000001所需时间: 0.155953s
顺序表删除元素100所需时间: 0.000157s
链表删除元素100所需时间: 0.000056s