Java数据结构与算法07——通俗易懂的栈

最新推荐文章于 2023-07-14 00:22:15 发布
最新推荐文章于 2023-07-14 00:22:15 发布
阅读量204 收藏 1
点赞数 1
分类专栏： Java 算法 文章标签： java 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012420395/article/details/106076007
版权
Java 同时被 2 个专栏收录
14 篇文章 2 订阅
订阅专栏
算法
4 篇文章 0 订阅
订阅专栏

标签 ： Java 数据结构 算法

作者 ： Maxchen

版本 ： V1.0.1

日期 ： 2020/5/13

目录

栈的简介

栈是一种后进先出的线性表，是最基本的一种数据结构，在许多地方都有应用。

栈是限制插入和删除只能在一个位置上进行的线性表。其中，允许插入和删除的一端位于表的末端，叫做栈顶（top），不允许插入和删除的另一端叫做栈底（bottom）。对栈的基本操作有 PUSH（入栈）和 POP （出栈），前者相当于表的插入操作（向栈顶插入一个元素），后者则是删除操作（删除一个栈顶元素）。栈是一种先进后出（LIFO）的数据结构，最先被删除的是最近压栈的元素。栈就像是一个箱子，往里面放入一个小盒子就相当于压栈操作，往里面取出一个小盒子就是出栈操作，取盒子的时候，最后放进去的盒子会最先被取出来，最先放进去的盒子会最后被取出来，这即是后入先出。下面是一个栈的示意图：

栈.gif-47kB

为什么要用到栈？

栈.png-134.3kB

栈的思路分析和代码实现

第一步： 栈有四种情况，即栈满、栈空、入栈以及出栈，我们用数组来模拟这四种情况，数组的角标是从0开始的，因此栈顶计数需要减1：

private int maxSize; // 栈的大小
private int[] stack; // 数组，数组模拟栈，数据就放在该数组
private int top = -1;// top表示栈顶，初始化为-1

//构造器
public ArrayStack(int maxSize) {
	this.maxSize = maxSize;
	stack = new int[this.maxSize];
}

第二步： 栈满判断（栈顶到达数组的最后一个角标时）

//栈满
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]);
	}
}

栈的代码测试

我们用代码模拟栈的四种情况，即栈满、栈空、入栈以及出栈：

第一步： 创建一个容量大小为4的栈

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("程序退出~~~");

第四步： 入栈测试，栈满时无法向数组添加数据

第五步： 出栈测试，栈空时无法取出数据

image.png-87.3kB

第六步： 最后贴上这次测试的所有代码

package com.maxchen.demo.stack;

import java.util.Scanner;

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("程序退出~~~");
    }

}

//定义一个 ArrayStack 表示栈
class ArrayStack {
    private int maxSize; // 栈的大小
    private int[] stack; // 数组，数组模拟栈，数据就放在该数组
    private int top = -1;// top表示栈顶，初始化为-1

    //构造器
    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }

    //栈满
    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]);
        }
    }

}

栈实现加减乘除

1、针对加减乘除四则运算符，我们需要确定优先级；
2、判断一段表达式哪些是运算符，如果是运算符则PUSH到符号栈，如果是数字则PUSH到数栈；
3、如果符号栈有操作符，就进行比较,如果当前的操作符的优先级小于或者等于栈中的操作符,就需要从数栈中pop出两个数，先将包高含优先级运算符（*和/）的表达式POP出来做运算，接着将结果PUSH到数栈；
4、之后将包含低优先级运算符的表达式POP出来进行+和-，得到最终结果PUSH到数栈。

下图以动图的形式展示此次运算的整体过程（PS：这里执行顺序有误，正确的执行顺序是一旦发现有 *和/ 运算符，就先将包含 *和/ 表达式计算出来，然后PUSH到栈顶，接着再将剩余的表达式分别入栈到数栈和符号栈，这里一开始将所有的表达式入栈都分别入栈了）：

栈.gif-173.1kB

第一步： 比较运算符的优先级

//返回运算符的优先级，优先级是程序员来确定, 优先级使用数字表示
//数字越大，则优先级就越高.
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;
}

第四步： 写个代码测试一下，扫描表达式→分别入栈到数栈和符号栈→当中发现有乘除先计算→计算结果入栈到数栈→剩余的加减表达式继续入栈→计算出最终结果入栈到数栈→打印结果

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);
}

运行结果如下：

image.png-15.6kB

第五步： 附上这次测试的代码（仅供参考，后续有更多问题需要优化）

package com.maxchen.demo.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;
    }

}
maxchen.cn
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java数据结构与算法02——队列
12-21
标签：Java 数据结构 算法 作者 ： Maxchen 版本 ： V1.0.0 日期 ： 2020/3/29 目录1.队列的概念2.数组模拟队列3.队列运行测试 1.队列的概念 队列同样是一种特殊的线性表，其插入和删除的操作分别在表的两端进行，...
Java数据结构_04 快速掌握基本数据结构（通俗易懂）
凤文Sharing的博客
10-20 609
常见数据结构入门，让你有一个清晰的区分！ 数组、链表、栈、队列、树、堆、散列、图……
数据结构与算法（Java笔记15天）
杨丙寅
06-07 1万+
文章目录Java数据结构与算法前言目录结束 Java数据结构与算法 前言 源码：https://github.com/name365/Java-Data-structure 目录 名称 地址 第一章 稀疏数组 https://blog.csdn.net/m0_46153949/article/details/106266666 第二章 队列 https://blog.csdn.net/m0_46153949/article/details/106266666 第三章 链表 htt
算法与数据结构入门必看（通俗易懂）
jj1130050965的博客
07-10 332
算法与数据结构开篇 你真的会数据结构吗？ 公司开发一个客服电话系统，小菜需要完成客户排队模块的开发，经过三次修改： 第一次：小菜使用了数据库设计了一张客户排队表，并且设置了一个自动增长的整型id字段，来一个用户，就在这张表的末尾插入一条数据，等客服系统一空闲，就将表中最前的的客户提交，然后删除这条记录。 实时排队模块，在内存中实现即可，无序用数据库 第二次：小菜用数组变量重新实现了这个功能，害怕数组不够大，选择远大于实际情况的100作为数组长度 数组虽然可以满足一定需求，但是需要考虑溢出问题，以及新增
十本数据结构与算法书籍推荐
肖邦的夜曲的专栏
05-20 1万+
学计算机的人是幸福的，因为在这个领域中有如此多的通俗易懂（相对来说）的经典好书，你需要做的只是坚持把它们一本一本读下去而已。在这里列出一些我看过或者准备看的算法书籍，以供参考。 第一名 原书名：The Art of Computer Programming 中文名：计算机程序设计艺术 作者：Donald E.Knuth 难度：★★★★★ 个人评价：★★★★★ 推荐程度：★★★ 本书是算法分析的经典名作（用经典不太恰当，应该是圣经或史诗），被科学美国人列为20世纪12大科学名著之一（和Di.
KMP算法——通俗易懂讲好KMP算法：实例图解分析+详细代码注解 --》你的所有疑惑在本文都能得到解答
热门推荐
是谢添啊
11-23 1万+
字符串的最长公共前后缀，部分匹配表，最长公共前后缀介绍，部分匹配表介绍，kmp算法java代码实现，匹配成功一个就退出匹配的kmp算法代码实现，允许匹配多个，可重复索引字符的kmp算法代码实现，允许匹配多个，不可重复索引字符的kmp算法代码实现，kmp算法实例分析，kmp算法图解
Java集合——（通俗易懂）
m0_63573177的博客
04-26 1912
目录 为什么需要集合 Collection（单列集合） List —— Arraylist List —— LinkedList 集合的三大遍历方式 Set —— HashSet Set —— LinkedHashSet Set —— TreeSet Map(双列集合) Map —— HashMap（key，value） Map —— HashTable Map —— TreeMap Map —— LinkedHashMap 总结 为什么需要集合 ...
基础算法与数据结构——排序算法
溯夜，逆流而上
08-25 289
网上有很多关于对排序算法的讲解了，只是别人的终究是别人的，没有经过自己的思考与探究，知识很快就会遗忘，这篇博客主要从排序算法的空间复杂度、时间复杂度，稳定性以及简答易懂的图示讲解来描述常用的排序算法。
七大排序算法——堆排序，通俗易懂的思路讲解与图解(完整Java代码)
The_emperoor_man的博客
07-14 784
本文介绍的是七大算法排序中的堆排序，用大白话讲解，配有图解与完整代码(内含注释)。快进来轻松学会堆排序。
简单通俗易懂学算法——十大常用排序算法（快速排序）
掉了根毛的博客
06-11 833
快速排序：是对冒泡排序的一种改进。 先说下快排的一个基本思想： 使用分治法（Divide and conquer）策略来把一个序列（list）分为较小和较大的2个子序列，然后递归地排序两个子序列。 就是通过一躺排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一不部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成...
java数据结构与算法.pdf
01-04
包含了各种数据结构和算法（java）的实现方式和详解（图解），包括单双链表、环形链表（约瑟夫问题）、栈、后缀表达式、中缀表达式转后缀表达式、迷宫问题、八大排序算法、多种查找算法、哈希表、二叉树实现以及操作...
数据结构与算法 —— Java 实现（链表）
01-21
数据结构与算法 —— Java 实现（链表）一、单链表1.1 链表的定义1.2 链表添加一个新的节点1.3 判断当前节点是否为最后一个节点 （isLast）1.4 删除下一节点 （removeNext）1.5 显示节点信息（show）1.6 插入一个...
数据结构&算法——Java.zip
最新发布
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
数据结构与算法分析——java语言描述（第二版） 习题答案
01-26
数据结构与算法分析——Java语言描述（第二版）是普林斯顿大学Mark Allen Weiss的经典之作，但是网上很少能找到Java描述第二版的课后习题，连作者的个人主页也明确表示不提供课后习题，只能到出版商那里去索取，这个...
Spring Boot+Vue前后端分离开发01-----概念描述
MAXCHEN BLOG
02-25 3921
Spring Boot+Vue前后端分离开发 标签 ： Java Vue Sring JPA ELementUI 作者 ： Maxchen 版本 ： V1.0.0 日期 ： 2020/2/24 前后端分离的概念 前后端分离顾名思义将前端代码和后端代码分开写，为什么我们要前后端分离？ 传统的Java Web开发中，前端主要采用JSP，而JSP不是由后端开发者独立完成的，需要前端和后端共同协同完成：...
Spring Boot+Vue前后端分离开发09-----Form表单
MAXCHEN BLOG
03-07 2207
标签 ： Java Vue Sring JPA ELementUI 作者 ： Maxchen 版本 ： V1.0.0 日期 ： 2020/3/7 目录1. Vue开发——Form表单前端2. SpringBoot开发——Form表单接口开发3. Form表单前后端联调4. 通过表单修改数据 1. Vue开发——Form表单前端 此次开发的Form表单功能为新增图书，具体要求如下： 添加...
Spring Boot+Vue前后端分离开发10-----删除功能（完结）
MAXCHEN BLOG
03-12 1751
标签 ： Java Vue Sring JPA ELementUI 作者 ： Maxchen 版本 ： V1.0.0 日期 ： 2020/3/11 删除功能开发 第一步：我们展开JpaRepository的方法，可以到找到一个方法deleteById，此方法了一通过id删除数据。 第二步：测试deleteById方法，运行之后发现数据已删除。 /** * @Title: ...
Spring Boot+Vue前后端分离开发07-----前后端分离开发数据对接
MAXCHEN BLOG
03-05 640
前后端分离开发数据对接 前端创建报表 后端创建接口 前后端对接 1、前端创建报表 新增路由Table //新增一个Table路由 { path: '/table', name: 'Table', component: () => import('../views/Table.vue') } 创建一个报表的Compo...
Java算法与数据结构测试——二叉树
04-06
非递归查找可以使用栈或队列实现，从根节点开始，每次将当前节点的左右子节点入栈/队列，直到找到要查找的值或者栈/队列为空。 4. 二叉树的插入与删除操作如何实现？ 二叉树的插入操作是将要插入的节点与当前节点...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值