数组、栈和队列之间的相互转换（Python + Java实现）

最新推荐文章于 2022-02-03 12:42:48 发布
最新推荐文章于 2022-02-03 12:42:48 发布
阅读量1.7k 收藏 4
点赞数 1
分类专栏： Java Data structure Python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Forlogen/article/details/105782848
版权
Java 同时被 3 个专栏收录
68 篇文章 4 订阅
订阅专栏
Data structure
14 篇文章 0 订阅
订阅专栏
Python
9 篇文章 1 订阅
订阅专栏

如何使用数组实现栈和队列？

Python中的list有如下的两个方法：

  • appned(x)：在列表的末尾添加元素
  • pop(index = -1)：从列表中弹出指定索引的元素，默认为弹出列表的末尾元素

因此，我们使用list可以很方法的实现栈和队列，废话不多说，直接上代码：

数组实现栈：

  • python实现

    class Stack:
    def __init__(self, array = None):
        super().__init__()
        self.array = array

    # 入栈
    def push(self, x):
        self.array.append(x)

    # 出栈
    def pop(self,):
        if len(self.array) == 0:
            return

        return self.array.pop()

    # 取栈顶元素
    def top(self,):
        if len(self.array) == 0:
            return

        return self.array[-1]

    # 判空
    def isEmpty(self,):
        return True if self.array == [] else False

  • Java实现

    Java中的数组并没有python中list类似的方法，因此需要设置一个变量size来表示当前数组中的元素个数，以及方便进行栈顶元素的获取。

    public class ArrayToStack {

  public static class Array2Stack<T>{
      private T[] array;
      private int size;

      public Array2Stack() {
      }

      public Array2Stack(T[] array) {
          this.array = array;
          this.size = 0;
      }


      // 入栈
      public void push(T x){
          if (this.size == this.array.length){
              throw new ArrayIndexOutOfBoundsException("the stack is full!");
          }

          this.array[size++] = x;
      }
      // 出栈
      public T pop(){
          if (isEmpty()){
              throw new ArrayIndexOutOfBoundsException("the stack is empty");
          }

          return this.array[--size];
      }
      // 取栈顶元素
      public T top(){
          if (isEmpty()){
              return null;
          }
          return this.array[size];
      }

      // 判空
      public boolean isEmpty(){
          boolean flag = this.size == 0 ? true : false;
          return flag;
      }
  }

  public static void main(String[] args) {
      int size = 10;
      Integer [] array = new Integer[size];
      Array2Stack<Integer> stack = new Array2Stack<>(array);

      // 入栈
      stack.push(1);
      stack.push(2);
      stack.push(3);

      // 出栈
      while(!stack.isEmpty()){
          System.out.println(stack.pop()); // 3, 2, 1
      }

      String[] arr = new String[size];
      Array2Stack<String> stack1 = new Array2Stack<>(arr);
      stack1.push("Forlogen");
      stack1.push("kobe");

      while(!stack1.isEmpty()){
          System.out.println(stack1.pop()); // kobe, Forlogen
      }
  }
}
数组实现队列

  • python实现：

    class Queue:
    def __init__(self, array = None):
        super().__init__()
        self.array = array

    # 入队
    def enqueue(self, x):
        self.array.append(x)

    # 出队
    def dequeue(self):
        if len(self.array) == 0:
            return

        return self.array.pop(0)

    # 判空
    def isEmpty(self,):
        return True if self.array == [] else False

  • Java实现：

    使用数组实现队列除了需要变量size来表示当前数组中的元素个数外，还需要first和last来表示队头元素和队尾元素的位置，将数组循环使用。

    
import java.util.Arrays;

public class ArrayToQueue<T>{
    private T[] array;
    private int size = 0;
    private int first = 0;
    private int last = 0;

    public ArrayToQueue() {
    }

    public ArrayToQueue(T[] array) {
        if (size < 0){
            throw new IllegalArgumentException("the size is less than 0!");
        }
        this.array = array;
    }

    // 入队
    public void enqueue(T x){
        if (this.size == this.array.length){
            throw new ArrayIndexOutOfBoundsException("the queue is full!");
        }
        size++;
        this.array[this.last] = x;
        last = last == this.array.length - 1 ? 0 : last + 1;
    }

    // 出队
    public T dequeue(){
        if (isEmpty()){
            throw new ArrayIndexOutOfBoundsException("the queue is empty!");
        }
        size--;
        int tmp = first;
        first = first == this.array.length - 1 ? 0: first + 1;
        return this.array[tmp];
    }

    public boolean isEmpty(){
        boolean flag = this.size == 0 ? true : false;
        return flag;
    }


    public static void main(String[] args) {
        int size = 10;
        Integer[] array = new Integer[size];
        ArrayToQueue<Integer> queue = new ArrayToQueue<>(array);

        // 入队
        queue.enqueue(1);
        queue.enqueue(2);
        queue.enqueue(3);

        System.out.println(Arrays.toString(array));
        while(!queue.isEmpty()){
            System.out.println(queue.dequeue()); // 1, 2,3
        }

    }
}

如何构建获取最小元素的栈

  • 思路1：array和mins分别存储入栈的元素和当前已入栈元素中最小的元素

    • 入栈：如果此时栈为空，则将元素同时压入两个数组中；如果此时栈不为空且入栈的元素小于mins的末尾元素，则同时压入两个数组；如果此时栈不为空但入栈的元素大于mins的末尾元素，则只将入栈元素压入array
    • 出栈：同样需要判断当前array的栈顶元素和mins末尾元素的关系，从而来判断是否需要同时出栈，还是只对array执行出栈操作
    class MinStack:
    def __init__(self, array = None):
        super().__init__()
        self.array = array
        self.mins = []

    # 入栈
    def push(self, x):
        if len(self.mins) == 0:
            self.array.append(x)
            self.mins.append(x)
        else:
            if x < self.mins[-1]:
                self.array.append(x)
                self.mins.append(x)
            else:
                self.array.append(x)

    # 出栈
    def pop(self,):
        if len(self.array) == 0:
            return
        elif self.top() == self.mins[-1]:
            self.mins.pop()
            return self.array.pop()
        else:
            return self.array.pop()

    # 获取栈中的最小元素
    def getMin(self, ):
        if len(self.array) == 0:
            return
        return self.mins[-1]

    # 取栈顶元素
    def top(self,):
        if len(self.array) == 0:
            return

        return self.array[-1]

  • 思路2： 同样使用array和mins来存储入栈的元素和当前栈中最小的元素，不同之处在于入栈和出栈更为简单，假设当前栈不为空：

    • 入栈：如果入栈元素x大于等于mins的栈顶元素，则将x压入array中，而mins重新压入它当前的栈顶元素
    • 出栈：array和mins同时出栈
    class MinStack:
    def __init__(self, array = None):
        super().__init__()
        self.array = array
        self.mins = []

    # 入栈
    def push(self, x):
        if len(self.mins) == 0:
            self.array.append(x)
            self.mins.append(x)
        else:
            if x < self.mins[-1]:
                self.array.append(x)
                self.mins.append(x)
            else:
                self.mins.append(self.mins[-1])
                self.array.append(x)

    # 出栈
    def pop(self,):
        if len(self.array) == 0:
            return

        self.mins.pop()
        return self.array.pop()


    # 获取栈中的最小元素
    def getMin(self, ):
        if len(self.array) == 0:
            return
        return self.mins[-1]

    # 取栈顶元素
    def top(self,):
        if len(self.array) == 0:
            return

        return self.array[-1]

如何使用队列实现栈？

  • python实现：

    Python的collections模块中的deque为一个双端队列，使用其中的append()入栈和使用pop()出栈，实现代码：

    from collections import deque

class Stack:
    def __init__(self, array = None):
        super().__init__()
        self.queue = deque(array) 

    # 入栈  
    def push(self, x):
        self.queue.append(x)

    # 出栈
    def pop(self,):
        if (list(self.queue)) == 0:
            return
        return self.queue.pop()

    # 取栈顶元素
    def top(self,):
        if (list(self.queue)) == 0:
            return

        return list(self.queue)[-1]

    # 判空
    def isEmpty(self, ):
        return True if (list(self.queue)) == 0 else False

  • Java 实现：

    import java.util.LinkedList;
import java.util.Queue;

public class QueueToStack<T>{
    private Queue<T> queue1;
    private Queue<T> queue2;

    public QueueToStack(Queue<T> queue1, Queue<T> queue2) {
        this.queue1 = queue1;
        this.queue2 = queue2;
    }

    // 入栈
    public void push(T x){
        this.queue1.add(x);
    }
    // 出栈
    public T pop(){
        if (queue1.isEmpty()){
            throw new RuntimeException("stack is empty");
        }
        while (this.queue1.size() > 1){
            this.queue2.add(this.queue1.poll());
        }
        T res = this.queue1.poll();
        swap();
        return res;
    }

    // 交换引用
    private void swap() {
        Queue<T> tmp = this.queue2;
        queue2 = queue1;
        queue1 = tmp;
    }
    // 返回栈顶元素
    public T top(){
        if (queue1.isEmpty()){
            throw new RuntimeException("stack is empty");
        }
        while (this.queue1.size() > 1){
            this.queue2.add(this.queue1.poll());
        }
        T res = this.queue1.poll();
        this.queue2.add(res);
        swap();
        return res;
    }

    // 判空
    public boolean isEmpty(){
        if (this.queue1.isEmpty() && this.queue2.isEmpty()){
            return true;
        } else{
            return false;
        }
    }


    @Override
    public String toString() {
        return "QueueToStack{" +
                "queue1=" + queue1 +
                ", queue2=" + queue2 +
                '}';
    }

    public static void main(String[] args) {
        Queue<Integer> queue1 = new LinkedList<>();
        Queue<Integer> queue2 = new LinkedList<>();

        QueueToStack<Integer> stack = new QueueToStack<>(queue1, queue2);

        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        stack.push(5);
        System.out.println(stack);  // QueueToStack{queue1=[1, 2, 3, 4, 5], queue2=[]}

        System.out.println(stack.top()); // 5

        stack.pop();
        System.out.println(stack); // QueueToStack{queue1=[1, 2, 3, 4], queue2=[]}
    }
}

如何使用栈构建队列？

  • python实现：

    队列是一种先进先出的数据结构，而栈是一种后见先出的数据结构。因此需用一个栈stack1做入队，另一个stack2做出队。如果stack2不为空则直接弹出，否则需将stack1中的全部元素先压入stack2再从stack2中出栈。

    class Queue:
    def __init__(self):
        super().__init__()
        self.stack1 = []
        self.stack2 = []

    # 入栈
    def push(self, x):
        self.stack1.append(x)

    # 出栈
    def pop(self,):
        if self.stack2:
            return self.stack2.pop()

        while self.stack1:
            self.stack2.append(self.stack1.pop())

        return self.stack2.pop()

    def isEmpty(self,):
        if len(self.stack1) == 0 and len(self.stack2) == 0:
            return True
        else:
            return False

  • Java实现：

    import java.util.Stack;

public class StackToQueue<T>{
    private Stack<T> stack1;
    private Stack<T> stack2;

    public StackToQueue() {
    }

    public StackToQueue(Stack<T> stack1, Stack<T> stack2) {
        this.stack1 = stack1;
        this.stack2 = stack2;
    }

    // 入队
    public void enqueue(T x){
        this.stack1.push(x);
    }

    // 出队
    public T dequeue(){
        if (!this.stack2.isEmpty()){
            return this.stack2.pop();
        } else{
            while (!this.stack1.isEmpty()){
                this.stack2.add(this.stack1.pop());
            }
            return this.stack2.pop();
        }
    }

    // 返回队首
    public T top(){
        if (!this.stack2.isEmpty()){
            return this.stack2.pop();
        } else{
            while (!this.stack1.isEmpty()){
                this.stack2.add(this.stack1.pop());
            }
            return this.stack2.peek();
        }
    }

    // 判空
    public boolean isEmpty(){
        if (this.stack1.isEmpty() && this.stack2.isEmpty()){
            return true;
        }else{
            return false;
        }
    }

    @Override
    public String toString() {
        return "StackToQueue{" +
                "stack1=" + stack1 +
                ", stack2=" + stack2 +
                '}';
    }


    public static void main(String[] args) {
        Stack<Integer> stack1 = new Stack<>();
        Stack<Integer> stack2= new Stack<>();

        StackToQueue<Integer> queue = new StackToQueue<>(stack1, stack2);

        queue.enqueue(1);
        queue.enqueue(2);
        queue.enqueue(3);
        queue.enqueue(4);
        queue.enqueue(5);
        System.out.println(queue); //StackToQueue{stack1=[1, 2, 3, 4, 5], stack2=[]}

        System.out.println(queue.top()); // 1

        System.out.println(queue.dequeue()); // 1
        System.out.println(queue); // StackToQueue{stack1=[], stack2=[5, 4, 3, 2]}

    }
}
Forlogen
关注
专栏目录
(D卷,200分)- 数组二叉树（Java & JS & Python&C）
2301_79779756的博客
08-16 27
给定一个用数组存储的二叉树，树的根节点在下标1，左子节点在下标2N，右子节点在下标2N+1，值为-1表示该位置为空节点。二叉树也可以用数组来存储，给定一个数组，树的根节点的值存储在下标1，对于存储在下标N的节点，它的左子节点和右子节点分别存储在下标2。说明 最小叶子节点的路径为5 8 7 6，注意数组仅存储至最后一个非空节点，故不包含节点“7”右子节点的-1。给定一个数组存储的二叉树，试求从根节点到最小的叶子节点的路径，路径由节点的值组成。一旦找到最小叶子节点，追踪从根节点到该叶子节点的路径。
最新华为OD机试（A卷+B卷+C卷）2024真题快速查找（Java+Python+C++）
最新发布
pitbulline的博客
02-02 782
购买专栏，可以查看本专栏全部内容。购买专栏，可以私信博主获得辅导答疑服务。购买专栏，可以享受题目在线练习服务。
数组和队列相互转化
03-28
更好了解数组和队列在C++应用开发当中使用，明白C++的变量内存结构。
Java实现栈和队列
weixin_33984032的博客
11-09 144
为什么80%的码农都做不了架构师？>>> ...
python 中列表、栈和队列的互相转化
浮云
10-07 1168
列表到队列 class Queue: def __init__(self): self.arr = [] def push(self, num): """入队""" self.arr.append(num) def peek(self): if not self.arr: raise Exception("the Queue is empty") return self.arr
用java数组实现栈
bitcarmanlee的博客
05-30 7086
栈是一种常见的数据结构。如果用一句话来概括栈的特点，估计大部分同学都能脱口而出：后进先出，即先进来的元素保存在栈的最底部，新来的元素则在栈顶堆积，直到栈满为止；而取元素的时候，只能从栈顶取，直到栈空为止。整个过程，与摞书的过程很类似：放书的时候都是摞在最上面，取书的时候也是从最上面开始取。要想取出下面的书，就必须先将上面的书先取走。原理就讲这么多，本身也比较简单。接下来，照例是咱们的口号： tal
python中队列简单使用
One of them的博客
08-23 780
使用队列共享资源 队列: 先进先出. queue被做为公共资源(多进程, 多线程.), 这种时候py自动帮我们加了锁(不管锁的问题). """ 线程的队列. q = queue.Queue() 创建对象. args: Queue(2)表示给参数可以指定队列长度, q.put('str') 添加对象. args: ('str',timeout=2)表示当队列慢了阻塞...
python数据结构：数组、列表、栈、队列及实现
MC_XY的博客
11-25 488
首先，我们要分清楚一些概念和他们之间的关系 数组（array) 表（list) 链表（linked list) 数组链表（array list) 队列（queue) 栈（stack) list列表 array数组 python中内置list数据结构 存放的数据类型可以不同。 但是有个缺点 list存放的是数据的索引也就是指针 这需要数据的原有存储加上数据的指针 增加了消耗。 python中numpy库的array 存放单一类型数据 。 python中数组并不是基本数据类型 但是可以调用array库 或者n
python ctypes 数组_python ctypes库3_如何传递并返回一个数组
weixin_39748928的博客
12-09 724
可以将数组指针传递给dll，但无法返回数组指针，python中没有对应的数组指针类型。如果需要返回数组，需借助结构体。参考ctypes官方文档：https://docs.python.org/3.6/library/ctypes.html#structures-and-unions返回一个结构体例程：# 返回结构体import ctypespath = r'E:\01_Lab\VisualStud...
java自定义栈(数组实现)
渐行渐远
07-11 6820
首先定义一个栈接口，用来描述栈的功能，提供出栈、入栈、获取栈顶元素、判断是否为空以及清空栈；
栈（数组）实现进制的转换
y8350318的专栏
03-24 627
//算法实现2进制的转化 #include #include //求进制，顺序，逆序 void change2(int n) { if (!n) { return; } else { //printf("%d", n % 2);//放在前面为顺序输出 change2(n / 2); printf("%d", n % 2);//放在后面为逆序输出 } }
【Java】栈实现数组
Karen_Ssl的博客
03-15 500
一、思路 单一的栈无法实现数组的功能，因此需要两个栈，分别是s1和s2. 如果两个栈都是空的，那么第一次把数字入到s1，每次都放入s1中. 如果s2是空的，那么把s1当中的元素全部导入到s2中，如果s2不是空的，直接将s2的栈顶元素pop（）。 二、代码 package test; import java.util.Stack; //栈实现队列 public class StackImplQu...
栈(数组简单实现)
MrQ_zh的博客
11-20 295
问题：逆波兰表达式又叫做后缀表达式。在通常的表达式中，二元运算符总是置于与之相关的两个运算对象之间，这种表示法也称为中缀表示 eg：  a+b ---> a,b,+  a+(b-c) ---> a,b,c,-,+  a+(b-c)*d ---> a,b,c,-,d,*,+  a+d*(b-c)--->a,d,b,c,-,*,+  a=1+3 ---> a=1,3 + 求：1 2 +
Python 通过List 实现队列的操作
Python+大数据+数据分析+自动化+Vue组件开发
09-18 1392
队列与栈数据结构是使用频率较高的技术知识，今天与大家一起分享Python如何用List 来实现队列操作。 队列是什么 队列是一种先进先出（First-In-First-Out，Fifo）的数据结构。 队列是一种列表，不同的是队列只能在队尾插入元素，在队首删除元素。 队列用于存储按顺序排列的数据，先进先出，这点和栈不一样，在栈中，最后入栈的元素反而被优先处理。 Python 实现代码 1 class queue: 2 def __init__(se...
队列Queue--数组实现
weixin_34290000的博客
07-31 260
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队，从队列中删除一个队列元素成为出队。因为队列只允许在一段插入，在另一端删除，所以只有最早进入队...
python队列数组_python数据结构-数组/列表/栈/队列及实现
weixin_36074800的博客
02-11 513
首先我们要分清楚一些概念和他们之间的关系数组(array) 表(list) 链表(linked list) 数组链表(array list) 队列(queue) 栈(stack) list列表array数组python中内置list数据结构 存放的数据类型可以不同。但是有个缺点 list存放的是数据的索引也就是指针 这需要数据的原有存储加上数据的指针 增加了消耗python中numpy...
Python3 线性数据结构 | 数组 栈 队列 链表
kudou1994的博客
08-17 324
数组 python没有数组，但是list可以充当数组的作用 栈 一个开口，后进先出，直接使用list实现 list.append() #push入栈，进入队列末尾 list.pop() #pop出栈，末尾先出 队列 两个开口，先进先出，直接使用list效率很低（insert），使用collections.deque提供的双端队列 我们使用l.append() #最右端入队 和 l.popleft...
Python数据结构之队列——使用数组实现队列
m0_51894865的博客
02-03 1230
Python数据结构之队列——使用数组实现队列 队列：一种受限制的线性表，ADT类型，仅支持队头删除数据和队尾添加数据。 具有先进先出，后进后出的特性。 适合领域：计算机模拟、CPU特性、外围设备的联机并发性质、树的广度优先搜索 (BFS)。 优点：只需要对 front(队首) 和 rear(队尾) 指针来进行操作数据。 缺点：数组队列容易产生假溢出现象。 假溢出: rear 指针添加数据时会超过数据大小范围，导致 rear 指向其他区域。 代码部分(5组) 创建队列 front = -1 rear
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值