精华内容
下载资源
问答
  • 永远指向栈部元素2压栈2.1(1)和(2)本质上一样,注意分清楚是先自加1,在赋值2.2注意:所有的System.out.println()方法执行时,如果输出饮用的话,自动调用引用的toString()方法2.3完整压栈代码2.4测试结果3弹栈4...

    要求:

    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执行结果

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

    在这里插入图片描述

    展开全文
  • //index为栈帧,index的数据表示当前中有多少个元素 //当index=objs.length-1的时候,表示中元素已满 //当index=0的时候,表示中元素为0个 //默认的空间为10个 public MyStack() { .
    package MyStack;
    
    public class MyStack {
        Object[] objs;
        int index=0;
        //默认的Object{]数组长度为10;
        //index为栈帧,index的数据表示当前栈中有多少个元素
        //当index=objs.length-1的时候,表示栈中元素已满
        //当index=0的时候,表示栈中元素为0个
    
        //默认的栈空间为10个
        public MyStack() {
            Object[] objs = new Object[10];
        }
    
        //根据传入的int类型数据开辟栈空间
        public MyStack(int x){
            Object[] objs = new Object[x];
        }
    
        //压栈操作,每传入一个未知类型数据,index加1
        public void push(Object objs){
            //检验栈帧的值
            if(index==10){
                System.out.println("栈中的数据已满,请先弹栈再继续操作");
                return;
            }
            //将传入的数据输入一维数组objs
            this.objs[index] = objs;
            index++;
    
        }
    
        //弹栈操作,将栈中的数据清除
        public void pop(){
            if(index==0){
                System.out.println("栈中的数据已空!请输入数据后再弹栈!");
                return;
            }
    
            this.objs[index] = null;
            index -- ;
        }
    }

     

    package MyStack;
    
    public class Test {
        public static void main(String[] args) {
            MyStack myStack = new MyStack();
    
            //myStack的一维数组还未创建?
            System.out.println(myStack.objs);
    
            //---------------------
            System.out.println("=============");
            myStack.objs = new Object[10];
            System.out.println(myStack.objs.length);
            for (int i = 0; i <myStack.objs.length ; i++) {
                System.out.println(myStack.objs[i]+" "+i);
            }
    
            //弹栈操作
            myStack.pop();
            System.out.println("--------------------");
            for (int i = 0; i < 10 ; i++) {
                myStack.push("30.0");
                System.out.println(myStack.index);
            }
            myStack.push("20");
        }
    }
    

           在"MyStack"类中设定了无参传入的情况下,应该创建一个默认长度为10的一维数组,可是在测试的时候,却并没有创建默认一维数组呢?

    展开全文
  • 栈可以用顺序表和链表实现,在这里用链表实现最基本的入栈,弹栈操作。 代码 #include<iostream> #include<cstdlib> using namespace std; typedef struct data { int data; }datas; struct stack { ...

    栈是一种重要的数据结构,是限定仅在表尾进行插入或删除操作的线性表。表尾称为栈顶,表头称为栈底。栈的修改是按照后进先出的原则的。栈可以用顺序表和链表实现,在这里用链表实现最基本的入栈,弹栈操作。

    代码

    #include<iostream>
    #include<cstdlib>
    using namespace std;
    typedef struct data
    {
    	int data;
    }datas;
    struct stack
    {
    	struct stack* base;
    	struct stack* top;
    	struct stack* next;
    	struct data* info;
    };
    stack* InitStack()//初始化
    {
    	struct stack* s;
    	s = new stack;
    	s->base = s->top;
    	return s->base;
    }
    stack* PushStack(struct stack* s)//压栈
    {
    	int e;//栈元素
    	struct stack* base,*top;
    	cout << "请输入入栈数据,输入-1表示结束" << endl;
    	while (true)
    	{
    		cin >> e;
    		if (e == -1)
    			break;
    		else
    		{
    			base = new stack;
    			top = new stack;
    			top->info = new datas;
    			top->info->data = e;
    			top->next = s;
    			s = top;
    		}
    	}
    	return s;
    }
    stack* PopStack(struct stack* s)//弹栈
    {
    	struct stack* s1;
    	cout << "请输入需要弹出的个数" << endl;
    	int n;
    	cin >> n;
    	for(int i=0;i<n;i++)
    	{
    		s1 = new stack;
    		s1 = s;
    		cout << "弹出的是:" << s->info->data << endl;
    		s = s->next;
    		free(s1);
    	}
    	return s;
    }
    int main()
    {
    	struct stack* s,*s1,*s2;
    	s = InitStack();
    	s1 = PushStack(s);
    	s2 = PopStack(s1);
    	system("pause");
    	return 0;
    }
    
    
    

    运行效果

    运行截图

    展开全文
  • java一维数组模拟入栈出栈弹栈 萌新代码,面向过程,勿喷,对栈内存理解不深! 希望一些对于此类作业烦恼的同级生有些许帮助,也可以在评论区提供帮助和修改以及错误的地方! import java.util.Scanner; public ...

    萌新代码面向过程,勿喷,对栈内存理解不深!
    希望一些对于此类作业烦恼的同级生有些许帮助,也可以在评论区提供帮助和修改以及错误的地方!
    思路
    先进后出,优先解决压栈的问题,之后解决弹栈和main方法
    功能
    1)随时模拟压栈
    2)随时模拟弹栈
    3)防止异常和各种错误
    4)随时可以遍历“栈”中存在的变量的方法,压栈弹栈栈帧清晰可见!
    使用演示:
    压栈:
    在这里插入图片描述
    栈满检测:
    在这里插入图片描述
    遍历栈内存和栈帧:

    只要栈中有变量就会输出栈帧:

    弹栈:
    在这里插入图片描述
    栈空检测:(没有变量,栈帧不输出!)
    在这里插入图片描述
    源码:

    import java.util.Scanner;
    public class MoveTest01 {
        //局部变量供栈方法的遍历数组使用
        static int i;
        //创建Object[]数组,作为栈,并且限制“内存上限”为5;
        static Object[] os = new Object[5];
        //创建数组,模拟入栈
        static num[] l = {new A(),new B(),new C(),new D(),new E(),new F()};
    
        public static void main(String[] args) {
            int a =0;//遍历Object[]数组时的控制
            boolean c = true;//控制循环
            boolean d = true;//检测栈内存使用量防止异常
            Scanner s = new Scanner(System.in);
            do {
                System.out.println("===========================");
                System.out.print("请选择”压栈““弹栈”或“列出栈内存中储存的变量指向的方法”,输入“退出”将会结束程序!:");
                String z = s.next();
                //判定用户输入
                if (z.equals("压栈")) {
                    //防止数列超限
                    if(a > (os.length - 1)){
                        d = false;
                        System.out.println("栈内存已满!请弹栈后压栈!");
                    }
                    if(d){
                      //调用num[]数组模拟入栈
                      l[a].leng();
                      a++;
                    }
                    //防止if(d)锁死
                    d = true;
                } else if (z.equals("弹栈")) {
                    //调用pop方法,模拟弹栈,并初始化计数
                    pop();
                    a = 0;
                    i = 0;
                } else if (z.equals("退出")) {
                    //结束do...while循环体
                    c = false;
                } else if (z.equals("列出栈内存中储存的变量指向的方法")) {
                    int index = -1;//创建栈帧
                    if(os[0] == null){
                        System.out.println("栈内没有已装载的变量!");
                    }
                    for (int k = os.length - 1; k > -1; k--) {
                        //判定如果Object[]数组内的各个属性,如果不等于null则输出声明
                        if(!(os[k] == null)){
                            index++;
                            System.out.println("栈内存中已入栈的变量的方法有:" + os[k]);
                        }
                    }
                    //如果栈帧的值不为0,则输出结果
                    if(!(index == -1)){
                        System.out.println(os[index] + "《== 栈帧指向");
                    }
                }
            }while (c);
        }
        //模拟栈
        public static void Zhan(Object o){
            if(i < os.length) {
                //给Object[]数组赋值
                os[i] = o;
                System.out.println("目标:" + os[i] + "的所有变量已压入栈内!");
                i++;
            }
        }
    
        public static void push(String c){
            //接收下面类传来的参数并赋值给Zhan()
            Zhan(c);
        }
    
        public static void pop(){
            //检测数组第一位的值是不是空,如果是则输出消息
            if(os[0] == null){
                System.out.println("栈内没有已装载的变量!无法弹栈!");
            }
            //模拟弹栈
            for(int k = (os.length - 1);k >= 0;k--){
                //遍历数组,将数组内不是null的值全部输出并初始化为null
                if(!(os[k] == null)) {
                    System.out.println(os[k] + "的所有变量:已弹出内存!");
                    os[k] = null;
                }
            }
        }
    }
    class num{
        public void leng(){
            //让下面的方法有个共同的父类,并且调用时统一输出自己的名字给栈
            MoveTest01.push(getClass().getName());
        }
    }
    //即将入方法区的方法,假设里面有变量(也可以直接把这些方法看成变量);
    class A extends num{
        public A() {}
    }
    class B extends num{
        public B() {}
    }
    class C extends num{
        public C() {}
    }
    class D extends num{
        public D() {}
    }
    class E extends num{
        public E() {}
    }
    class F extends num{
        public F() {}
    }
    
    展开全文
  • 压栈弹栈

    2019-12-04 14:39:06
    * 出最后一个栈顶元素 * @return */ public int prop ( ) { if ( elements . length - 1 0 ) { throw new RuntimeException ( "元素为空" ) ; } //取出最后一个元素 int element...
  • 顺序特点:FILO(先进后出) 计算顺序的长度方法:length=s.top-s.base; 时间复杂度:O(1) #include <stdio.h> #include <iostream> using namespace std; #define sElemType int //预定义...
  • java压栈弹栈

    千次阅读 2020-01-14 10:57:57
    一、的存放 局部变量 堆中对象的引用(对象在堆内存中的 地址) 全局变量存储在堆中 局部变量存储在的属性:每条线程都有一个独立的,在线程创建时创建 二、的操作 的存取顺序是先进后出,后进先出...
  • //创建类 用一维数组模拟数据结构 public class Stack { Object[] obj;//属性 ,模拟的容量,由构造方法赋值容量大小。objec可以存储任何数据类型 int index;//模拟栈帧,栈帧等于obj容量时,表示满并...
  • Java中使用数组模拟栈的压栈弹栈 栈stack的知识 栈是一种数据结构 压栈:将元素放入栈中 弹栈:将元素移除栈中 栈帧:指向栈顶元素 栈顶:栈最上面的那个元素 特点:先进后出,后进先出 Java实现 MyStack类 ...
  • cout压栈1弹栈2显示3"; cin>>temp; if(temp==1) { int num; cin>>num; if(!insert_stack(num)) { cout插入失败"; } } else if(temp==2) { int num; if(pop_stack(&num)) ...
  • 给定一个初始为空的栈和一系列压栈弹栈操作,请编写程序输出每次弹栈的元素。栈的元素值均为整数。 输入格式: 输入第1行为1个正整数n,表示操作个数;接下来n行,每行表示一个操作,格式为1 d或0。1 d表示将整数...
  • 堆栈在内存中的压栈弹栈工作原理 一.概述:  网上关于堆栈的文章很多,但多为不祥尽.趁清明假期整理验证下.VC编译,XP平台. 调用函数入栈过程分以下5步: 1.压参数(右向左)-->2.压调用完函数后的第一条汇编...
  • 括号匹配算法该算法的原理:算法的内容:与该算法配套的压栈弹栈算法以及结构体定义: 该算法的原理: 判断是否出现 {【(,出现则压入栈中,如果遇到}】),则弹出上一个栈与其对比。 算法的内容: void ...
  • 给定一个初始为空的栈和一系列压栈弹栈操作,请编写程序输出每次弹栈的元素。栈的元素值均为整数。 输入格式: 输入第1行为1个正整数n,表示操作个数;接下来n行,每行表示一个操作,格式为1 d或0。1 d表示将整数d...
  • 的作用 1. 的存放 局部变量 堆中对象的引用(对象在堆内存中的地址) 一个对象的大小无法估计,但是一个对象的引用只占4byte 基本数据类型的变量没有什么存储区域的说法,内存中分为两类进行存储 ...
  • 使用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("小...
  • JVM-一个简单的压栈弹栈操作指令解析 i++ 操作 package com.cyc.jvm.c4_RuntimeDataAreaAndInstructionSet; public class TestIPulsPlus { public static void main(String[] args) { int i = 8; i = i++; // ...
  • 文章目录前言常见指令待分析代码release 模式下分析 (单纯的压栈弹栈过程)debug 模式下分析 (主要是看rep 指令初始化的问题)总结 前言 首先知道release下就算关闭优化也和dubug下的汇编差了很多,主要是debug ...
  •   ...调用Method01种的print方法,语法格式:类名....当该方法执行完毕,则该方法出战(弹栈)  3.栈特点:先进后出或后进先出   转载于:https://www.cnblogs.com/penphy/p/10717911.html
  • 结构体 typedef struct node//定义结点类型 { int data; struct node * next; }Node; typedef struct myStack//定义结构 { int size; Node * top; }myStack; 创建 void createStack(myStack ** s)//...
  • java使用随机生成1百万个数据,压入栈中,并且出数据,打印耗时时间。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 34,552
精华内容 13,820
关键字:

压栈弹栈