Python实现类似C/C++的数据结构

python在线工具： https://c.runoob.com/compile/6

---

Stack (使用list实现Stack的基础方法)

# -*- coding: UTF-8 -*-
class Stack:
    def __init__(self) :
        self.items = []

    def empty(self) :
        if len(self.items) == 0 :
            return True 
        return False 

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

    def push(self, data) :
        self.items.append(data)

    def pop(self) :
        self.items.pop(-1)

    def top(self) :
        return self.items[-1]

if __name__ == '__main__':

    sta = Stack()
    sta.push(1)
    sta.push(2)
    print sta.top()
    sta.pop()
    print sta.top()
    print sta.size()
    print sta.empty()
    sta.push(3)
    print sta.top()
    print sta.size()

Queue

# -*- coding: UTF-8 -*-
class Queue:
    def __init__(self) :
        self.items = []

    def empty(self) :
        if len(self.items) == 0 :
            return True 
        return False 

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


    def push(self, data) : 
        """在末尾加入一个元素"""
        self.items.append(data)

    def pop(self) :
        """删除第一个元素"""
        self.items.pop(0)

    def front(self) :
        """返回第一个元素"""
        return self.items[0]

    def back(self) :
        """返回最后一个元素"""
        return self.items[-1]

if __name__ == '__main__':

    que = Queue()
    que.push(1)
    que.push(2)
    que.push(3)
    print que.front(), que.back()
    que.pop()
    print que.front(), que.back()
    print que.size()
    print que.empty()
    que.push(4)
    print que.front(), que.back()

堆：大堆，小堆

# -*- coding:utf-8 -*-
class BigHeap:
    def __init__(self):
        self.heap = [-1] # 让下标从1开始
        self.size = 0

    # 大堆调整
    def adjust(self,heap, n, pos):
        k = pos
        while k <= n / 2:
            l_k = 2 * k
            r_k = 2 * k + 1
            if r_k > n:
                if heap[l_k] > heap[k]:
                    tmp = heap[k]
                    heap[k] = heap[l_k]
                    heap[l_k] = tmp
                return None

            if heap[k] >= heap[l_k] and heap[k] >= heap[r_k]:
                break
            elif heap[k] >= heap[l_k] and heap[k] < heap[r_k]:  # 右边大
                tmp = heap[k]
                heap[k] = heap[r_k]
                heap[r_k] = tmp
                k = r_k
            elif heap[k] < heap[l_k] and heap[k] >= heap[r_k]:  # 左边大
                tmp = heap[k]
                heap[k] = heap[l_k]
                heap[l_k] = tmp
                k = l_k
            else:
                if heap[l_k] >= heap[r_k]:  # 左边更大
                    tmp = heap[k]
                    heap[k] = heap[l_k]
                    heap[l_k] = tmp
                    k = l_k
                else:  # 右边更大
                    tmp = heap[k]
                    heap[k] = heap[r_k]
                    heap[r_k] = tmp
                    k = r_k

    def Insert(self, val) :
        self.heap.append(val)
        self.size += 1

        j = self.size / 2
        while j >= 1:
            self.adjust(self.heap, self.size, j)
            j -= 1

    def isEmpty(self):
        if self.size == 0 :
            return True
        return False

    def pop(self):
        if self.size == 0 :
            return None
        # 返回根节点，并且自己调整
        val = self.heap.pop(1)
        self.size -= 1
        j = self.size / 2
        while j >= 1:
            self.adjust(self.heap, self.size, j)
            j -= 1
        return val

    def getTop(self):
        if self.size == 0:
            return None
        return self.heap[1]

class SmallHeap() :
    def __init__(self):
        self.heap = [-1] # 让下标从1开始
        self.size = 0

    # 小堆调整
    def adjust(self,heap, n, pos):
        k = pos
        while k <= n / 2:
            l_k = 2 * k
            r_k = 2 * k + 1
            if r_k > n:
                if heap[l_k] < heap[k]:
                    tmp = heap[k]
                    heap[k] = heap[l_k]
                    heap[l_k] = tmp
                return None

            if heap[k] <= heap[l_k] and heap[k] <= heap[r_k]:
                break
            elif heap[k] <= heap[l_k] and heap[k] > heap[r_k]:  # 右边小
                tmp = heap[k]
                heap[k] = heap[r_k]
                heap[r_k] = tmp
                k = r_k
            elif heap[k] < heap[l_k] and heap[k] >= heap[r_k]:  # 左边小
                tmp = heap[k]
                heap[k] = heap[l_k]
                heap[l_k] = tmp
                k = l_k
            else:
                if heap[l_k] <= heap[r_k]:  # 左边更小
                    tmp = heap[k]
                    heap[k] = heap[l_k]
                    heap[l_k] = tmp
                    k = l_k
                else:  # 右边更小
                    tmp = heap[k]
                    heap[k] = heap[r_k]
                    heap[r_k] = tmp
                    k = r_k

    def Insert(self, val) :
        self.heap.append(val)
        self.size += 1

        j = self.size / 2
        while j >= 1:
            self.adjust(self.heap, self.size, j)
            j -= 1

    def isEmpty(self):
        if self.size == 0 :
            return True
        return False

    def pop(self):
        if self.size == 0:
            return None
        # 返回根节点，并且自己调整
        val = self.heap.pop(1)
        self.size -= 1
        j = self.size / 2
        while j >= 1:
            self.adjust(self.heap, self.size, j)
            j -= 1
        return val

    def getTop(self):
        if self.size == 0:
            return None
        return self.heap[1]

def testBHeap() :
    bHeap = BigHeap()
    li = [3,4,2,1,7,6,5,8]
    for num in li :
        bHeap.Insert(num)
        bHeap.Print()

def testSHeap() :
    sHeap = SmallHeap()
    li = [3,4,2,1,7,6,5,8,0]
    for num in li :
        sHeap.Insert(num)
        sHeap.Print()

testSHeap()