基于python实现常见数据结构

基于python实现常见数据结构

import numpy as np
class ResizingArrayStack():
    # 下压栈（能动态调整数组大小的实现）
    # 每项操作用时与集合大小无关
    # 空间需求不超过集合大小乘一个常数
    # 缺点在于某些push()和pop()操作会调整数组大小，
    # 这个耗时和栈大小成正比
    a = np.empty(1)  # 栈元素
    N = 0  # 元素数量

    def isEmpty(self):
        return self.N == 0

    def size(self):
        return self.N

    def resize(self, max):
        # 将栈移动到一个大小为max的新数组
        temp = np.empty(max)
        for i in range(self.N):
            temp[i] = self.a[i]
        self.a = temp

    def push(self, item):
        # 元素添加到栈顶
        if self.N == len(self.a):
            self.resize(2 * len(a))
        self.N = self.N + 1
        self.a[self.N] = item

    def pop(self):
        self.N = self.N - 1
        item = self.a[self.N]
        self.a[self.N + 1] = None
        if self.N > 0 and self.N == len(self.a) / 4:
            self.resize(len(self.a / 2))
        return item

    def __next__(self):
        return next(self.a)

    def __iter__(self):
        return self


class Stack():
    # 下压堆栈（链表实现）
    # 可以处理任意类型数据
    # 所需空间总是和集合大小成正比
    # 操作所需时间总是和集合大小无关
    def __init__(self):
        self.first = None  # 栈顶（最近添加的元素）
        self.N = 0  # 元素数量

    class Node:
        # 定义结点的嵌套类
        def __init__(self):
            self.item = None
            self.next = None

    def isEmpty(self):
        return self.first is None

    def size(self):
        return self.N

    def push(self, item):
        # 向栈顶添加元素
        oldfirst = self.first
        self.first = self.Node()
        self.first.item = item
        self.first.next = oldfirst
        self.N = self.N + 1

    def pop(self):
        # 从栈顶删除元素
        item = self.first.item
        self.first = self.first.next
        self.N = self.N - 1
        return item


class Queue():
    # 先进先出队列（链表实现）
    # 可以处理任意类型数据
    # 所需空间总是和集合大小成正比
    # 操作所需时间总是和集合大小无关
    def __init__(self):
        self.first = None  # 指向最早添加的结点的链接
        self.last = None  # 指向最近添加的结点的链接
        self.N = 0  # 元素数量

    class Node:
        # 定义结点的嵌套类
        def __init__(self):
            self.item = None
            self.next = None

    def isEmpty(self):
        return self.first is None

    def size(self):
        return self.N

    def enqueue(self, item):
        # 向表尾添加元素
        oldlast = self.last
        self.last = self.Node()
        self.last.item = item
        self.last.next = None
        if self.isEmpty():
            self.first = self.last
        else:
            oldlast.next = self.last
        self.N = self.N + 1

    def dequeue(self):
        # 从表头删除元素
        item = self.first.item
        self.first = self.first.next
        if self.isEmpty():
            self.last = None
        self.N = self.N - 1
        return item


class Bag():
    # 背包（链表实现）
    # 可以处理任意类型数据
    # 所需空间总是和集合大小成正比
    # 操作所需时间总是和集合大小无关
    def __init__(self):
        self.first = None  # 最近添加的元素
        self.N = 0  # 元素数量

    class Node:
        # 定义结点的嵌套类
        def __init__(self):
            self.item = None
            self.next = None

    def isEmpty(self):
        return self.first is None

    def size(self):
        return self.N

    def add(self, item):
        oldfirst = self.first
        self.first = self.Node()
        self.first.item = item
        self.first.next = oldfirst
        self.N = self.N + 1
class MaxPQ():
    #基于堆的优先队列
    #当一根二叉树的每个节点都大于等于它的两个子节点时，被称为堆有序
    #二叉堆是一组能够堆有序的完全二叉树排序的元素。并在数组中安装层级存储（不使用数组的第一个位置）
    #运行时间最坏为lgN
    def __init__(self,maxN):
        self.pq=np.empty(maxN)#基于堆的完全二叉树
        self.N=0
    def isEmpty(self):
        return self.N==0

    def size(self):
        return self.N
    def insert(self,v):
        self.N=self.N+1
        self.pq[self.N]=v
        self.swim(self.N)
    def delMax(self):
        max=self.pq[1] #从根结点得到最大元素
        self.pq[1], self.pq[self.N] = self.pq[self.N], self.pq[1]#将其和最后一个结点交换
        self.N=self.N-1
        self.pq[self.N+1]=None
        return max
    def swim(self,k):
        #由下至上的堆有序化
        while k>1 and self.pq[k/2]>self.pq[k]:
            self.pq[k / 2], self.pq[k]=self.pq[k], self.pq[k / 2]
            k=k/2
    def sink(self,k):
        #由上至下的堆有序化
        while 2*k<=self.N:
            j=2*k
            if j<self.N and self.pq[j]>self.pq[j+1]:
                j=j+1
            if self.pq[k]<self.pq[j]:
                break
            self.pq[k], self.pq[j] = self.pq[j], self.pq[k]
            k=j