栈、队列和链表

原创 2016年05月30日 14:29:37

栈是一种后进先出的策略,其操作包括入栈,出栈,获取栈顶元素值等。
我们这里用python列表简单的模拟栈,考虑上下溢出的情况,其代码实现如下:

class Stack:
    def __init__(self,sz=65536):
        self.stack = []
        self.top = -1
        self.size = sz

    def isEmpty(self):
        return True if self.top is -1 else False

    def isFull(self):
        return True if self.top is self.size - 1 else False

    def push(self,obj): #压入栈操作
        if self.isFull():
            raise Exception("Stack over flow!")
        else:
            self.stack.append(obj)
            self.top += 1

    def pop(self): #弹出栈顶元素
        if self.isEmpty():
            raise Exception("Stack is empty!")
        else:
            self.top -= 1
            return self.stack.pop()

    def count(self): #获取栈中元素个数
        return self.top + 1

    def top(self): #获取栈顶元素值
        if self.isEmpty():
            raise Exception("Stack is empty!")
        return self.stack[top]

    def show(self):
        print(self.stack)

队列

队列是一种先进先出的数据结构,主要操作包括入队,出队。入队的元素加入到对尾,从队头取出出队的元素。这里用列表简单模拟队列,其实现如下:

class Queue:
    def __init__(self,sz=65535):
        self.queue = []
        self.size = sz
        self.len = 0

    def isEmpty(self):
        return True if self.len is 0 else False

    def isFull(self):
        return True if self.len is self.size else False

    def length(self):
        return self.len

    def enqueue(self,obj): #入队
        if self.isFull():
            raise Exception("Queue is Full!")
        else:
            self.queue.append(obj)
            self.len += 1

    def dequeue(self): #出队
        if self.isEmpty():
            raise Exception("Queue is Empty!")
        else:
            self.len -= 1
            return self.queue.pop(0)

    def show(self):
        print(self.queue)

实际应用中还使用一种叫做双端队列的数据结构,其实现也在队列的基础上变成可以对两端操作。

class Deque:
    def __init__(self,sz=65535):
        self.queue = []
        self.size = sz
        self.len = 0

    def isEmpty(self):
        return True if self.len is 0 else False

    def isFull(self):
        return True if self.len is self.size else False

    def length(self):
        return self.len

    def enqueue(self,obj): #从右边入队
        if self.isFull():
            raise Exception("DeQueue is Full!")
        else:
            self.len += 1
            self.queue.append(obj)

    def enqueueLeft(self,obj): #从左边入队
        if self.isFull():
            raise Exception("DeQueue is Full!")
        else:
            self.len += 1
            self.queue.insert(0,obj)

    def dequeue(self): #从左边出队
        if self.isEmpty():
            raise Exception("DeQueue is Empty!")
        else:
            self.len -= 1
            return self.queue.pop(0)

    def dequeueRight(self): #从右边出队
        if self.isEmpty():
            raise Exception("DeQueue is Empty!")
        else:
            self.len -= 1
            return self.queue.pop()

    def show(self):
        print(self.queue)

链表

链表分为单向链表和双向链表,这里给出双向链表的实现:

#构成双向链表的结点
class Node:
    def __init__(self,key=None):
        self.key = key
        self.prev = None #指向前驱
        self.next = None #指向后继

    def getKey(self):
        return self.key

    def getPrev(self):
        return self.prev

    def getNext(self):
        return self.next

    def setKey(self, key):
        self.key = key

    def setPrev(self, prev):
        self.prev = prev

    def setNext(self, next):
        self.next = next


class LinkList:
    def __init__(self,data=None):
        self.head = None
        self.len = 0
        if data:
            p = self.head = Node(data[0])
            self.len += 1
            for key in data[1:]:
                node = Node(key)
                p.setNext(node)
                node.setPrev(p)
                self.len += 1
                p = node
    #重载[]运算符,使其具体下标访问能力,比如像obj[1]这样访问           
    def __getitem__(self, index):
        if index >= self.len or index < 0:
            raise Exception("Index out of range!")
        else:
            p = self.head
            for i in range(index):
                p = p.getNext()
            return p.getKey()

    def length(self):
        return self.len

    def search(self,key):
        p = self.head
        while p and p.getKey() is not key:
            p = p.getNext()
        return p

    def insert(self,key):
        p = Node(key)
        if not self.head:
            self.head = p
            self.len += 1
        else:
            self.head.setPrev(p)
            p.setNext(self.head)
            self.head = p
            self.len += 1

    def delete(self,key):
        p = self.search(key)
        if p:
            if p.getPrev():
                p.getPrev().setNext(p.getNext())
            else:
                self.head = p.getNext()
            if p.getNext():
                p.getNext().setPrev(p.getPrev())
            p.setPrev(None)
            p.setNext(None)
            self.len -= 1

    def show(self):
        p = self.head
        while p:
            print(p.getKey(),end=' ')
            p = p.getNext()
        print()
版权声明:

数据结构(栈,队列,链表,二叉树)

栈栈作为一种数据结构,用途十分广泛。在回调函数等许多场景中都有应用。我们需要了解它的基本用途,那就是先进后出和队列的先进先出正好相反。最近在学习数据结构和算法,于是自己来实现。我特别喜欢C语言的指针,...
  • u013766436
  • u013766436
  • 2016年05月04日 17:03
  • 1917

链表,队列,堆栈的区别

链表,队列,堆栈的区别 1、栈是个有底的口袋,像袜子。 队列是没底的口袋,像通心粉。 所以:栈的特点是先进后出,队列的特点是先进先出。 2、主要区别是适用的地方不一样,      链表实际上...
  • jixinhuluwa
  • jixinhuluwa
  • 2016年01月06日 17:18
  • 1355

【数据结构】数组、链表、栈、队列、二叉树

数组 数组存储的数据在地址空间上是连续的。 方便数据的查找,查找数据的时间复杂度为O(1)。...
  • m0_37854317
  • m0_37854317
  • 2017年04月23日 10:50
  • 819

常见的线性列表结构---【数组、链表、栈、队列、堆】

我们在算法设计当中最常见的线性结构列表无非是一下几种:         1.数组:                   数组应该是我最常用的一种。他的存储地址是连续的,就是当我们新开辟一个数组时,...
  • Toplifeww
  • Toplifeww
  • 2015年01月22日 10:44
  • 1168

【万字总结】图解堆算法、链表、栈与队列(多图预警)

堆算法什么是堆堆(heap),是一类特殊的数据结构的统称。它通常被看作一棵树的数组对象。在队列中,调度程序反复提取队列中的第一个作业并运行,因为实际情况中某些时间较短的任务却可能需要等待很长时间才能开...
  • NoMasp
  • NoMasp
  • 2015年12月18日 08:40
  • 18758

数组、链表、堆栈和队列、线性表和顺序表

转自http://blog.csdn.net/amork/article/details/7258216 数据结构:是指相互之间存在一种或多种特定关系的数据元素的集合。听起来是不是很抽象,简单理解:...
  • qingkongyeyue
  • qingkongyeyue
  • 2016年12月26日 13:51
  • 1045

数组、链表、堆栈、队列和树

数据结构:是指相互之间存在一种或多种特定关系的数据元素的集合。听起来是不是很抽象,简单理解:数据结构就是描述对象间逻辑关系的学科。比如:队列就是一种先进先出的逻辑结构,栈是一种先进后出的逻辑结构,家谱...
  • wei78008023
  • wei78008023
  • 2016年02月25日 10:04
  • 2927

c++基本数据结构的类的用法--栈,队列,链表

1.stack类 转自:http://www.169it.com/article/2839007600903800247.html c++ stl栈stack介绍 C++ Stack(堆栈) 是一...
  • xtnc1028
  • xtnc1028
  • 2015年05月28日 16:41
  • 970

java 链表、栈、队列、树的实现

最近无意中翻到一本书,闲来无事写几行代码,实现几种常用的数据结构,以备后查。 一、线性表(链表) 1、节点定义 /**链表节点定义 * @author colonel * */ class...
  • sinat_34322082
  • sinat_34322082
  • 2016年12月16日 15:59
  • 665

线性表、链表、栈、队列的关系

程序员在编程实战操作面前有两个拦路虎,第一个是用递归的思想去解决问题,第二个是数据结构与算法的应用。对于递归,由于其神奇的薄面纱总是然我们觉得难以理解,而大多数递归解法还是需要承担一定的计算负担的,因...
  • qq_26849233
  • qq_26849233
  • 2017年05月16日 09:14
  • 549
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:栈、队列和链表
举报原因:
原因补充:

(最多只允许输入30个字)