1、数组：

首先让我们来创建一个数组，也就是Python中的列表，代码非常简单，使用方括号的形式 即可：

#初始化列表

my.list = [3, 1, 2, 5, 4, 9, 7, 2]

现在我们已经拥有了一个名为my_list的数组，要读取数组下标为3的元素，就写作 my_list[3];要读取数组下标为5的元素，就写作my_list[5]o需要注意的是，输入的下标 必须在数组的长度范围之内，否则会出现数组越界的问题。

#尾部插入元素
my_list.append(6)
#巾间插入元素
my_list・insept(5, 11)
print(my_list)

class MyArray:
def 	init 	(self, capacity): self.array = [None] * capacity self.size = 0
def insert(self, index, element):
#判断访问下标是否超岀范围
if index < 0 or index > self.size:
raise Exception("超出数组实际元素范围！")
#从右向左循环，逐个元素向右挪一位
for i in range(self.size-lj -1, -1):
self.array[i+l] = self.array[i]
#腾出的位置放入新元素
self.array[index] = element
self.size += 1
def output(self):
for i in range(self.size):
print(self.array[i])
array = MyArray(4)
array.insert_v2(0, 10)
array.insert_v2(0j 11)
array ,insert_v2(0J> 15)
array.output()

#代码中的成员变量size是数组中实际元素的数量。如果插入元素在数组尾部，传入的下标 参数index等于#size；如果插入元素在数组中间或头部，则index小于size。
#如果传入的下标参数index大于size或小于o,则认为是非法输入，会直接抛出异常。

#删除：

def remove(self, index):
#判断访问下綜是否超出范围
    if index < 0 or index >= self.size:
        raise Exception("超出数组实际元素范围！") #从左到右，逐个元素向左挪动一位
    for i in range(index, self.size):
        self.array[i] = self.array[i+l]
        self.size -= 1

2、单链表：

class Node:
    def __init__(selfdata):
        self.data = data
        self.next = None

单链表的实现：

class Node:
    def __init__(self, data): self.data = data self.next = None

class LinkedList:
    def__init__(self):
        self.size = 0
        self.head = None
        self.last = None

    def get(selfindex):
        if index < 0 or index >= self.size: 
            raise Exception(1超出链表节点范围！')
        p = self.head
        for i in range(index):
            p = p.next
        return p

    def insert(self, data, index):
        if index < 0 or index > self.size:
            raise Exception('超岀链表节点范围！’) 
        node = Node(data)
        if self.size == 0:
            #空链表
            self.head = node
            self.last = node
        elif index == 0:
            #插入头部
            node.next = self.head
            self.head = node
        elif self.size == index:
            #插入尾部
            self.last.next = node
            self.last = node;
        else:
            #插入中间
            prev_node = self.get(index-1)
            node.next = prev_node.next
            prev_node.next = node
        self.size += 1

    def remove(selfindex):
        if index < 0 or index >= self.size: 
            raise Exception('超出链表节点范围！')
        #暂存被删除的节点，用于返回
        if index == 0:
            #删除头节点
            removed_node = self.head
            self.head = self.head.next
        elif index == self.size - 1:
            #删除尾节点
            prev_node = self.get(index-1)
            removed_node = prev_node.next
            prev_node.next = None
            self.last = prev_node
        else:
            #删除中间节点
            prev_node = self.get(index-l)
            next_node = prev_node.next.next
            removed_node = prev_node.next
            prev_node.next = next_node
        self.size -= 1
        return removed_node

    def output(self): 
        p = self.head
        while p is not None: 
            print(p.data) 
            p = p.next
    linkedList = LinkedList() 
    linkedList.insert(3j 0) 
    linkedList.insert(4j 0) 
    linkedList.insert(9j 2) 
    linkedList.insert(5j 3) 
    linkedList.insert(6^ 1) 
    linkedList.remove(0) 
    linkedList.output()