使用python实现数组、链表、队列、栈

引言

什么是数据结构？

数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成。
简单来说，数据结构就是设计数据以何种方式组织并存储在计算机中。
比如：列表，集合和字典等都是数据结构
N.Wirth：“程序=数据结构+算法”

数据结构按照其逻辑结构可分为线性结构、树结构、图结构

线性结构：数据结构中的元素存在一对一的互相关系。
树结构：数据结构中的元素存在一对多的互相关系。
图结构：数据结构中的元素存在多对多的互相关系。

数组

在python中是没有数组的，有的是列表，它是一种基本的数据结构类型。

实现

class Array(object):

    def __init__(self, size=32):

        """

        :param size: 长度

        """

        self._size = size

        self._items = [None] * size

    # 在执行array[key]时执行

    def __getitem__(self, index):

        return self._items[index]

    # 在执行array[key] = value 时执行

    def __setitem__(self, index, value):

        self._items[index] = value

    # 在执行len(array) 时执行

    def __len__(self):

        return self._size

    # 清空数组

    def clear(self, value=None):

        for i in range(len(self._items)):

            self._items[i] = value

    # 在遍历时执行

    def __iter__(self):

        for item in self._items:

            yield item

使用

a = Array(4)

a[0] = 1

print(a[0]) #

a.clear()

print(a[0]) # None

a[0] = 1

a[1] = 2

a[3] = 4

for i in a:

    print(i) # 1, 2, None, 4

链表

链表中每一个元素都是一个对象，每一个对象被称为节点，包含有数据域value和指向下一个节点的指针next。

通过各个节点直接的相互链接，最终串成一个链表。

实现

class Node(object):

    def __init__(self, value=None, next=None):

        self.value, self.next = value, next

class LinkedList(object):

    def __init__(self, size=None):

        """

        :param size: int or None, 如果None，则该链表可以无限扩充

        """

        self.size = size

        # 定义一个根节点

        self.root = Node()

        # 尾节点始终指向最后一个节点

        self.tail_node = None

        self.length = 0

    def __len__(self):

        return self.length

    def append(self, value):

        # size 不为 None, 且长度大于等于size则链表已满

        if self.size and len(self) >= self.size:

            raise Exception("LinkedList is full")

        # 构建节点

        node = Node(value)

        tail_node = self.tail_node

        # 判断尾节点是否为空

        if tail_node is None:

            # 还没有 append 过，length = 0， 追加到 root 后

            self.root.next = node

        else:

            # 否则追加到最后一个节点的后边，并更新最后一个节点是 append 的节点

            tail_node.next = node

        # 把尾节点指向node

        self.tail_node = node

        # 长度加一

        self.length += 1

    # 往左边添加

    def append_left(self, value):

        if self.size and len(self) >= self.size:

            raise Exception("LinkedList is full")

        # 构建节点

        node = Node(value)

        # 链表为空，则直接添加设置

        if self.tail_node is None:

            self.tail_node = node

        # 设置头节点为根节点的下一个节点

        head_node = self.root.next

        # 把根节点的下一个节点指向node

        self.root.next = node

        # 把node的下一个节点指向原头节点

        node.next = head_node

        # 长度加一

        self.length += 1

    # 遍历节点

    def iter_node(self):

        # 第一个节点

        current_node = self.root.next

        # 不是尾节点就一直遍历

        while current_node is not self.tail_node:

            yield current_node

            # 移动到下一个节点

            current_node = current_node.next

        # 尾节点

        if current_node is not None:

            yield current_node

    # 实现遍历方法

    def __iter__(self):

        for node in self.iter_node():

            yield node.value

    # 删除指定元素

    def remove(self, value):

        # 删除一个值为value的节点，只要使该节点的前一个节点的next指向该节点的下一个

        # 定义上一个节点

        perv_node = self.root

        # 遍历链表

        for current_node in self.iter_node():

            if current_node.value == value:

                # 把上一个节点的next指向当前节点的下一个节点

                perv_node.next = current_node.next

                # 判断当前节点是否是尾节点

                if current_node is self.tail_node:

                    # 更新尾节点 tail_node

                    # 如果第一个节点就找到了，把尾节点设为空

                    if perv_node is self.root:

                        self.tail_node = None

                    else:

                        self.tail_node = perv_node

                # 删除节点，长度减一，删除成功返回1

                del current_node

                self.length -= 1

                return 1

            else:

                perv_node = current_node

        # 没找到返回-1

        return -1

    # 查找元素，找到返回下标，没找到返回-1

    def find(self, value):

        index = 0

        # 遍历链表，找到返回index,没找到返回-1

        for node in self.iter_node():

            if node.value == value:

                return index

            index += 1

        return -1

    # 删除第一个节点

    def popleft(self):

        # 链表为空

        if self.root.next is None:

            raise Exception("pop from empty LinkedList")

        # 找到第一个节点

        head_node = self.root.next

        # 把根节点的下一个节点，指向第一个节点的下一个节点

        self.root.next = head_node.next

        # 获取删除节点的value

        value = head_node.value

        # 如果第一个节点是尾节点, 则把尾节点设为None

        if head_node is self.tail_node:

            self.tail_node = None

        # 长度减一，删除节点，返回该节点的值

        self.length -= 1

        del head_node

        return value

    # 清空链表

    def clear(self):

        for node in self.iter_node():

            del node

        self.root.next = None

        self.tail_node = None

        self.length = 0

    # 反转链表

    def reverse(self):

        # 第一个节点为当前节点，并把尾节点指向当前节点

        current_node = self.root.next

        self.tail_node = current_node

        perv_node = None

        while current_node:

            # 下一个节点

            next_node = current_node.next

            # 当前节点的下一个节点指向perv_node

            current_node.next = perv_node

            # 当前节点的下一个节点为空，则把根节点的next指向当前节点

            if next_node is None:

                self.root.next = current_node

            # 把当前节点赋值给perv_node

            perv_node = current_node

            # 把下一个节点赋值为当前节点

            current_node = next_node

使用

ll = LinkedList()

ll.append(0)

ll.append(1)

ll.append(2)

ll.append(3)

print(len(ll)) #

print(ll.find(2)) #

print(ll.find(-1)) # -1

ll.clear()

print(len(ll)) #

print(list(ll)) # []

循环链表

双链表中每一个节点有两个指针，一个指向后面节点、一个指向前面节点。

循环链表实现

class Node(object):

    def __init__(self, value=None, prev=None, next=None):

        self.value = value

        self.prev = prev

        self.next = next

class CircularDoubleLinkedList(object):

    """

    双向循环链表

    """

    def __init__(self, maxsize=None):

        self.maxsize = maxsize

        node = Node()

        node.prev = node

        node.next = node

        self.root = node

        self.length = 0

    def __len__(self):

        return self.length

    def head_node(self):

        return self.root.next

    def tail_node(self):

        return self.root.prev

    # 遍历

    def iter_node(self):

        if self.root.next is self.root:

            return

        current_node = self.root.next

        while current_node.next is not self.root:

            yield current_node

            current_node = current_node.next

        yield current_node

    def __iter__(self):

        for node in self.iter_node():

            yield node.value

    # 反序遍历

    def iter_node_reverse(self):

        if self.root.prev is self.root:

            return

        current_node = self.root.prev

        while current_node.prev is not self.root:

            yield current_node

            current_node = current_node.prev

        yield current_node

    def append(self, value):

        if self.maxsize is not None and len(self) >= self.maxsize:

            raise Exception("LinkedList is full")

        node = Node(value)

        tail_node = self.tail_node() or self.root

        tail_node.next = node

        node.prev = tail_node

        node.next = self.root

        self.root.prev = node

        self.length += 1

    def append_left(self, value):

        if self.maxsize is not None and len(self) >= self.maxsize:

            raise Exception("LinkedList is full")

        node = Node(value)

        if self.root.next is self.root:

            self.root.next = node

            node.prev = self.root

            node.next = self.root

            self.root.prev = node

        else:

            node.next = self.root.next

            self.root.next.prev = node

            self.root.next = node

            node.prev = self.root

        self.length += 1

    def remove(self, node):

        if node is self.root:

            return

        node.next.prev = node.prev

        node.prev.next = node.next

        self.length -= 1

        return node

循环链表的使用

dll = CircularDoubleLinkedList()

dll.append(0)

dll.append(1)

dll.append(2)

assert list(dll) == [0, 1, 2]

print(list(dll)) # [0, 1, 2]

print([node.value for node in dll.iter_node()]) # [0, 1, 2]

print([node.value for node in dll.iter_node_reverse()]) # [2, 1, 0]

headnode = dll.head_node()

print(headnode.value) #

dll.remove(headnode)

print(len(dll)) #

队列

队列(Queue)是一个数据集合，仅允许在列表的一端进行插入，另一端进行删除。

进行插入的一端成为队尾(rear)，插入动作称为进队或入队。

进行删除的一端称为队头(front)，删除动作称为出队。

队列的性质：先进先出(First-in, First-out)。

基于数组实现环形队列

class Array(object):

    def __init__(self, size=32):

        """

        :param size: 长度

        """

        self._size = size

        self._items = [None] * size

    # 在执行array[key]时执行

    def __getitem__(self, index):

        return self._items[index]

    # 在执行array[key] = value 时执行

    def __setitem__(self, index, value):

        self._items[index] = value

    # 在执行len(array) 时执行

    def __len__(self):

        return self._size

    # 清空数组

    def clear(self, value=None):

        for i in range(len(self._items)):

            self._items[i] = value

    # 在遍历时执行

    def __iter__(self):

        for item in self._items:

            yield item

class ArrayQueue(object):

    def __init__(self, maxsize):

        self.maxsize = maxsize

        self.array = Array(maxsize)

        self.head = 0

        self.tail = 0

    def __len__(self):

        return self.head - self.tail

    # 入队

    def push(self, value):

        if len(self) >= self.maxsize:

            raise Exception("Queue is full")

        self.array[self.head % self.maxsize] = value

        self.head += 1

    # 出队

    def pop(self):

        value = self.array[self.tail % self.maxsize]

        self.tail += 1

        return value

使用

size = 5

q = ArrayQueue(size)

for i in range(size):

    q.push(i)

print(len(q)) #

print(q.pop()) #

print(q.pop()) #

双向队列

两端都可以进行插入，删除。

基于双向链表实现双向队列

class Node(object):

    def __init__(self, value=None, prev=None, next=None):

        self.value = value

        self.prev = prev

        self.next = next

class CircularDoubleLinkedList(object):

    """

    双向循环链表

    """

    def __init__(self, maxsize=None):

        self.maxsize = maxsize

        node = Node()

        node.prev = node

        node.next = node

        self.root = node

        self.length = 0

    def __len__(self):

        return self.length

    def head_node(self):

        return self.root.next

    def tail_node(self):

        return self.root.prev

    # 遍历

    def iter_node(self):

        if self.root.next is self.root:

            return

        current_node = self.root.next

        while current_node.next is not self.root:

            yield current_node

            current_node = current_node.next

        yield current_node

    def __iter__(self):

        for node in self.iter_node():

            yield node.value

    # 反序遍历

    def iter_node_reverse(self):

        if self.root.prev is self.root:

            return

        current_node = self.root.prev

        while current_node.prev is not self.root:

            yield current_node

            current_node = current_node.prev

        yield current_node

    def append(self, value):

        if self.maxsize is not None and len(self) >= self.maxsize:

            raise Exception("LinkedList is full")

        node = Node(value)

        tail_node = self.tail_node() or self.root

        tail_node.next = node

        node.prev = tail_node

        node.next = self.root

        self.root.prev = node

        self.length += 1

    def append_left(self, value):

        if self.maxsize is not None and len(self) >= self.maxsize:

            raise Exception("LinkedList is full")

        node = Node(value)

        if self.root.next is self.root:

            self.root.next = node

            node.prev = self.root

            node.next = self.root

            self.root.prev = node

        else:

            node.next = self.root.next

            self.root.next.prev = node

            self.root.next = node

            node.prev = self.root

        self.length += 1

    def remove(self, node):

        if node is self.root:

            return

        node.next.prev = node.prev

        node.prev.next = node.next

        self.length -= 1

        return node

# 双向队列

class Deque(CircularDoubleLinkedList):

    # 从右边出队

    def pop(self):

        if len(self) <= 0:

            raise Exception("stark is empty!")

        tail_node = self.tail_node()

        value = tail_node.value

        self.remove(tail_node)

        return value

    # 从左边出队

    def popleft(self):

        if len(self) <= 0:

            raise Exception("stark is empty!")

        head_node = self.head_node()

        value = head_node.value

        self.remove(head_node)

        return value

双向队列的使用

dq = Deque()

dq.append(1)

dq.append(2)

print(list(dq)) # [1, 2]

dq.appendleft(0)

print(list(dq)) # [0, 1, 2]

dq.pop()

print(list(dq)) # [0, 1]

dq.popleft()

print(list(dq)) # [1]

dq.pop()

print(len(dq)) #

栈

栈(Stack)是一个数据集合，可以理解为只能在一端插入或删除操作的链表。

栈的特点：后进先出(Last-in, First-out)

栈的概念：

栈顶
栈底

栈的基本操作：

进栈（压栈）：push
出栈：pop

基于双向队列实现

class Node(object):

    def __init__(self, value=None, prev=None, next=None):

        self.value = value

        self.prev = prev

        self.next = next

class CircularDoubleLinkedList(object):

    """

    双向循环链表

    """

    def __init__(self, maxsize=None):

        self.maxsize = maxsize

        node = Node()

        node.prev = node

        node.next = node

        self.root = node

        self.length = 0

    def __len__(self):

        return self.length

    def head_node(self):

        return self.root.next

    def tail_node(self):

        return self.root.prev

    # 遍历

    def iter_node(self):

        if self.root.next is self.root:

            return

        current_node = self.root.next

        while current_node.next is not self.root:

            yield current_node

            current_node = current_node.next

        yield current_node

    def __iter__(self):

        for node in self.iter_node():

            yield node.value

    # 反序遍历

    def iter_node_reverse(self):

        if self.root.prev is self.root:

            return

        current_node = self.root.prev

        while current_node.prev is not self.root:

            yield current_node

            current_node = current_node.prev

        yield current_node

    def append(self, value):

        if self.maxsize is not None and len(self) >= self.maxsize:

            raise Exception("LinkedList is full")

        node = Node(value)

        tail_node = self.tail_node() or self.root

        tail_node.next = node

        node.prev = tail_node

        node.next = self.root

        self.root.prev = node

        self.length += 1

    def append_left(self, value):

        if self.maxsize is not None and len(self) >= self.maxsize:

            raise Exception("LinkedList is full")

        node = Node(value)

        if self.root.next is self.root:

            self.root.next = node

            node.prev = self.root

            node.next = self.root

            self.root.prev = node

        else:

            node.next = self.root.next

            self.root.next.prev = node

            self.root.next = node

            node.prev = self.root

        self.length += 1

    def remove(self, node):

        if node is self.root:

            return

        node.next.prev = node.prev

        node.prev.next = node.next

        self.length -= 1

        return node

class Deque(CircularDoubleLinkedList):

    def pop(self):

        if len(self) <= 0:

            raise Exception("stark is empty!")

        tail_node = self.tail_node()

        value = tail_node.value

        self.remove(tail_node)

        return value

    def popleft(self):

        if len(self) <= 0:

            raise Exception("stark is empty!")

        head_node = self.head_node()

        value = head_node.value

        self.remove(head_node)

        return value

class Stack(object):

    def __init__(self):

        self.deque = Deque() 

    # 压栈

    def push(self, value):

        self.deque.append(value)

    # 出栈

    def pop(self):

        return self.deque.pop()

使用

s = Stack()

s.push(0)

s.push(1)

s.push(2)

print(s.pop()) #

print(s.pop()) #

print(s.pop()) #

~>.<~

使用python实现数组、链表、队列、栈的更多相关文章

Python：数组、队列及堆栈的使用（list用法）--转
Python编程中数组.队列及堆栈用于保存一组数据或对象的序列,元素可以是各种类型混合在一起,定义格式为[元素,元素,……,元素],用变量[位置]即可取出相应的元素,其中“位置”是从零开始计算. 数组 ...
Python列表操作与深浅拷贝（5）——数字处理函数、类型判断、列表链表队列栈
python内建数据结构分类数值型: int float complex bool 序列对象: 字符串str 列表list 元组tuple 键值对: 集合set 字典dict 数值型 (list ...
python数据结构-数组/列表/栈/队列及实现
首先我们要分清楚一些概念和他们之间的关系数组(array) 表(list) 链表(linked list) 数组链表(array list) 队列(queue) 栈(stack) li ...
数组、链表、栈、队列和STL
数组数组是一种最基本的数据结构,它是内存上的一块连续存储空间.正因如此数组的随机访问很方便.但数组也有其固有的限制,大小分配后不能改变. STL中的数组 STL中的Array是静态数组模板,就是我们 ...
[Python] 数据结构--实现顺序表、链表、栈和队列
说明: 本文主要展示Python实现的几种常用数据结构:顺序表.链表.栈和队列. 附有实现代码. 来源主要参考网络文章. 一.顺序表 1.顺序表的结构一个顺序表的完整信息包括两部分,一部分是表中元素 ...
线性表及Java实现顺序表、链表、栈、队列
数据结构与算法是程序设计的两大基础,大型的IT企业面试时也会出数据结构和算法的题目, 它可以说明你是否有良好的逻辑思维,如果你具备良好的逻辑思维,即使技术存在某些缺陷,面试公司也会认为你很有培养价值, ...
Python与数据结构[2] -> 队列/Queue[0] -> 数组队列的 Python 实现
队列 / Queue 数组队列数组队列是队列基于数组的一种实现,其实现类似于数组栈,是一种FIFO的线性数据结构. Queue: <--| 1 | 2 | 3 | 4 | 5 |<-- ...
图解堆算法、链表、栈与队列（Mark）
原文地址: 图解堆算法.链表.栈与队列(多图预警) 堆(heap),是一类特殊的数据结构的统称.它通常被看作一棵树的数组对象.在队列中,调度程序反复提取队列中的第一个作业并运行,因为实际情况中某些时间 ...
数据结构 1 线性表详解链表、栈、队列结合JAVA 详解
前言其实在学习数据结构之前,我也是从来都没了解过这门课,但是随着工作的慢慢深入,之前学习的东西实在是不够用,并且太皮毛了.太浅,只是懂得一些浅层的,我知道这个东西怎么用,但是要优化.或者是解析,就不 ...

随机推荐

vux组件的样式变量的使用
使用x-header,查看文档发现有个样式变量,可以改变x-header的样式这玩意怎么用呢? 1.在项目中创建一个.less样式文件,例如我这里是创建一个src/style/vux_theme.l ...
ubuntu 16.04 上使用pybind11进行C++和Python代码相互调用 | Interfacing C++ and Python with pybind11 on ubuntu 16.04
本文首发于个人博客https://kezunlin.me/post/a41adc1/,欢迎阅读! Interfacing C++ and Python with pybind11 on ubuntu ...
Unittest框架的从零到壹（二）
四大重要概念在unittest文档中有四个重要的概念:Test Case.Test Suite.Test Runner和Test Fixture.只有理解了这几个概念,才能理解单元测试的基本特征. ...
c# 发送邮箱，企业邮箱测试成功
今天在项目中需要实现一个发送邮箱的功能,来实现用户邮箱激活功能!!! 之前采用的是个人的邮箱进行测试,一切都是很顺利的,后来换成了公司的企业邮箱,遇到了一点小问题,问题如下: 发送邮件失败,原因:命令 ...
2019-10-9：渗透测试，基础学习the-backdoor-factory-master（后门工厂）初接触
该文章仅供学习,利用方法来自网络文章,仅供参考 the-backdoor-factory-master(后门工制造厂)原理:可执行二进制文件中有大量的00,这些00是不包含数据的,将这些数据替换成pa ...
linux basic
一:date 语法: 打印日期:date [OPTION]..... [+FORMAT] 设定日期:date [MMDDhhmm] [[cc][YY][.ss] 创建带实时日期的文件 touch $ ...
es6 filter方法应用
let arr =[ {title:'aaaa',read:100,hot:true}, {title:'bbbb',read:50,hot:false}, {title:'ccc',read:100 ...
Spring中，多个service发生嵌套，事务是怎么样的？
前言最近在项目中发现了一则报错:"org.springframework.transaction.UnexpectedRollbackException: Transaction roll ...
win上找到host文件的方法
在运行的位置输入 C:\WINDOWS\system32\drivers\etc
Django中间件详解
Django中间件详解中间件位置 WSGI 主要负责的就是负责和浏览器和应用之家沟通的桥梁浏览器发送过来一个http请求,WSGI负责解包,并封装成能够给APP使用的environ,当app数据返 ...