DSA_栈（java数据结构与算法）

最新推荐文章于 2024-06-22 14:08:24 发布
最新推荐文章于 2024-06-22 14:08:24 发布
阅读量147 收藏
点赞数 1
分类专栏： java数据结构与算法（韩顺平老师随堂笔记）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fine____/article/details/120602393
版权

栈 中缀表达式 后缀表达式 逆波兰计算器 表达式求值
关键词由CSDN通过智能技术生成

栈

栈的一个实际需求

请输入一个表达式

计算式:[722-5+1-5+3-3] 点击计算【如下图】

image-20210517195544473

请问: 计算机底层是如何运算得到结果的？ 注意不是简单的把算式列出运算,因为我们看这个算式 7 * 2 * 2 - 5, 但是计算机怎么理解这个算式的(对计算机而言，它接收到的就是一个字符串)，我们讨论的是这个问题。-> 栈

栈的介绍

  1. 栈的英文为(stack)

  2. 栈是一个先入后出(FILO-First In Last Out)的有序列表。

  3. 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。

  4. 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除

  5. 图解方式说明出栈(pop)和入栈(push)的概念

image-20210517195706012

image-20210517195716355

栈的应用场景

  1. 子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。

  2. 处理递归调用：和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。

  3. 表达式的转换[中缀表达式转后缀表达式]与求值(实际解决)。

  4. 二叉树的遍历。

  5. 图形的深度优先(depth 一 first)搜索法。

栈的快速入门

  1. 用数组模拟栈的使用，由于栈是一种有序列表，当然可以使用数组的结构来储存栈的数据内容，下面我们就用数组模拟栈的出栈，入栈等操作。

  2. 实现思路分析,并画出示意图

image-20210517195852869

  1. 代码实现
public class ArrayStackDemo {
    public static void main(String[] args) {
        //测试一下ArrayStack 是否正确
        //先创建一个ArrayStack对象->表示栈
        ArrayStack stack = new ArrayStack(4);
        String key = "";
        boolean loop = true; //控制是否退出菜单
        Scanner scanner = 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 = scanner.next();
            switch (key) {
                case "show":
                    stack.list();
                    break;
                case "push":
                    System.out.println("请输入一个数");
                    int value = scanner.nextInt();
                    stack.push(value);
                    break;
                case "pop":
                    try {
                        int res = stack.pop();
                        System.out.printf("出栈的数据是 %d\n", res);
                    } catch (Exception e) {
                        // TODO: handle exception
                        System.out.println(e.getMessage());
                    }
                    break;
                case "exit":
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }

        System.out.println("程序退出~~~");
    }
}

class ArrayStack {
    private int maxSize;
    private int top;
    private int[] stack;

    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        top = -1;
        stack = new int[maxSize];
    }

    public boolean isEmpty() {
        return top == -1;
    }

    public boolean isFull() {
        return top == maxSize-1;
    }

    public void push(int value) {
        if (isFull()) {
            System.out.println("The stack is full");
            return;
        }
        stack[++top] = value;
    }

    public int pop() {
        if (isEmpty()) {
            throw new RuntimeException("The stack is empty!");
        }
        return stack[top--];
    }

    public int peak() {
        if (isEmpty()) {
            throw new RuntimeException("The stack is empty!");
        }
        return stack[top-1];
    }

    public void list() {
        if (isEmpty()) {
            System.out.println("The stack is empty!");
        }
        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d] = %d\n", i, stack[i]);
        }
    }
}

  1. 关于栈的一个小练习

    课堂练习，将老师写的程序改成使用链表来模拟栈

栈实现综合计算器(中缀表达式)

使用栈来实现综合计算器-

image-20210517201358032

思路分析(图解)

image-20210517201417379

代码实现

[1. 先实现一位数的运算， 2. 扩展到多位数的运算]

package com.atguigu.stack;

public class Calculator {

   public static void main(String[] args) {
      //根据前面老师思路，完成表达式的运算
      String expression = "7*2*2-5+1-5+3-4"; // 15//如何处理多位数的问题？
      //创建两个栈，数栈，一个符号栈
      ArrayStack2 numStack = new ArrayStack2(10);
      ArrayStack2 operStack = new ArrayStack2(10);
      //定义需要的相关变量
      int index = 0;//用于扫描
      int num1 = 0; 
      int num2 = 0;
      int oper = 0;
      int res = 0;
      char ch = ' '; //将每次扫描得到char保存到ch
      String keepNum = ""; //用于拼接 多位数
      //开始while循环的扫描expression
      while(true) {
         //依次得到expression 的每一个字符
         ch = expression.substring(index, index+1).charAt(0);
         //判断ch是什么，然后做相应的处理
         if(operStack.isOper(ch)) {//如果是运算符
            //判断当前的符号栈是否为空
            if(!operStack.isEmpty()) {
               //如果符号栈有操作符，就进行比较,如果当前的操作符的优先级小于或者等于栈中的操作符,就需要从数栈中pop出两个数,
               //在从符号栈中pop出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈
               if(operStack.priority(ch) <= operStack.priority(operStack.peek())) {
                  num1 = numStack.pop();
                  num2 = numStack.pop();
                  oper = operStack.pop();
                  res = numStack.cal(num1, num2, oper);
                  //把运算的结果如数栈
                  numStack.push(res);
                  //然后将当前的操作符入符号栈
                  operStack.push(ch);
               } else {
                  //如果当前的操作符的优先级大于栈中的操作符， 就直接入符号栈.
                  operStack.push(ch);
               }
            }else {
               //如果为空直接入符号栈..
               operStack.push(ch); // 1 + 3
            }
         } else { //如果是数，则直接入数栈
            
            //numStack.push(ch - 48); //? "1+3" '1' => 1
            //分析思路
            //1. 当处理多位数时，不能发现是一个数就立即入栈，因为他可能是多位数
            //2. 在处理数，需要向expression的表达式的index 后再看一位,如果是数就进行扫描，如果是符号才入栈
            //3. 因此我们需要定义一个变量 字符串，用于拼接
            
            //处理多位数
            keepNum += ch;
            
            //如果ch已经是expression的最后一位，就直接入栈
            if (index == expression.length() - 1) {
               numStack.push(Integer.parseInt(keepNum));
            }else{
            
               //判断下一个字符是不是数字，如果是数字，就继续扫描，如果是运算符，则入栈
               //注意是看后一位，不是index++
               if (operStack.isOper(expression.substring(index+1,index+2).charAt(0))) {
                  //如果后一位是运算符，则入栈 keepNum = "1" 或者 "123"
                  numStack.push(Integer.parseInt(keepNum));
                  //重要的!!!!!!, keepNum清空
                  keepNum = "";
                  
               }
            }
         }
         //让index + 1, 并判断是否扫描到expression最后.
         index++;
         if (index >= expression.length()) {
            break;
         }
      }
      
      //当表达式扫描完毕，就顺序的从 数栈和符号栈中pop出相应的数和符号，并运行.
      while(true) {
         //如果符号栈为空，则计算到最后的结果, 数栈中只有一个数字【结果】
         if(operStack.isEmpty()) {
            break;
         }
         num1 = numStack.pop();
         num2 = numStack.pop();
         oper = operStack.pop();
         res = numStack.cal(num1, num2, oper);
         numStack.push(res);//入栈
      }
      //将数栈的最后数，pop出，就是结果
      int res2 = numStack.pop();
      System.out.printf("表达式 %s = %d", expression, res2);
   }

}

//先创建一个栈,直接使用前面创建好
//定义一个 ArrayStack2 表示栈, 需要扩展功能
class ArrayStack2 {
   private int maxSize; // 栈的大小
   private int[] stack; // 数组，数组模拟栈，数据就放在该数组
   private int top = -1;// top表示栈顶，初始化为-1
   
   //构造器
   public ArrayStack2(int maxSize) {
      this.maxSize = maxSize;
      stack = new int[this.maxSize];
   }
   
   //增加一个方法，可以返回当前栈顶的值, 但是不是真正的pop
   public int peek() {
      return stack[top];
   }
   
   //栈满
   public boolean isFull() {
      return top == maxSize - 1;
   }
   //栈空
   public boolean isEmpty() {
      return top == -1;
   }
   //入栈-push
   public void push(int value) {
      //先判断栈是否满
      if(isFull()) {
         System.out.println("栈满");
         return;
      }
      top++;
      stack[top] = value;
   }
   //出栈-pop, 将栈顶的数据返回
   public int pop() {
      //先判断栈是否空
      if(isEmpty()) {
         //抛出异常
         throw new RuntimeException("栈空，没有数据~");
      }
      int value = stack[top];
      top--;
      return value;
   }
   //显示栈的情况[遍历栈]， 遍历时，需要从栈顶开始显示数据
   public void list() {
      if(isEmpty()) {
         System.out.println("栈空，没有数据~~");
         return;
      }
      //需要从栈顶开始显示数据
      for(int i = top; i >= 0 ; i--) {
         System.out.printf("stack[%d]=%d\n", i, stack[i]);
      }
   }
   //返回运算符的优先级，优先级是程序员来确定, 优先级使用数字表示
   //数字越大，则优先级就越高.
   public int priority(int oper) {
      if(oper == '*' || oper == '/'){
         return 1;
      } else if (oper == '+' || oper == '-') {
         return 0;
      } else {
         return -1; // 假定目前的表达式只有 +, - , * , /
      }
   }
   //判断是不是一个运算符
   public boolean isOper(char val) {
      return val == '+' || val == '-' || val == '*' || val == '/';
   }
   //计算方法
   public int cal(int num1, int num2, int oper) {
      int res = 0; // res 用于存放计算的结果
      switch (oper) {
      case '+':
         res = num1 + num2;
         break;
      case '-':
         res = num2 - num1;// 注意顺序
         break;
      case '*':
         res = num1 * num2;
         break;
      case '/':
         res = num2 / num1;
         break;
      default:
         break;
      }
      return res;
   }
   
}

逆波兰计算器

我们完成一个逆波兰计算器，要求完成如下任务:

  1. 输入一个逆波兰表达式(后缀表达式)，使用栈(Stack), 计算其结果

  2. 支持小括号和多位数整数，因为这里我们主要讲的是数据结构，因此计算器进行简化，只支持对整数的计算。

  3. 思路分析

例如: (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 - , 针对后缀表达式求值步骤如下:

1．从左至右扫描，将 3 和 4 压入堆栈；

2．遇到+运算符，因此弹出 4 和 3（4 为栈顶元素，3 为次顶元素），计算出 3+4 的值，得 7，再将 7 入栈；

3．将 5 入栈；

4．接下来是×运算符，因此弹出 5 和 7，计算出 7×5=35，将 35 入栈；

5．将 6 入栈；

6．最后是-运算符，计算出 35-6 的值，即 29，由此得出最终结果

  1. 代码完成
public class PolandNotation {

    public static void main(String[] args) {
        //先定义给逆波兰表达式
        //(30+4)×5-6  => 30 4 + 5 × 6 - => 164
        // 4 * 5 - 8 + 60 + 8 / 2 => 4 5 * 8 - 60 + 8 2 / +
        //测试
        //说明为了方便，逆波兰表达式 的数字和符号使用空格隔开
        //String suffixExpression = "30 4 + 5 * 6 -";
        String suffixExpression = "4 5 * 8 - 60 + 8 2 / +"; // 76
        //思路
        //1. 先将 "3 4 + 5 × 6 - " => 放到ArrayList中
        //2. 将 ArrayList 传递给一个方法，遍历 ArrayList 配合栈 完成计算

        List<String> list = getListString(suffixExpression);
        int res = calculate(list);
        System.out.println(res);
    }


    /**
     * 将一个逆波兰表达式，依次将数据和运算符放到ArrayList中
     * @param suffixExpression
     * @return
     */
    public static List<String> getListString(String suffixExpression) {
        String[] split = suffixExpression.split(" ");
        List<String> list = new ArrayList<>();
        for (String ele : split) {
            list.add(ele);
        }
        return list;
    }

    /**
     * 完成对逆波兰表达式的运算
     * @param list  
     * @return
     */
    public static int calculate(List<String> list) {
        Stack<String> stack = new Stack<>();

        for(String item : list) {
            if (item.matches("\\d+")) {
                stack.push(item);
            } else {
                int num1 = Integer.parseInt(stack.pop());
                int num2 = Integer.parseInt(stack.pop());
                int res = 0;
                // 取出的是String不是char，用“”不用‘’
                if (item.equals("+")) {
                    res = num1 + num2;
                } else if (item.equals("-")){
                    res = num2 - num1;
                } else if (item.equals("*")) {
                    res = num1 * num2;
                } else if (item.equals("/")) {
                    res = num2 / num1;
                }

                stack.push(String.valueOf(res));
            }
        }

        return Integer.parseInt(stack.pop());
    }

}

中缀表达式转换为后缀表达式

大家看到，后缀表达式适合计算式进行运算，但是人却不太容易写出来，尤其是表达式很长的情况下，因此在开发中，我们需要将 中缀表达式转成后缀表达式。

具体步骤如下:

  1. 初始化两个栈：运算符栈 s1 和储存中间结果的栈 s2；

  2. 从左至右扫描中缀表达式；

  3. 遇到操作数时，将其压 s2；

  4. 遇到运算符时，比较其与 s1 栈顶运算符的优先级：

    • 如果 s1 为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
    • 否则，若优先级比栈顶运算符的高，也将运算符压入 s1；
    • 否则，将 s1 栈顶的运算符弹出并压入到 s2 中，再次转到(4-1)与 s1 中新的栈顶运算符相比较；

  5. 遇到括号时：

    • 如果是左括号“(”，则直接压入 s1
    • 如果是右括号“)”，则依次弹出 s1 栈顶的运算符，并压入 s2，直到遇到左括号为止，此时将这一对括号丢弃

  6. 重复步骤 2 至 5，直到表达式的最右边

  7. 将 s1 中剩余的运算符依次弹出并压入 s2

  8. 依次弹出 s2 中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式

举例说明:

将中缀表达式“1+((2+3)×4)-5”转换为后缀表达式的过程如下

image-20210518093146517

因此结果为 :“1 2 3 + 4 × + 5 –”

代码实现中缀表达式转为后缀表达式

思路分析

image-20210518100448228

代码实现

public class PolandNotation {

    public static void main(String[] args) {
        //先定义给逆波兰表达式
        //(30+4)×5-6  => 30 4 + 5 × 6 - => 164
        // 4 * 5 - 8 + 60 + 8 / 2 => 4 5 * 8 - 60 + 8 2 / +
        //测试
        //说明为了方便，逆波兰表达式 的数字和符号使用空格隔开
        //String suffixExpression = "30 4 + 5 * 6 -";

        //思路
        //1. 先将 "3 4 + 5 × 6 - " => 放到ArrayList中
        //2. 将 ArrayList 传递给一个方法，遍历 ArrayList 配合栈 完成计算
        String expression = "1+((2+3)*4)-5";//注意表达式
        List<String> infixExpressionList = toInfixExpressionList(expression);
        System.out.println("中缀表达式对应的List=" + infixExpressionList); // ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
        List<String> suffixExpreesionList = parseSuffixExpressionList(infixExpressionList);
        System.out.println("后缀表达式对应的List" + suffixExpreesionList); //ArrayList [1,2,3,+,4,*,+,5,–]

        System.out.printf("expression=%d", calculate(suffixExpreesionList)); // ?
    }


    /**
     * 将一个逆波兰表达式，依次将数据和运算符放到ArrayList中
     * @param suffixExpression
     * @return
     */
    public static List<String> getListString(String suffixExpression) {
        String[] split = suffixExpression.split(" ");
        List<String> list = new ArrayList<>();
        for (String ele : split) {
            list.add(ele);
        }
        return list;
    }

    /**
     * 完成对逆波兰表达式的运算
     * @param list
     * @return
     */
    public static int calculate(List<String> list) {
        Stack<String> stack = new Stack<>();

        for(String item : list) {
            if (item.matches("\\d+")) {
                stack.push(item);
            } else {
                int num1 = Integer.parseInt(stack.pop());
                int num2 = Integer.parseInt(stack.pop());
                int res = 0;
                // 取出的是String不是char，用“”不用‘’
                if (item.equals("+")) {
                    res = num1 + num2;
                } else if (item.equals("-")){
                    res = num2 - num1;
                } else if (item.equals("*")) {
                    res = num1 * num2;
                } else if (item.equals("/")) {
                    res = num2 / num1;
                }

                stack.push(String.valueOf(res));
            }
        }

        return Integer.parseInt(stack.pop());
    }

    /**
     * 将中缀表达式转成对应的List
     * @param s 中缀表达式字符串
     * @return 返回一个转换完成的list
     */
    public static List<String> toInfixExpressionList(String s) {
        List<String> list = new ArrayList<>();
        int index = 0;
        String str = "";//对多位数的拼接
        char c;         //遍历取出的一位字符
        do {
            c = s.charAt(index);
            // 如果c是一个运算符，直接加入
            if (c < 48 || c > 57) {
                list.add(""+c);//将char转换为字符串
                index++;
            } else {
                // 如果是一个数值，考虑多位数
                str = ""; //置空
                while (index < s.length() && s.charAt(index) >= 48 && s.charAt(index) <= 57 ) {
                    str += s.charAt(index); //拼接
                    index++;
                }
                list.add(str);
            }
        } while (index < s.length());

        return list;
    }

    /**
     * 将中缀表达式转换为后缀表达式
     * @param list  传入List类型的中缀表达式
     * @return  返回List类型的后缀表达式
     */
    public static List<String> parseSuffixExpressionList(List<String> list) {
        Stack<String> stack = new Stack<>();
        List<String> strings = new ArrayList<>();

        for (String item : list) {
            if (item.matches("\\d+")) {
                strings.add(item);
            } else if (item.equals("(")) {
                stack.push(item);
            } else if (item.equals(")")) {
                // peak而不是pop
                while (!stack.peek().equals("(")) {
                    // 将符号依次加到string
                    strings.add(stack.pop());
                }
                // 消除一个括号
                stack.pop();
            } else {
                // item 为运算符，需要比较优先级了,不涉及任何计算，只是转化,使用peak而不是pop
                // 遇到（） 返回的是0
                if ( stack.size()!=0 && Operation.getValue(item) <= Operation.getValue(stack.peek())) {
                    strings.add(stack.pop());
                }
                //这个运算符依旧要压入栈
                stack.push(item);
            }
        }
        // 将stack中剩余运算符依次放入list
        while (stack.size() != 0) {
            strings.add(stack.pop());
        }
        // list顺序遍历即可
        return strings;
    }

}


/**
 * 编写一个类 Operation 可以返回一个运算符 对应的优先级
 */
class Operation {
    private static int ADD = 1;
    private static int SUB = 1;
    private static int MUL = 2;
    private static int DIV = 2;

    public static int getValue(String operation) {
        int result = 0;
        switch (operation) {
            case "+":
                result = ADD;
                break;
            case "-":
                result = SUB;
                break;
            case "*":
                result = MUL;
                break;
            case "/":
                result = DIV;
                break;
            default:
                System.out.println("不存在该运算符" + operation);
                break;
        }
        return result;
    }
}

注意：peak和pop的使用。用于跟栈顶元素的比较等操作应用peak。

逆波兰计算器完整版

完整版的逆波兰计算器，功能包括

  1. 支持 + - * / ( )

  2. 多位数，支持小数,

  3. 兼容处理, 过滤任何空白字符，包括空格、制表符、换页符

说明：逆波兰计算器完整版考虑的因素较多，下面给出完整版代码供同学们学习，其基本思路和前面一样，也 是使用到：中缀表达式转后缀表达式。

代码实现：

奥义喷火恐龙
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
dsa_java:使用Java的数据结构和算法
04-07
在编程领域，数据结构和算法...通过这个"dsa_java"项目，你可以深入学习和实践这些Java数据结构和算法，提升编程技能，并能够更好地理解和解决问题。项目的源代码可以作为学习和参考的实例，加深理论与实际操作的结合。
【数据结构】Java实现栈
qq_53869058的博客
03-23 4880
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈 顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
栈(java)
weixin_51713937的博客
01-16 501
栈 1、数组实现栈 public class StackTest { int top; int arr[]; int maxSize; public StackTest(int maxSize) { super(); this.top = -1; this.maxSize = maxSize; this.arr = new int[maxSize]; } //栈满 public boolean isFull() { return top == maxSize -1;
Java面试题：详细描述Java内存模型中的各个内存区域，以及它们的作用
最新发布
码农超哥的博客
06-22 775
Java内存模型（Java Memory Model，JMM）定义了Java程序中各种变量（尤其是共享变量）的访问规则和可见性，规定了不同线程之间如何通过内存进行交互。
栈和队列(超详细Java实现)
热门推荐
qq_57735833的博客
07-30 1万+
可以看到,先入栈的元素要等后入栈的元素出栈后才能出栈,栈中的元素总是遵循后进先出LIFO（Last In First Out）的原则。生活中的例子:JVM : Java虚拟机Java标准库中提供的栈 可以看到，Stack继承了Vector，Vector是动态的顺序表,与ArrayList类似,不同的是,Vector是线程安全的.实现的方法 输出结果: 2. 入栈(push) 3. 出栈(pop) 4.获取栈顶元素(peek) 5.获取元素个数(getSize) 6.判断栈是否为空(isEm
数据结构和算法-栈
feicongcong的博客
04-02 224
介绍 栈的英文为(stack) 栈是一个先入后出(FILO-First In Last Out)的有序列表。 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元...
数据结构与算法 栈的数组实现
ShaneHolmes
11-17 774
package stack; import java.util.Scanner; public class ArrayStackDemo { public static void main(String[] args) { //测试一下ArrayStack 是否正确 //先创建一个ArrayStack对象->表示栈 ArrayStack stack = new Array...
DSA_Java：Java Java中的数据结构和算法
02-05
注意： 最好的准备方法是克隆此存储库，并在进行过程中将问题标记为...未排序-摩尔投票算法，但使用快速排序后跟count [或] HashMap 5->发生超过n / 2次的元素-已排序 六个->最大差异，使得较小的数字出现在较大的数字
Java DSA extensions:Java数据结构和算法扩展-开源
04-25
DSA扩展包含的类的目的与java.util中提供的类相似。 当前，它包含可排序的列表和映射，以及平衡的二进制搜索树和二进制数组搜索算法。
lb_dsa_cracker:450必须解决算法和数据结构方面的基本问题
03-31
《lb_dsa_cracker:450算法与数据结构基础挑战》 在计算机科学领域，算法和数据结构是核心的基础，对于任何编程语言，包括Java，掌握它们的重要性不言而喻。"lb_dsa_cracker"这个项目似乎是一个旨在帮助开发者提升...
DSA:Java中的数据结构和算法
03-21
数据结构与算法（DSA）是计算机科学的基础，对于任何编程语言来说，理解并掌握它们都是至关重要的。在Java中，DSA的应用尤其广泛，因为Java作为一种强类型、面向对象的语言，其丰富的类库和高效性能使得它成为实现...
如何用Java实现一个简易的栈（Stack）
m0_47455023的博客
06-16 2548
栈是一种典型的“后进先出（LIFO）”的数据结构，下面我们来看下如何使用Java编写一个简易的栈
Java数据结构-栈
QUIXOTIC_的博客
04-02 2046
栈
01 Java基本数据结构之栈实现
R_conqueror的博客
07-10 762
笔者在学习了数据结构后，希望通过Java实现加深印象，如栈、队列、链表等基本结构，可网上这方面资料比较少或者带有各种个人风格不太规范的代码，零零碎碎的，对于我这个初学者而言不太友好，有些地方不是很理解，因此阅读了《Java数据结构和算法》,学习里面的基本数据结构的Java实现，并参考里面代码写下博客记录自己的学习过程。同时文章主要专注于数据结构代码的实现和理解，对于数据结构原理部分不会很详细，希望能对有同样困惑的朋友有个小小的参考。
java栈g_Java栈的三种实现方式(完整版)
weixin_34921325的博客
02-15 380
java什么是栈系统中的堆、栈和数据结构堆、栈不是一个概念。可以说系统中的堆、栈是真实的内存物理区，数据结构中的堆、栈是抽象的数据存储结构。栈：实际上就是满足后进先出的性质，是一种数据项按序排列的数据结构，只能在一端(称为栈顶(top))对数据项进行插入和删除。栈区(stack)— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。栈的优势是，存取速度比堆要...
java怎么写栈_用java语言写一个栈
weixin_35719581的博客
02-26 302
package com.sunny.stack;/** * 栈 * @author zhangdong */ public class MyStack { /*栈顶元素的位置**/ private int top; /*栈的容量**/ private int stackCapacity; /*存放栈中元素的数组**/ private Object[] sta...
【数据结构篇】手摸手带你学会如何手写一个栈
热爱编程、热爱生活、热爱探索
08-04 1167
什么是栈？栈（stack）又名堆栈，它是一种运算受限的线性表，它只允许再表的一端进行插入和删除操作，这一端也称作栈的栈顶（Top），另一端称作栈底（Bottom）。栈的特点：栈中的数据元素先进后出（Last In First Out），所以也称栈为LIFO表栈的分类顺序栈和链栈顺序栈是指使用顺序存储结构实现的栈链栈是指使用链式存储结构实现的栈栈的应用：表达式求值、回溯功能的实现栈的基本操作出栈，获取栈顶的元素（栈中元素减一）入栈，向栈中添加一个元素E peek()取栈顶元素。
java实现入栈push和出栈pop
m566666的博客
12-08 5749
什么叫栈：凡是满足数据先进后出的一种数据结构都叫做栈。 特点：先进后出，后进先出。 数据一般存储在两种数据结构中：1.数组、2.链表 实现入栈出栈可以用链表也可以用数组，数组是最简单的一种方法，我们用数组来实现： 栈的就像杯子一样，模型如下图： 那么我们往栈中放数据时入栈（push）就可以跟数组添加数据一样，假如我们放入数组顺序依次为3,5,7,9，那它在栈中的表现形式如下图，先进入的在栈底，最后进入的在栈顶，当然我们定义的数组会有长度限制，在到达栈顶时我们需...
java语言使用链表实现栈（入栈出栈）
Willow_zhu的博客
03-02 1625
刚开始学习栈的时候，使用数组来实现的。但是，用链表也可以实现，所以就试一下。 栈的特性就是 后进先出，如果用链表来实现的话，将新入栈的元素作为链表的最后一个元素，在出栈的时候就不是很好操作。那这样吧，栈顶对链头，栈底对链尾。这样就好操作了。所以在入栈的时候，将新入栈元素的next指向原来的栈顶元素就可以了。 先创建链表节点类吧 public class Node<T> { ...
Java加密算法详解：DES、AES、RSA、DSA、MD5与SHA
在Java中，`java.security.Signature`类可以用来生成和验证数字签名，支持RSA、DSA等多种算法。 在实际应用中，开发者还需要考虑密钥管理、密钥分发和加密性能等问题。例如，密钥的存储通常需要安全的密钥库，Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值