Python带你了解数据结构【一】

array = [1, 2, 3, 4, 5, 6, 7]

print(array[0])
获取索引为0的元素的值

修改元素值
array[0] = 5
中间插入新的值
array.insert(0, 5)
尾部插入新的值
array.append(5)
删除值
array.remove(5)

class Node(object):    #初始化，需要传入节点的数据
    def __init__(self, data):
        self.data = data
        self.next = None

    #返回节点的数据
    def get_data(self):
        return self.data

    #更新节点的数据
    def set_data(self, new_data):
        self.data = new_data

    #返回后继节点
    def get_next(self):
        return self.next

    #变更后继节点
    def set_next(self, new_next):
        self.next = new_next

# Reference codes:https://www.jianshu.com/p/e4000619232bclass Linked_list:    # 初始化，头结点为空
    def __init__(self):
        self.head = None

    # 添加节点，添加的新节点作为新的头结点
    def add(self, data):
        new_node = Node(data)
        new_node.set_next() = self.head
        self.head = new_node

    # 包含查询，传入值，返回该值在链表中是否存在
    def search(self, data):
        checking = self.head  # 从头结点开始查询
        while checking != None:
            if checking.get_data() == data:  # 查找到，返回True
                return True
            checking = checking.get_next()  # 查询下一个节点
        return False  # 遍历到最后也未能找到，返回False

    # 删除节点，将第一个具有传入值的节点从链表中删除
    def remove(self, data):
        checking = self.head  # 从头结点开始查询
        previous = None  # 记录前一个节点，头结点的前一个节点为None

        while checking != None:
            if checking.get_data() == data:  # 查找到，跳出查找循环
                break
            previous = checking  # 更新前一个节点
            checking = checking.get_next()  # 查询下一个节点

        if previous == None：  # 如果头结点便是查找的节点
            self.head = checking.get_next()
        else:  # 查找的节点不在头节点，即，存在前驱节点
            previous.set_next(checking.get_next())


    # 判断链表是否为空
    def isEmpty(self):
        return self.head == None


    # 返回链表长度
    def size(self):
        count = 0
        counting = self.head  # 从头结点开始计数
        while counting != None:
            count += 1
            counting = counting.get_next()
        return count

class Stack:
    # 初始化栈为空列表
    def __init__(self):
        self.items = []

    # 判断栈是否为空
    def is_empty(self):
        return self.items == []

    # 返回栈顶
    def peek(self):
        return self.items[len(self.items) - 1]

    # 返回栈的大小
    def size(self):
        return len(self.items)

    # 入栈
    def push(self, item):
        self.items.append(item)

    # 出栈
    def pop(self, item):
        return self.items.pop()

class Queue:
    def __init__(self):
        self.items = []

    def enqueue(self, item):
        self.items.append(item)

    def dequeue(self):
        return self.items.pop(0)

    def empty(self):
        return self.size() == 0

    def size(self):
        return len(self.items)

import queue

q = queue.Queue(3)  # 调用构造函数，初始化一个大小为3的队列
print(q.empty())  # 判断队列是否为空，也就是队列中是否有数据
#  入队，在队列尾增加数据， block参数，可以是True和False 意思是如果队列已经满了则阻塞在这里，
# timeout 参数 是指超时时间，如果被阻塞了那最多阻塞的时间，如果时间超过了则报错。
q.put(13, block=True, timeout=5)
print(q.full())  # 判断队列是否满了，这里我们队列初始化的大小为3
print(q.qsize())  # 获取队列当前数据的个数
#  block参数的功能是 如果这个队列为空则阻塞，
#  timeout和上面一样，如果阻塞超过了这个时间就报错，如果想一只等待这就传递None
print(q.get(block=True, timeout=None))

#  queue模块还提供了两个二次封装了的函数，
q.put_nowait(23)  # 相当于q.put(23, block=False)
q.get_nowait()  # 相当于q.get(block=False)