精华内容
下载资源
问答
  • 例如,序列 {1,2,3,4,5} 是某压栈序列,序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列,但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。 示例 1: 输入:pushed = [1,2,3,4,5], popped = [4,5,3,2,1] 输出...

    输入两个整数序列,第一个序列表示栈的压入顺序,请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如,序列 {1,2,3,4,5} 是某栈的压栈序列,序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列,但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。

    示例 1:

    输入:pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
    输出:true
    解释:我们可以按以下顺序执行:
    push(1), push(2), push(3), push(4), pop() -> 4,
    push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1
    示例 2:

    输入:pushed = [1,2,3,4,5], popped = [4,3,5,1,2]
    输出:false
    解释:1 不能在 2 之前弹出。

    class Solution {
    
        public boolean validateStackSequences(int[] pushed, int[] popped) {
            Deque<Integer> stack = new LinkedList<>();
            int pushIndex = 0;
            int popIndex = 0;
            while(pushIndex<pushed.length&&popIndex<popped.length){
                if(pushed[pushIndex]==popped[popIndex]){    //如果当前两个数相等
                    //进栈,出栈
                    pushIndex++;
                    popIndex++;
                }else{  //如果当前两个不相等
                    if(stack.isEmpty()){    //判断栈是否为空
                        //栈为空,直接压栈
                        stack.push(pushed[pushIndex++]);
                    }else{
                        //栈不为空,判断栈顶元素是否和popIndex指向的元素是否相等
                        if(stack.peek()==popped[popIndex]){
                            //如果相等,出栈,popIndex++
                            stack.pop();
                            popIndex++;
                        }else{
                            //如果不相等,入栈,pushIndex++
                            stack.push(pushed[pushIndex++]);
                        }
                    }
                }
            }
            //如果栈不为空的话,直接弹一个,判断一个是否相等
            while(!stack.isEmpty()){
                if(stack.pop()!=popped[popIndex++]){    //如果不相等,直接返回false
                    return false;
                }
            }
            return true;
        }
    }
    
    展开全文
  • java压栈和

    千次阅读 2020-01-14 10:57:57
    一、的存放 局部变量 堆中对象的引用(对象在堆内存中的 地址) 全局变量存储在堆中 局部变量存储在的属性:每条线程都有一个独立的,在线程创建时创建 二、的操作 的存取顺序是先进后出,后进先出...

    好好学习,天天向下

    一、栈的存放

    • 局部变量
    • 堆中对象的引用(对象在堆内存中的 地址)
    • 全局变量存储在堆中
    • 局部变量存储在栈中
    • 栈的属性:每条线程都有一个独立的栈,在线程创建时创建

    二、栈的操作

    栈的存取顺序是先进后出,后进先出,就像是桶装羽毛球,先放进去的后拿出来

    public class storage {
        //先规定栈的最大容量
        Object[] objs;
        //获取当前栈容量
        int size;
    
        public void SQ(int MaxLen) {
            this.objs = new Object[MaxLen];
        }
        
        //进行压栈操作(就是在栈中存入内容)
        public void push(Object x) {
         //先给当前指针位置赋值,然后指针变大
            System.out.println("压栈操作,压入内容为" + (objs[size++] = x)); 
       }
    
        //弹栈操作
        public void popu() {
        //获取栈顶数据,然后弹出栈中,栈容量减少
            System.out.println("弹出栈顶内容:" + objs[size - 1]);
            size--;
        }
    
        //获取栈内所有数据
        public void getAllStack() {
            System.out.println("栈顶到栈底所有数据为");
            for (int i = size - 1; i >= 0; i--) {
                System.out.println(objs[i] + " ");
            }
        }
    }
    
    public class run {
        public static void main(String[] args) {
            storage storage = new storage();
            storage.SQ(20);
            storage.push(1);
            storage.push(2);
            storage.push(3);
            storage.push(4);
            storage.getAllStack();
            storage.popu();
            storage.popu();
            storage.getAllStack();
        }
    }
    

    三、栈和栈帧

    • java栈以帧为单位来保存线程的状态
    • JVM对java栈只进行两种操作——>一帧为单位的压栈和弹栈
    展开全文
  • 这里写目录标题要求:1定义属性1.1定义Object类型一维数组1.2栈帧,永远指向部元素2压栈2.1(1)(2)本质上一样,注意分清楚是先自加1,在赋值2.2注意:所有的System.out.println()方法执行时,如果输出饮用的...

    要求:

    1.栈可以存储java中的任何引用类型的数据
    2.在这个栈中提供push方法模拟压栈(栈满了,要有提示信息)
    3.在栈中提供给pop方法模拟弹栈。(栈空了。也要有提示信息)
    4.编写测试程序,new 栈对象,调用push 和pop方法来模拟压栈弹栈的动作
    5.假设栈的默认初始化容量是10,(请注意无参构造方法的编写方式)

    栈类:MyStcck

    1定义属性

    1.1定义Object类型一维数组

    向栈当中存储元素,我们这里使用一维数组模拟。存到栈中,就表示存储到数组中
    因为数组是我们学习java的第一个容器
    为什么选择Object类型数据?因为这个栈可以存储java中任何引用类型的数据
    new Animal()对象可以放进去,new person()对象也可以放进去。因为Animal和Person的超级父类就是Object
    包括String也可以存储进去,因为String父类也是Object

    private Object[] elements;  //属性私有化
    

    1.2栈帧,永远指向栈元素

    那么这个默认称呼是指应该是多少。注意:最初的栈是空的,一个元素都没有
    private int index = 0;  //如果index采用0,表示栈帧指向了底部元素的上方
    private int index = -1;  //如果index采用1,表示栈帧指向了底部元素
    
      private int index = -1;
    

    2压栈

    2.1(1)和(2)本质上一样,注意分清楚是先自加1,在赋值

    (1)

    this.index++;
    elements[index] = obj; 
    

    (2)

    elements[++index] = obj 
    

    2.2注意:所有的System.out.println()方法执行时,如果输出引用的话,自动调用引用的toString()方法

    //声明:所有的System.out.println()方法执行时,如果输出饮用的话,自动调用引用的toString()方法
            System.out.println("压栈"+ obj + "成功,栈帧指向" + index);
    

    2.3完整压栈代码

    public void push(Object obj){
            if(this.index >= this.elements.length - 1){
                System.out.println("压栈失败,栈已满!");
            }
            //程序能走到这里,说明栈没满
            this.index++;
            elements[index] = obj;         //以上两句可以写成elements[++index] = obj  先自加一后赋值
            //再声明一次:所有的System.out.println()方法执行时,如果输出引用的话,自动调用引用的toString()方法
            System.out.println("压栈"+ obj + "成功,栈帧指向" + index);
        }
    

    2.4测试结果

    在这里插入图片描述

    3弹栈

    public void pop(){
            if(index <0){
                System.out.println("弹栈失败,栈已空!");
                return;
            }
            //程序能够执行到此处,说明栈没有空
            System.out.print("弹栈" + elements[index] + "元素成功");
            //栈帧向下移动一位
            index--;
            System.out.println("栈帧指向" + index);
        }
    

    4完整代码

    4.1栈类

    package com.power.Javase.array.homework;
    /*
    要求:
    1.栈可以存储java中的任何引用类型的数据
    2。在这个栈中提供push方法模拟压栈(栈满了,要有提示信息)
    3.在栈中提供给pop方法模拟贪占。(栈空了。也要有提示信息)
    4。编写测试程序,new 站对象,调用push 和pop方法来模拟压栈弹栈的动作
    5.假设栈的默认初始化容量是10,(请注意无参构造方法的编写方式)
     */
    
    public class MyStcck {
        //向栈当中存储元素,我们这里使用一维数组模拟。存到栈中,就表示存储到数据中心
        //因为数组是我们学习java的第一个容器
        //为什么选择Object类型数据?因为这个站可以存储java中任何引用类型的数据
        // new Animal()对象可以放进去,new person()对象也可以放进去。因为Animal和Person的超级父类就是Object
        //包括String也可以存储进去,因为String父类也是Object
        private Object[] elements;  //属性私有化
    
        //栈帧,永远指向栈部元素
        //那么这个默认称呼是指应该是多少。注意:最初的栈是空的,一个元素都没有
        //private int index = 0;  //如果index采用0,表示栈帧指向了顶部元素的上方
        //private int index = -1;  //如果index采用1,表示栈帧指向了顶部元素
        private int index = -1;
    
        public MyStcck() {
            //一维数组动态初始化
            //栈的默认初始化容量是10
            this.elements = new Object[10];
            //给index动态初始化
            this.index = -1;
        }
    
        /**
         * 压栈的方法
         *
         * @param obj
         */
        public void push(Object obj){
            if(this.index >= this.elements.length - 1){
                System.out.println("压栈失败,栈已满!");
            }
            //程序能走到这里,说明栈没满
            this.index++;
            elements[index] = obj;         //以上两句可以写成elements[++index] = obj  先自加一后赋值
            //再声明一次:所有的System.out.println()方法执行时,如果输出饮用的话,自动调用引用的toString()方法
            System.out.println("压栈"+ obj + "成功,栈帧指向" + index);
        }
    
        /**
         * 从数组中望外取元素
         * 每去一个元素,栈帧减一
         */
        public void pop(){
            if(index <0){
                System.out.println("弹栈失败,栈已空!");
                return;
            }
            //程序能够执行到此处,说明栈没有空
            System.out.print("弹栈" + elements[index] + "元素成功");
            //栈帧向下移动一位
            index--;
            System.out.println("栈帧指向" + index);
        }
    
    
    
        //set和get也许用不上,但是你必须写上,这是规矩
        //封装:第一步:属性私有化,第二步:对外提供setter和getter
        public Object[] getElements() {
            return elements;
        }
    
        public void setElements(Object[] elements) {
            this.elements = elements;
        }
    }
    
    

    4.2测试类

    package com.power.Javase.array.homework;
    
    public class MyStackTest {
        public static void main(String[] args) {
            //创建一个栈对象,初始化容量是10个
            MyStcck stack = new MyStcck();
    
            //调用方法压栈
            stack.push(new Object());
            stack.push(new Object());
            stack.push(new Object());
            stack.push(new Object());
            stack.push(new Object());
            stack.push(new Object());
            stack.push(new Object());
            stack.push(new Object());
            stack.push(new Object());
            stack.push(new Object());
    
            //压这个元素失败了
            //stack.push(new Object());
            //System.out.println("================================");
    
            stack.pop();
            stack.pop();
            stack.pop();
            stack.pop();
            stack.pop();
            stack.pop();
            stack.pop();
            stack.pop();
            stack.pop();
            stack.pop();stack.pop();
    
    
        }
    }
    
    

    4.3执行结果

    可以看出栈的特点,后进先出

    在这里插入图片描述

    展开全文
  • Java中使用数组模拟压栈和 stack的知识 是一种数据结构 压栈:将元素放入中 弹:将元素移除中 栈帧:指向栈顶元素 栈顶:最上面的那个元素 特点:先进后出,后进先出 Java实现 MyStack类 ...

    Java中使用数组模拟栈的压栈和弹栈

    栈stack的知识

    栈是一种数据结构

    压栈:将元素放入栈中

    弹栈:将元素移除栈中

    栈帧:指向栈顶元素

    栈顶:栈最上面的那个元素

    特点:先进后出,后进先出

    Java实现

    MyStack类

    package com.tqw_zg.stack;
    //提供一个数组来存储栈中的元素
    //Object[] object;
    
    // 栈帧(永远指向栈顶部的元素)
    // 每加1个元素,栈帧+1
    // 每减1个元素,栈帧-1
    
    // 构造方法
    // 构造方法是不是应该给一维数组一个初始化容量。
    public class MyStack {// 栈类
        private Object[] object;//数组,模拟栈
        private int index = -1;//栈帧
    
        public MyStack() {//无参构造方法,直接赋数组大小为10
            this.object = new Object[10];//创建大小为10的Object类的数组,课储存各种类型的数据
        }
    
        public MyStack(int num) {//有参构造方法,传入一个数,作为数组的大小
            this.object = new Object[num];//创建大小为num的Object类的数组,课储存各种类型的数据
        }
    //setter and getter
        public Object[] getObject() {
            return object;
        }
    
        public void setObject(Object[] object) {
            this.object = object;
        }
    

    压栈

     // push方法(push方法压栈)
        // 压栈表示栈中多一个元素。
        // 但是栈如果已满,压栈失败。
        // 这个方法的参数以及返回值类型自己定义。
        public void push(Object obj) {
            if (getObject().length - 1 <= index) {
                System.out.println("压栈失败");
            } else {
                object[++index] = obj;//0,1,2,3,4,5,6
                System.out.println("压栈成功");
                if (getObject().length - 1 == index) {
                    System.out.println("栈满了");
                }
            }
        }
    

    弹栈

    // pop方法(pop方法弹栈)
        // 弹栈表示栈中少一个元素。
        // 但是栈如果已空,弹栈失败。
        // 这个方法的参数以及返回值类型自己定义。
        public void pop() {
            if (index == -1) {
                System.out.println("弹栈失败");
            } else {
                object[index--] = null;
                System.out.println("弹栈成功");
                if (index == -1) {
                    System.out.println("栈空了");
                }
            }
        }
    

    总的MyStack类

    public class MyStack {// 栈类
        private Object[] object;//数组,模拟栈
        private int index = -1;//栈帧
    
        public MyStack() {//无参构造方法,直接赋数组大小为10
            this.object = new Object[10];//创建大小为10的Object类的数组,课储存各种类型的数据
        }
    
        public MyStack(int num) {//有参构造方法,传入一个数,作为数组的大小
            this.object = new Object[num];//创建大小为num的Object类的数组,课储存各种类型的数据
        }
    //setter and getter
        public Object[] getObject() {
            return object;
        }
    
        public void setObject(Object[] object) {
            this.object = object;
        }
        //压栈
         public void push(Object obj) {
            if (getObject().length - 1 <= index) {
                System.out.println("压栈失败");
            } else {
                object[++index] = obj;//0,1,2,3,4,5,6
                System.out.println("压栈成功");
                if (getObject().length - 1 == index) {
                    System.out.println("栈满了");
                }
            }
        }
        //弹栈
         public void pop() {
            if (index == -1) {
                System.out.println("弹栈失败");
            } else {
                object[index--] = null;
                System.out.println("弹栈成功");
                if (index == -1) {
                    System.out.println("栈空了");
                }
            }
        }
    }
    

    测试代码

    package com.tqw_zg.stack;
    
    public class Test {
        public static void main(String[] args) {
            MyStack myStack=new MyStack(7);
            myStack.push("i");
            myStack.push(" love");
            myStack.push(" tqw  ");
            myStack.push(3);
            myStack.push("b");
            myStack.push(4);
            myStack.push("c");
            myStack.push(1);
            for(int i=0;i<7;i++) {
                System.out.print(myStack.getObject()[i]);
            }
            System.out.println();
            myStack.pop();
            myStack.pop();
            myStack.pop();
            myStack.pop();
            myStack.pop();
            myStack.pop();
            myStack.pop();
            myStack.pop();
            myStack.pop();
        }
    }
    

    测试结果

    压栈成功
    压栈成功
    压栈成功
    压栈成功
    压栈成功
    压栈成功
    压栈成功
    栈满了
    压栈失败
    i love tqw  3b4c
    弹栈成功
    弹栈成功
    弹栈成功
    弹栈成功
    弹栈成功
    弹栈成功
    弹栈成功
    栈空了
    弹栈失败
    弹栈失败
    
    Process finished with exit code 0
    

    感悟

    1、在创建数组时必须先给定数组的大小;

    2、Object类的数组可以输入任何类型的数据;

    3、一般栈帧初始化为-1

    展开全文
  • //index为栈帧,index的数据表示当前中有多少个元素 //当index=objs.length-1的时候,表示中元素已满 //当index=0的时候,表示中元素为0个 //默认的空间为10个 public MyStack() { .
  • 堆栈在内存中的压栈和工作原理 一.概述:  网上关于堆栈的文章很多,但多为不祥尽.趁清明假期整理验证下.VC编译,XP平台. 调用函数入栈过程分以下5步: 1.压参数(右向左)-->2.压调用完函数后的第一条汇编...
  • 压栈,弹

    2019-12-04 14:39:06
    /** * @author huimou * @Date: 2019/11/6 * @Description: util * @version: jdk 1.8 */ public class Stack { public int[] elements; ... public Stack(){ this.elements=new int[0];......
  • 希望一些对于此类作业烦恼的同级生有些许帮助,也可以在评论区提供帮助修改以及错误的地方! import java.util.Scanner; public class MoveTest01 { //局部变量供方法的遍历数组时使用 static int i; //创建...
  • 顺序特点:FILO(先进后出) 计算顺序的长度方法:length=s.top-s.base; 时间复杂度:O(1) #include <stdio.h> #include <iostream> using namespace std; #define sElemType int //预定义...
  • 可以用顺序表链表实现,在这里用链表实现最基本的入栈,弹操作。 代码 #include<iostream> #include<cstdlib> using namespace std; typedef struct data { int data; }datas; struct stack { ...
  • 函数压栈退的过程 C++程序在运行过程中所占用的内存空间主要分为五个部分: 区(stack): 是一种连续储存的数据结构,具有先进后出的性质。由编译器自动分配与释放,存放为运行时函数分配的局部变量、函数参数、...
  • 顺序压栈和出栈

    2017-10-19 00:45:42
    //存放元素的数组 int top; //栈顶指针,为栈顶元素在数组的下标 }; int main() { SeqStack a; for(int i= 1 ; i ; i++) { a.Push(i);} for(int i = 0; i ; i++) { int k = 0; k = a.Pop()...
  • //创建类 用一维数组模拟数据结构 public class Stack { Object[] obj;//属性 ,模拟的容量,由构造方法赋值容量大小。objec可以存储任何数据类型 int index;//模拟栈帧,栈帧等于obj容量时,表示满并...
  • //stackarray.c #include #define MaxSize 10 int Stack[MaxSize]; int top=-1; void push(int value) { int i;...printf("\nThe data of the stack(before the push stack) is :\n")
  • 文章目录前言常见指令待分析代码release 模式下分析 (单纯的压栈过程)debug 模式下分析 (主要是看rep 指令初始化的问题)总结 前言 首先知道release下就算关闭优化也dubug下的汇编差了很多,主要是debug ...
  • 数组模拟压栈和

    2018-07-26 21:50:10
    #include &lt;iostream&gt; #define MAXSIZE 50 using namespace std; bool push(int *stack,int PushX,int &amp;top) {  if(top==MAXSIZE)  {  cout&lt;&lt;"......
  • 给定一个初始为空的栈和一系列压栈、弹栈操作,请编写程序输出每次弹栈的元素。栈的元素值均为整数。 输入格式: 输入第1行为1个正整数n,表示操作个数;接下来n行,每行表示一个操作,格式为1 d或0。1 d表示将整数...
  • 上一个博客,动态方式一样 #include #include #define MAX_STACKSIZE 100 #define OK 1 #define ERROR 0 using namespace std; typedef struct sqstack { int stack_array[MAX_STACKSIZE]; int top; int ...
  • JVM-一个简单的压栈和操作指令解析 i++ 操作 package com.cyc.jvm.c4_RuntimeDataAreaAndInstructionSet; public class TestIPulsPlus { public static void main(String[] args) { int i = 8; i = i++; // ...
  • java使用随机生成1百万个数据,压入栈中,并且弹出数据,打印耗时时间。
  • 的作用 1. 的存放 局部变量 堆中对象的引用(对象在堆内存中的地址) 一个对象的大小无法估计,但是一个对象的引用只占4byte 基本数据类型的变量没有什么存储区域的说法,内存中分为两类进行存储 ...
  • 顺序,利用一组地址连续的存数单元依次存放自底到栈顶的数据元素,同时附设指针top指示栈顶元素在顺序中的位置,压栈、弹、获得栈顶元素、统计中元素个数、打印中元素
  • 给定一个初始为空的栈和一系列压栈、弹栈操作,请编写程序输出每次弹栈的元素。栈的元素值均为整数。 输入格式: 输入第1行为1个正整数n,表示操作个数;接下来n行,每行表示一个操作,格式为1 d或0。1 d表示将整数d...
  • 结构体 typedef struct node//定义结点类型 { int data; struct node * next; }Node; typedef struct myStack//定义结构 { int size; Node * top; }myStack; 创建 void createStack(myStack ** s)//...
  • //把pS所指向的出栈一次,并把出栈的元素存入pVal所指向的变量中,如果出栈失败,返回false,否则返回true bool pop ( PSTACK pS , int * pVal ) { if ( empty ( pS ) ) { //pS本身存放的就是S的地址 ...
  • 使用List集合实现 压栈功能

    千次阅读 2017-07-04 20:05:15
    * 压栈,,弹 * push,,pop * @author RayLu * */ public class StackDemo { @Test public void test1(){ Stack stack = new Stack(); stack.push("小明"); stack.push(new Date()); stack.push("小...
  • 头文件: #ifndef seqstack_H #define seqstack_H const int stacksize=10;... cout对1510执行入栈操作"; s.push(15); s.push(10); cout栈顶元素为:"(); cout执行一次出栈操作"(); cout栈顶元素为:"(); }
  • <script type="text/javascript"> console.log('one'+i); //变量的声明提升 var i= 1;... //压栈 foo(i+1); //递归调用 console.log('three'+i); //出栈 } console.log('four'+i); &
  • 一、不同类型矩阵变换先后顺序、 二、渲染前不设置单位阵、 三、矩阵的压栈和出栈原理分析、 四、矩阵的压栈和出栈代码示例、 五、相关资源

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 68,692
精华内容 27,476
关键字:

压栈和栈