Java尚硅谷数据结构与算法学习记录(6)-栈的两种模拟实现

最新推荐文章于 2024-09-19 23:18:29 发布
最新推荐文章于 2024-09-19 23:18:29 发布
阅读量132 收藏 2
点赞数 1
文章标签： 数据结构 算法 java 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38715538/article/details/106835121
版权

数组模拟栈

思路分析：

  1. 定义一个数组stack模拟栈
  2. 定义top指向栈顶 初始化为-1
  3. 入栈（push）操作：top++；stack[top]=data;
  4. 出栈（pop）操作：int value=stack[top]；top–；return value；

代码实现：

package com.lylicoo.stack;

//数组模拟栈的基本操作的实现
public class ArrayStack {
    private int maxSize;//栈的最大容量
    private int[] stack;//定义一个数组 栈的数据存在数组中
    private int top=-1;//指向栈顶

    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        stack=new int[maxSize];
    }
    //栈满
    public boolean isFull(){
        return top==maxSize-1;
    }
    //栈空
    public boolean isEmpty(){
        return top==-1;
    }
    //入栈
    public void push(int data){
        if (isFull()){
            System.out.printf("栈满，无法入栈");
            return;
        }else{
            top++;
            stack[top]=data;
        }
    }
    //出栈
    public int pop(){
        if (isEmpty()){
            throw new RuntimeException("栈空");
        }else{
            int value=stack[top];
            top--;
            return value;
        }
    }
    //显示栈
    public void show(){
        if (isEmpty()){
            throw new RuntimeException("栈空");
        }else{
            for (int i=top;i>=0;i--){
                System.out.printf("stack[%d]=%d\n",i,stack[i]);
            }
        }
    }








}

测试：

package com.lylicoo.stack;

import java.util.Scanner;

public class ArrayStackDemo {
    public static void main(String[] args) {
        //测试
        //创建ArrayStack的对象表示栈
        ArrayStack stack = new ArrayStack(4);
        String key="";
        boolean loop=true;
        Scanner sc = new Scanner(System.in);
        while(loop){
            System.out.println("show:显示栈");
            System.out.println("exit:退出栈");
            System.out.println("push:入栈");
            System.out.println("pop:出栈");
            System.out.println("请输入您的选择：");
            key=sc.next();
            switch(key){
                case "show":
                    try {
                        stack.show();
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case "push":
                    System.out.println("请输入您要入栈的数据：");
                    int data=sc.nextInt();
                    stack.push(data);
                    break;
                case "pop":
                    try{
                        int value=stack.pop();
                        System.out.println("出栈的数据是："+value);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case "exit":
                    loop=false;
                    break;
                default:
                    break;
            }
        }
    }
}

单链表模拟栈

思路分析：

  1. 因为是动态链表存储 故无需考虑栈满情况
  2. 创建节点类，创建一个top指针指向栈顶，初始化为null
  3. 入栈：将节点添加到链表表尾，并将top指针指向这个节点
  4. 出栈：将最后的节点出栈(将最后的节点从链表中删除)，并将top指向最后节点的前一个节点
  5. 遍历：栈的遍历是先进后出，而链表是先进先出，所以可以通过反转链表再打印的方式实现栈的遍历。

代码实现：

package com.lylicoo.stack;

import com.lylicoo.linkedlist.singlelinkedlist.HeroNode;

//单链表模拟栈
public class SingleLinkedListStack {
    private Node top = null;// 指向栈顶节点
    //定义一个头节点
    Node head = new Node(0);
    //栈空
    public boolean isEmpty() {
        return top == null;
    }

    //入栈
    public void push(Node node) {
        //临时变量，保存头节点
        Node temp = head;
        while (true) {
            if (temp.next == null) {
                break;//已找到最后一个节点
            }
            temp = temp.next;
        }//退出循环时说明已经找到最后一个节点
        //将新节点添加到链表的最后
        temp.next = node;
        top = node;
    }

    //出栈  每次都将栈顶（top指向的）节点出栈
    public Node pop() {
        //临时变量，保存头节点
        Node temp = head;
        //出栈后 top需要向前移动 故借助辅助指针
        Node tmp=top;
        //top向前移动 故要先遍历找到top节点的前一个节点
        while(true){
            if (temp.next==top){
                break;
            }
            temp=temp.next;
        }//退出循环时说明已经找到top节点的前一个节点
        temp.next=top.next;//删除top节点
        //将top指针指向该节点
        top=temp;
        return tmp;
    }

    //显示栈  从栈顶开始显示 即 从链表表尾开始遍历链表
    //采取反转链表后打印的方法
    public void show() {
       //判断链表是否为空
        if (head.next==null){
            System.out.println("链表为空");
            return;
        }
        reverseList(head);//反转链表
        Node temp=head.next;
        while(true){
            if (temp==null){
                break;
            }
            System.out.println(temp);
            temp=temp.next;
        }
    }
    //反转链表
    private void reverseList(Node head) {
        if (head.next == null || head.next.next == null) {//链表为空或只有一个节点 不必反转
            return;
        }
        Node resHead = new Node(0);
        Node cur = head.next;//辅助变量
        Node next = null;//用来保存cur的下一个节点  防止断链
        while (cur != null) {
            next = cur.next;
            cur.next = resHead.next;//cur是被取下的节点 头插法
            resHead.next = cur;//以上两行是头插法标配 画图更好理解！
            cur = next;//cur后移 实现遍历
        }
        head.next = resHead.next;
    }
}
//定义节点
class Node {
    public int value;//值
    public Node next;//指向下一节点

    public Node(int value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "Node{" +
                "value=" + value +
                ", next=" + next +
                '}';
    }
}

测试：

package com.lylicoo.stack;

import java.util.Scanner;

public class SingleLinkedListStackDemo {
    public static void main(String[] args) {
        SingleLinkedListStack stack = new SingleLinkedListStack();
        String key = "";
        boolean loop = true;
        Scanner sc = new Scanner(System.in);
        while (loop) {
            System.out.println("show:显示栈");
            System.out.println("exit:退出栈");
            System.out.println("push:入栈");
            System.out.println("pop:出栈");
            System.out.println("请输入您的选择：");
            key = sc.next();
            switch (key) {
                case "show":
                    try {
                        stack.show();
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case "push":
                        System.out.println("请输入您要入栈的数据：");
                        int data = sc.nextInt();
                        Node node = new Node(data);
                        stack.push(node);
                    break;
                case "pop":
                    try {
                        Node res = stack.pop();
                        System.out.println("出栈的节点是：" + res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case "exit":
                    sc.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
    }
}
liililiya
关注
尚硅谷 java数据结构与算法 学习笔记(二)
weixin_43691773的博客
12-15 1766
查找算法 二分查找算法 代码实现 package com.luyi.search; import java.util.ArrayList; import java.util.Arrays; /** * 二分查找法 * 注意 使用二分查找法的前提是 数组时有序的 * @author 卢意 * @create 2020-12-09 15:50 */ public class BinarySearch { public static void main(String[] args) {
尚硅谷 java数据结构与算法 学习笔记(三)
weixin_43691773的博客
12-19 1094
这里写目录标题多路查找树2-3树B树 B+树 B*树 多路查找树 2-3树 插入28 B树 B+树 B*树
尚硅谷Java数据结构学习记录9-用单链表模拟栈的操作
backer
03-05 194
package datacode; import java.util.Stack; /* * 使用单链表模拟栈 * push pop list */ public class SingleLinkListStackDemo { //定义HeroNode,每个HeroNode对象就是一个节点 static class HeroNode{ public int no; ...
Java 单链表实现栈
qq_44173555的博客
04-30 522
最近在B站学习尚硅谷韩顺平老师的数据结构与算法，其中P32节末尾韩老师布置的用单链表实现栈，自己下来实现的代码如下 public class LinkedListStackDemo { public static void main(String[] args) { LinkedListStack stack = new LinkedListStack(); ...
用链表来实现栈
S___Lei的博客
03-24 414
#include #include int num; typedef char ElemType; using namespace std; typedef struct Stack {     ElemType data;     struct Stack *next; }Stack, *StackLink; void Push_Stack(StackLink T
《尚硅谷数据结构》-单向链表面试题练习
Amigo_1997的博客
03-08 200
目录 求单链表中节点的个数 查找单链表中的倒数第k个节点 单链表的反转 从尾到头打印单链表 合并两个有序的单链表 求单链表中节点的个数 //获取单链表的节点个数（如果有头节点，则不统计头节点） public int getLength(HeroNode headNode){ if(headNode.next == null){ return 0; } int length = 0; Her
队列和栈的区别
热门推荐
刘涛的博客
09-15 2万+
队列（Queue）：是限定只能在表的一端进行插入和另一端删除操作的线性表 栈（Stack）：是限定之能在表的一端进行插入和删除操作的线性表 队列和栈的规则 队列：先进先出 栈：先进后出 队列和栈的遍历数据速度 队列：基于地址指针进行遍历，而且可以从头部或者尾部进行遍历，但不能同时遍历，无需开辟空间，因为在遍历的过程中不影响数据结构，所以遍历速度要快 栈...
尚硅谷 java数据结构与算法 学习笔记(一)
weixin_43691773的博客
12-09 5720
这里写目录标题线性结构和 非线性结构稀疏数组SparseArray需求介绍实例代码实现代码执行结果队列介绍数组模拟队列思路代码实现问题数组模拟环形队列环形队列代码实现 线性结构和 非线性结构 稀疏数组SparseArray 需求 记录棋盘的位置 可用用二位数组将它保存 ,但是会发现记录很多没有意义的数据很多空间浪费 可以用稀疏数组进行优化 介绍 稀疏数组就是压缩缩多余的冗余数据 第一行的记录原表的行列数和 非0值的个数 实例 代码实现 package com.luyi.DataStructure
chapter5. Java数据结构与java算法
weixin_56137667的博客
08-04 731
一、数据结构和算法概述 数据结构包括：线性结构和非线性结构。 1线性结构 线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系。 一对一e.g. a[0] = 3; 线性结构有两种不同的存储结构，即顺序存储结构(数组)和链式存储结构(链表)。 顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的 链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息（链表可以充分利用碎片内存） 线性结构常见的有：数组、队列、链表和栈，后面我们会详细讲解.
02 单链表 【数据结构与算法学习笔记(Java)】
小智爱学习的博客
03-09 224
数据结构与算法（Java实现） 我的学习资料： 视频：尚硅谷Java数据结构与java算法（Java数据结构与算法） 书籍：《大话数据结构》 笔记中包括学习的内容，代码，同时自己总结了知识点速记（部分会带页内跳转，可点击跳转）供快速回顾和记忆学到的知识点。 三、链表（Linked List）之单链表 3.1链表和单链表的定义 线性表的顺序存储结构（即顺序表）用一段地址连续的存储单元依次存储线性表的数据元素，优点是可以通过索引快速找到对应元素，实现了随机访问，但是扩容比较麻烦（需要再重新分配一个更大的空间，
重新学习数据结构和算法（持续更新）
qq_42805101的博客
04-23 269
文章目录前言第一章 先给大家打个气第二章 初识数据结构1.线性结构和非线性结构2.总结 前言 为什么写这篇文章：数据结构和算法是程序的灵魂，强烈建议大家认真学好这门学科，无论是对今后的工作生活、还是找工作亦或者是自己的思维都有巨大的帮助。相信我，一定要好好学，即将走入社会的我决定好好补一补大学期间没认真学的这门课。我是我重学《数据结构和算法》的学习笔记，java版本，在这里分享给大家，互帮互助共同进步。2021年4月23日开始编写，后期持续更新。 适宜人群：认同数据结构和算法很重要的同学 你将学习到：常见
数据结构及算法笔记
热爱编写程序的药学在读书
09-30 449
来吧，不管是自学，还是科班，咱都逃不过这个问题，接下里开始学习算法。 视频资料是来自于尚硅谷的课程视频和笔记 第一部分是前言部分 一、数据结构介绍 1、线性结构 线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系 线性结构有两种不同的存储结构，即顺序存储结构(数组)和链式存储结构(链表)。顺序存储的线性表称为顺序 表，顺序表中的存储元素是连续的 链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地 址信息 线性结构常见的有：数组、队列、链表和
Pandas_数据结构详解
2201_75415080的博客
09-19 858
DataFrame是一个表格型的==结构化==数据结构，它含有一组或多组有序的列（Series），每列可以是不同的值类型（数值、字符串、布尔值等）。DataFrame是Pandas中最基本的数据结构，Series的许多属性和方法在DataFrame中也一样适用.两个Series之间计算时，索引值相同的元素之间会进行计算；索引值不同的元素的计算结果会用NaN值(缺失值)填充。两个Series之间计算时，索引值相同的元素之间会进行计算；索引值不同的元素的计算结果会用NaN值(缺失值)填充。
数据结构之二叉树遍历
weixin_44021343的博客
09-19 171
先遍历左子树，再遍历右子树，最后输入父节点：D、E、B、F、G、C、A。先遍历左子树，再输出父节点，再遍历右子树：D、B、E、A、F、C、G。先输入父节点，再遍历左子树和右子树：A、B、D、E、C、F、G。
数据结构——二叉树堆的专题
imaima666的博客
09-19 473
如果有一个关键码的集合K = {K0 ，K1 ，K2 ，K3…) i = 0，1， 2…，则称为(或将。
数据结构--顺序表的创建和增删改查操作
KBDYD1010的博客
09-19 284
通过编写学生管理系统掌握顺序表的创建、增删改查等功能
Java 中 Map 常用类和数据结构详解
最新发布
J老熊
09-19 748
在Java编程中，Map是一种重要的数据结构，广泛应用于各种场景，Map实现了键值对（key-value）的存储方式，使得开发者能够快速检索、更新和操作数据。本篇文章将详细讲解Java中常用的Map类及其底层数据结构，并通过电商交易系统中的实际应用场景来分析每种Map的使用场景和区别。
数据结构——LeetCode刷题:7. 整数反转,66. 加一,1. 两数之和
u014114223的博客
09-19 792
你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。你可以假设除了整数 0 之外，这个整数不会以零开头。最高位数字存放在数组的首位， 数组中每个元素只存储。如果反转后整数超过 32 位的有符号整数的范围。数组所表示的非负整数，在该数的基础上加一。给你一个 32 位的有符号整数。整数，并返回它们的数组下标。中的数字部分反转后的结果。你可以按任意顺序返回答案。，请你在该数组中找出。
尚硅谷Java数据结构与算法详解：从面试题到实战应用
"这是一份名为《Java数据结构和算法笔记》的文档，由尚硅谷提供，专注于Java编程中的核心数据结构和算法讲解。文档结构清晰，分为多个章节，旨在帮助学习者理解和掌握数据结构和算法的基础知识，以及它们在实际编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值