数据结构(Java实现)：栈和队列相关练习题

news2024/9/30 11:38:06

文章目录

  • 1. 题目链接
  • 2. 题目解析
    • 2.1 括号匹配
    • 2.2 逆波兰表达式求值
    • 2.3 出栈入栈次序匹配
    • 2.4 最小栈
    • 2.5 环形数组队列
    • 2.6 用队列实现栈
    • 2.7 用栈实现队列

1. 题目链接

  1. 括号匹配
  2. 逆波兰表达式求值
  3. 出栈入栈次序匹配
  4. 最小栈
  5. 设计循环队列
  6. 用队列实现栈
  7. 用栈实现队列

2. 题目解析

2.1 括号匹配

题目分析
可能遇到的情况如下：

  1. 如果括号匹配成功，栈最终为空且字符串遍历完成。
  2. 左括号和右括号不匹配。eg：[(])
  3. 字符串还没遍历完，遇到右半边符号，栈就为空。eg：()))
  4. 字符串遍历完成，但是栈中仍然存在左括号。eg：(()

我们使用条件判断语句将上面四种情况考虑到就可以解决这道题目了。

代码示例

class Solution {
        public boolean isValid(String s) {
        //使用栈存字符串左半边符号
        Stack<Character> stack = new Stack<>();
        for(int i = 0; i < s.length();i++) {
            char ch = s.charAt(i);
            //左括号入栈
            if(ch == '(' || ch == '{' || ch == '[') {
                stack.push(ch);
            }else {
                //遇到了右括号
                if(stack.empty()) {//字符串还没遍历完，遇到右半边符号，栈就为空
                    return false;
                }else {
                    //取栈顶元素的左括号看和当前右括号是否匹配
                    char chL = stack.peek();
                    if(chL == '(' && ch == ')' || chL == '[' && ch == ']' || chL == '{' && ch == '}') {
                        //匹配成功，出栈
                        stack.pop();
                    }else {
                        //左括号和右括号不匹配
                        return false;
                    }
                }
            }
        }
        //字符串遍历完成，但是栈中仍然存在左括号
        return stack.empty();
    }
}

2.2 逆波兰表达式求值

题目分析
tips： 逆波兰表达式是一种机器易读的表达式，不需要加括号或者定义运算符优先级就可以正确的描述运算顺序12。它是一种后缀表达式，与中缀表达式相对应，例如中缀表达式 (1 + 2) * (3 + 4) 对应的逆波兰表达式为 ((1 2 +) (3 4 +) *)。
首先传入的字符串组存储的是符号和数字的字符串，根据上面逆波兰表达式的介绍，我们可以得知开始都是数字，然后当出现一个符号，再对前面的数组进行运算。因此我们可以使用栈来解决这道题，当字符串为数字串时入栈，然后如果遇到符号，出栈两个数字，先出的在运算符右边，后出的在运算符左边，再将运算结果入栈。最后经过一系列运算，栈内剩余的数字就是运算结果。
代码示例

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack=new Stack<>();
        for(int i=0;i<tokens.length;i++){
            String c=tokens[i];
            if(!(c.equals("+")||c.equals("-")||c.equals("*")||c.equals("/"))){
            	//字符串为数字串时入栈
                stack.push(Integer.valueOf(c));
            }else{
            	//如果遇到符号，出栈两个数字
                Integer val2=stack.pop();//先出的在运算符右边
                Integer val1=stack.pop();//后出的在运算符左边
                switch(c){
                    case "+":
                    stack.push(val1+val2);//将运算结果入栈
                    break;
                    case "-":
                    stack.push(val1-val2);//将运算结果入栈
                    break;
                    case "*":
                    stack.push(val1*val2);//将运算结果入栈
                    break;
                    case "/":
                    stack.push(val1/val2);//将运算结果入栈
                    break;
                }
            }
        }
        //栈内剩余的数字就是运算结果
        return stack.pop();
    }
}

2.3 出栈入栈次序匹配

题目分析
首先遍历pushV数组，将pushV数组正常入栈。然后每入栈一个数，判断popV数组，当popV数组的元素跟栈顶元素相同时，就将入栈元素出栈。然后继续判断，直到popV数组的元素不等于栈顶元素或者popV数组越界或者栈中没有元素结束循环，继续将pushV数组入栈。最后pushV数组完成入栈和出栈，栈中没有元素就返回true；否则返回false。
代码示例

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pushV int整型一维数组 
     * @param popV int整型一维数组 
     * @return bool布尔型
     */
    public boolean IsPopOrder (int[] pushV, int[] popV) {
        Stack<Integer> stack=new Stack<>();
        int j=0;
        for(int i=0;i<pushV.length;i++){//将pushV数组正常入栈
            stack.push(pushV[i]);
            //popV数组的元素不等于栈顶元素或者popV数组越界或者栈中没有元素结束循环
            while(!stack.empty()&&stack.peek()==popV[j]&&j<popV.length){
            	//当popV数组的元素跟栈顶元素相同时，就将入栈元素出栈
                stack.pop();
                //遍历popV数组
                j++;
            }
        }
        //栈中没有元素就返回true；否则返回false
        return stack.empty();
    }
}

2.4 最小栈

题目分析
存放元素的过程:push

  1. 如果第一次存放元素，普通栈和最小栈都得存放。
  2. 如果不是第一次存放的时候，普通栈肯定得放。如果元素小于等于最小栈的栈顶元素，最小栈才存放元素。

取元素的过程:pop() 返回值是普通栈的元素

  1. 每次pop元素的时候，都需要判断pop的元素是不是和最小栈的栈顶元素一样。如果一样，最小栈也得pop。

top相当于peek()返回值是普通栈的值。
getMin() 获取最小值，最小栈的栈顶元素就为栈的最小值。
代码示例

class MinStack {

    Stack<Integer> s1;//普通栈
    Stack<Integer> s2;//最小栈

    public MinStack() {
        s1=new Stack<>();
        s2=new Stack<>();
    }
    //存放元素
    public void push(int val) {
        s1.push(val);//普通栈必须存放
        if(s2.empty()){//如果第一次，最小栈也要存放元素
            s2.push(val);
        }else{//不是第一次，元素小于等于最小栈的栈顶元素，最小栈才存放元素
            if(s2.peek()>=val){
                s2.push(val);
            }
        }
    }
    //取元素
    public void pop() {
        if(s1.empty()){//判空
            return;
        }
        int a=s1.pop();
        //判断pop的元素是不是和最小栈的栈顶元素一样
        if(a==s2.peek()){
            s2.pop();//如果一样，最小栈也得pop
        }
    }
    //相当于peek()返回值是普通栈的值
    public int top() {
        return s1.peek();
    }
    //获取最小值，最小栈的栈顶元素就为栈的最小值
    public int getMin() {
        return s2.peek();
    }
}

2.5 环形数组队列

题目分析
当队尾走到顺序表的尽头，此时我们一直让fist++或者last++可能会造成数组越界，我们可以在每次入队列或者出队列时加一个判断，当first==len或者last==len时让他们的下标设置为0,。我们也可以通过表达式来设置下标，first=(first+1)%len或者last=(last+1)%len，通过这个表达式就不用担心数组越界的问题了。
在这里插入图片描述
考虑完数组越界问题后，我们如何区分队列的空与满？单纯依靠头尾相遇并不能解决这个问题，因为环形链表头尾相遇时可能为空，也可能为满。我们有下面三种解决方案。题目：力扣循环队列。

  1. 使用usedSize，当usedSize==len时就为满。代码示例
class MyCircularQueue {
    public int[] elem;//存放队列元素
    public int first;//队列头
    public int last;//队列尾
    public int usedSize;//元素个数
    //构造方法
    public MyCircularQueue(int k) {
        elem=new int[k];
        this.usedSize=0;
        this.first=0;
        this.last=0;
    }
    //入队列 
    public boolean enQueue(int value) {
        if(isFull()){//判满，如果队列满了返回false
            return false;
        }
        //元素入队列
        elem[last]=value;
        //队尾位置往后移一个
        last=(last+1)%elem.length;
        //元素个数加1
        usedSize++;
        //成功入队列，返回true
        return true;
    }
    //出队列
    public boolean deQueue() {
        if(isEmpty()){//判空，如果队列为空返回false
            return false;
        }
        //出队列直接让对头往后移动一个
        first=(first+1)%elem.length;
        //元素个数减1
        usedSize--;
        //出队列成功，返回true
        return true;
    }
    //看队头元素
    public int Front() {
        if(isEmpty()){//判空，如果为空返回-1
            return -1;
        }
        //不为空，first下标即为队头元素
        return elem[first];
    }
    //看队尾元素
    public int Rear() {
        if(isEmpty()){//判空，如果为空返回-1
            return -1;
        }
        int index;
        if(last==0) {//如果last为0，队尾元素下标就为elem.length-1
            index = elem.length-1;
        }else {//否则，队尾元素下标为last-1
            index = last-1;
        }
        //返回对应下标的元素
        return elem[index];
    }
    //判空
    public boolean isEmpty() {
    //如果usedSize为0，队列尾空
        return usedSize==0;
    }
    //判满
    public boolean isFull() {
    //如果usedSize等于数组长度队列为满
        return usedSize==elem.length;
    }
}
  1. 使用一个boolean类型的标记，当队列为满，flag为true，否则为false。代码示例
class MyCircularQueue {
    public int[] elem;//存放队列元素
    public int first;//队列头
    public int last;//队列尾
    public boolean flag;//标记
    //构造方法
    public MyCircularQueue(int k) {
        elem=new int[k];
        this.flag=false;//flag为false时，队列不满
        this.first=0;
        this.last=0;
    }
    //入队列
    public boolean enQueue(int value) {
        if(isFull()){//判满，如果队列满了返回false
            return false;
        }
        //元素入队列
        elem[last]=value;
        //队尾位置往后移一个
        last=(last+1)%elem.length;
        if(last==first){//入队列时，last走完一圈回到first队列就满了
            flag=true;
        }
        //成功入队列，返回true
        return true;
    }
    //出队列
    public boolean deQueue() {
        if(isEmpty()){//判空，如果队列为空返回false
            return false;
        }
        //出队列直接让对头往后移动一个
        first=(first+1)%elem.length;
        flag=false;//出队列时，队列就不满，标志设为false
        //出队列成功，返回true
        return true;
    }
    //看队头元素
    public int Front() {
        if(isEmpty()){//判空，如果为空返回-1
            return -1;
        }
        //不为空，first下标即为队头元素
        return elem[first];
    }
    //看队尾元素
    public int Rear() {
        if(isEmpty()){//判空，如果为空返回-1
            return -1;
        }
        int index;
        if(last==0) {//如果last为0，队尾元素下标就为elem.length-1
            index = elem.length-1;
        }else {//否则，队尾元素下标为last-1
            index = last-1;
        }
        //返回对应下标的元素
        return elem[index];
    }
    //判空
    public boolean isEmpty() {
        //如果last==first且flag为false，队列为空
        return last==first&&!flag;
    }
    //判满
    public boolean isFull() {
        //如果队列为满，flag为true
        return flag;
    }
}
  1. 浪费一个空间，当first+1==last时，为满。代码示例
class MyCircularQueue {

    public int[] elem;//存放队列元素
    public int first;//队列头
    public int last;//队列尾
    //构造方法
    public MyCircularQueue(int k) {
        //因为浪费了一个空间，所以为了保证能够存够k个元素就需要开辟k+1个空间
        elem=new int[k+1];
        this.first=0;//队头
        this.last=0;//队尾
    }
    //入队列
    public boolean enQueue(int value) {
        if(isFull()){//判满，如果队列满了返回false
            return false;
        }
        //元素入队列
        elem[last]=value;
        //队尾位置往后移一个
        last=(last+1)%elem.length;
        //成功入队列，返回true
        return true;
    }
    //出队列
    public boolean deQueue() {
        if(isEmpty()){//判空，如果队列为空返回false
            return false;
        }
        //出队列直接让对头往后移动一个
        first=(first+1)%elem.length;
        //出队列成功，返回true
        return true;
    }
    //看队头元素
    public int Front() {
        if(isEmpty()){//判空，如果为空返回-1
            return -1;
        }
        //不为空，first下标即为队头元素
        return elem[first];
    }
    //看队尾元素
    public int Rear() {
        if(isEmpty()){//判空，如果为空返回-1
            return -1;
        }
        int index;
        if(last==0) {//如果last为0，队尾元素下标就为elem.length-1
            index = elem.length-1;
        }else {//否则，队尾元素下标为last-1
            index = last-1;
        }
        //返回对应下标的元素
        return elem[index];
    }
    //判空
    public boolean isEmpty() {
    //头等于尾时为空
        return last==first;
    }

    public boolean isFull() {
    //浪费一个元素，尾的下一个为头就视为满
        return (last+1)%elem.length==first;
    }
}

2.6 用队列实现栈

题目分析
队列是按照顺序出队列和入队列，栈是后进先出。如果要用队列实现栈，就需要两个队列。当我们要出栈或者查看栈顶元素时，就需要查看队尾元素。此时就将队尾的元素往前的元素进入到另一个队列，此时就能实现栈。
代码示例

class MyStack {
    Queue<Integer> q1;
    Queue<Integer> q2;

    public MyStack() {
        q1=new LinkedList<>();
        q2=new LinkedList<>();
    }
    //入栈
    public void push(int x) {
        if(empty()){//如果队列都为空，就先将元素入队列1
            q1.offer(x);
        }else {//否则，判断哪个队列为空，将元素如不为空的那个队列
            if(q1.isEmpty()){
                q2.offer(x);
            }else {
                q1.offer(x);
            }
        }
    }
    //出栈
    public int pop() {
        if(empty()){//如果栈为空，返回-1
            return -1;
        }
        if(q1.isEmpty()){//如果队列1为空，将队尾的元素往前的元素进入到队列2
            while (q2.size()>1){
                q1.offer(q2.poll());
            }
            return q2.poll();//返回队尾元素，实现出栈
        }else {//如果队列2为空，将队尾的元素往前的元素进入到队列1
            while (q1.size()>1){
                q2.offer(q1.poll());
            }
            return q1.poll();//返回队尾元素，实现出栈
        }
    }
    //查看栈顶元素
    public int top() {
        if(empty()){//如果栈为空，返回-1
            return -1;
        }
        int ret;//返回值
        if(q1.isEmpty()){//如果队列1为空，将队尾的元素往前的元素进入到队列2
            while (q2.size()>1){
                q1.offer(q2.poll());
            }
            ret=q2.element();//返回队尾元素
            q1.offer(q2.poll());//将队尾元素入到另一个队列
        }else {//如果队列2为空，将队尾的元素往前的元素进入到队列1
            while (q1.size()>1){
                q2.offer(q1.poll());
            }
            ret=q1.element();//返回队尾元素
            q2.offer(q1.poll());//将队尾元素入到另一个队列
        }
        return ret;
    }
    //判空
    public boolean empty() {
    //队列1和队列2都为空，栈为空
        return q1.isEmpty()&&q2.isEmpty();
    }
}

2.7 用栈实现队列

题目分析
栈是后进先出，队列是按照顺序出队列和入队列。所以要用栈实现队列，就需要一个模拟入队列，一个模拟出队列。我们先创建两个栈，s1和s2，s1入队列使用，s2出队列使用。详细实现参照下面代码注释。
在这里插入图片描述

代码示例

class MyQueue {
    public Stack<Integer> s1;
    public Stack<Integer> s2;

    public MyQueue() {
        s1=new Stack<>();
        s2=new Stack<>();
    }
    //入队列
    public void push(int x) {
        while (!s2.isEmpty()){//将栈2的元素放入栈1，实现入队列
            s1.push(s2.pop());
        }
        s1.push(x);//将新元素入队列
    }
    
    public int pop() {
        if (empty()){//判空，如果队列为空返回-1
            return -1;
        }
        while (!s1.isEmpty()){//将栈1的元素放入栈2，实现出队列
            s2.push(s1.pop());
        }
        return s2.pop();//出队列
    }
    
    public int peek() {
        if (empty()){//判空，如果队列为空返回-1
            return -1;
        }
        while (!s1.isEmpty()){//将栈1的元素放入栈2，实现出队列
            s2.push(s1.pop());
        }
        return s2.peek();//查看队头元素
    }
    
    public boolean empty() {
    	//当栈1和站2都为空，队列为空
        return s1.isEmpty()&&s2.isEmpty();
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2087708.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

基于RK3568平台移植ffmpeg3.4.5及ffmpeg验证

基于RK3568平台移植ffmpeg3.4.5及ffmpeg验证

目录 一、概述二、环境要求2.1 硬件环境2.2 软件环境三、移植流程3.1 编译x2643.2 编译mpp3.3 编译ffmpeg四、ffmpeg验证4.1 ffmpeg配置说明4.2 ffmpeg推流/拉流使用说明4.2.1 使用http方式推流/拉流4.2.1.1 先执行ffmpeg服务4.2.1.2 再执行ffmpeg进行推流4.2.1.3 最后执行vlc进…
阅读更多...
等保测评中的数据安全保护：重点与挑战

等保测评中的数据安全保护：重点与挑战

在信息安全等级保护&#xff08;等保&#xff09;测评中&#xff0c;数据安全保护是核心关注点之一&#xff0c;它不仅关系到企业的合规性&#xff0c;还直接影响到企业的运营安全和用户信任。本文将深入探讨等保测评中数据安全保护的重点与挑战&#xff0c;为企业提供有效的应…
阅读更多...
JavaScript初级——事件传播

JavaScript初级——事件传播

1、事件的传播 关于事件的传播网景公司和微软公司有不同的理解&#xff1a; 微软公司认为事件应该是由内向外传播&#xff0c;也就是当事件触发时&#xff0c;应该先触发当前元素上的事件&#xff0c;然后再向当前元素的祖先元素上传播&#xff0c;也就说事件应该在冒泡阶段执行…
阅读更多...
如何解决U盘无法压缩卷或删除卷的问题

如何解决U盘无法压缩卷或删除卷的问题

U盘在日常使用中&#xff0c;偶尔会遇到无法压缩卷或删除卷的情况。出现这些问题通常与U盘的磁盘状态或文件系统有关。本文将介绍一种有效的解决方法&#xff0c;通过使用Windows自带的磁盘管理工具diskpart来解决这些问题。 一、问题原因 U盘无法压缩卷或删除卷的常见原因包…
阅读更多...
Nginx部署Vue前端项目全攻略：从构建到上线一步到位！

Nginx部署Vue前端项目全攻略：从构建到上线一步到位！

要将前端 Vue 项目部署到 Nginx&#xff0c;你需要遵循以下步骤&#xff1a; 首先确保你已经安装了 Node.js 和 npm。如果没有&#xff0c;请访问 Node.js 官网 下载并安装。 使用 Vue CLI 创建一个新的 Vue 项目&#xff08;如果你还没有一个&#xff09;&#xff1a; npm i…
阅读更多...
探索未知，悦享惊喜 —— 您的专属盲盒小程序，即将开启奇妙之旅

探索未知，悦享惊喜 —— 您的专属盲盒小程序，即将开启奇妙之旅

在这个充满无限可能的数字时代&#xff0c;每一次点击都可能是通往惊喜的门户。我们匠心打造的“惊喜盲盒”小程序&#xff0c;正是为了给您带来前所未有的娱乐体验与心灵触动。在这里&#xff0c;每一份盲盒都蕴藏着精心挑选的宝藏&#xff0c;等待着与您的不期而遇。 【探索…
阅读更多...
学习bat脚本

学习bat脚本

内容包含一些简单命令或小游戏&#xff0c;在乐趣中学习知识。 使用方法&#xff1a; 新建文本文档&#xff0c;将任选其一代码保存到文档中并保存为ASCII编码。将文件后缀改为.bat或.cmd双击运行即可。 一. 关机脚本 1. 直接关机 echo off shutdown -s -t 00秒直接关机。 2…
阅读更多...
H5手机端调起支付宝app支付

H5手机端调起支付宝app支付

1.调起APP页面如下 步骤 1.让后端对接一下以下文档&#xff08;手机网站支付通过alipays协议唤起支付宝APP&#xff09; https://opendocs.alipay.com/open/203/107091?pathHash45006f4f&refapi 2.后端接口会返回一个form提交表单 html&#xff1a;在页面中定义一个d…
阅读更多...
halcon2

halcon2

halcon自带图片路径 C:\Users\Public\Documents\MVTec\HALCON-18.11-Progress\examples 案例1&#xff1a;blob 固定阈值分割图像-车牌号识别 案例2&#xff1a;blob 动态阈值分割 匹配字母 案例1:打开窗口并画几何图形 &#xff08;ROI 感兴趣区域&#xff09; 并且距离测量…
阅读更多...
IO进程day05（线程、同步、互斥、条件变量、进程间通信IPC）

IO进程day05（线程、同步、互斥、条件变量、进程间通信IPC）

目录 【1】线程 1》什么是线程 1> 概念 2> 进程和线程的区别 3> 线程资源 2》 函数接口 1> 创建线程&#xff1a;pthread_create 2> 退出线程&#xff1a;pthread_exit 3> 回收线程资源 练习1&#xff1a;通过父子进程完成对文件的拷贝&#xff08…
阅读更多...
sqlmap注入语句学习，帮助你排查SQL注入漏洞

sqlmap注入语句学习，帮助你排查SQL注入漏洞

摘要 sqlmap是一个开源的渗透测试工具&#xff0c;可以用来进行自动化检测&#xff0c;利用SQL注入漏洞&#xff0c;获取数据库服务器的权限。它具有功能强大的检测引擎&#xff0c;针对各种不同类型数据库的渗透测试的功能选项&#xff0c;包括获取数据库中存储的数据&#x…
阅读更多...
第3章-03-Python库Requests安装与讲解

第3章-03-Python库Requests安装与讲解

Python库Requests的安装与讲解 &#x1f3c6;作者简介&#xff0c;黑夜开发者&#xff0c;CSDN领军人物&#xff0c;全栈领域优质创作者✌&#xff0c;CSDN博客专家&#xff0c;阿里云社区专家博主&#xff0c;2023年CSDN全站百大博主。 &#x1f3c6;数年电商行业从业经验&…
阅读更多...
GPLGIAGQ；MMP2靶向光敏剂多肽；MMP2可降解 (cleavable) 的多肽；CAS号:109053-09-0

GPLGIAGQ；MMP2靶向光敏剂多肽；MMP2可降解 (cleavable) 的多肽；CAS号:109053-09-0

【GPLGIAGQ 简介】 GPLGIAGQ 是一种 MMP2 可切割的多肽,在脂质体和胶束纳米载体中都被用作刺激敏感的连接物,用于 MMP2 触发的肿瘤靶向治疗。GPLGIAGQ可用于合成光动力治疗 (PDT) 中独特的MMP2靶向光敏剂。 【中文名称】MMP2靶向光敏剂多肽&#xff1b;GPLGIAGQ 【英文名称】G…
阅读更多...
【知识】缓存类型和策略

【知识】缓存类型和策略

转载请注明出处&#xff1a;小锋学长生活大爆炸[xfxuezhagn.cn] 如果本文帮助到了你&#xff0c;欢迎[点赞、收藏、关注]哦~ 目录 缓存读取策略 缓存写入策略 直写缓存写入策略 回写高速缓存写入策略 回写缓存写入策略 ​​​​​​缓存替换策略 先进先出 &#xff08;F…
阅读更多...
C与C++的三种区分方式

C与C++的三种区分方式

1、单个字符的sizeof大小 在C和C中&#xff0c;单个字符&#xff08;char类型&#xff09;的大小通常是1字节&#xff08;8位&#xff09;&#xff0c;但这取决于编译器和目标平台。这是一种特别的区分方式&#xff0c;特别定义的。 2、是否有__cplusplus __cplusplus是一个预…
阅读更多...
【html+css 绚丽Loading】000025 玄机翻转棱

【html+css 绚丽Loading】000025 玄机翻转棱

前言&#xff1a;哈喽&#xff0c;大家好&#xff0c;今天给大家分享htmlcss 绚丽Loading&#xff01;并提供具体代码帮助大家深入理解&#xff0c;彻底掌握&#xff01;创作不易&#xff0c;如果能帮助到大家或者给大家一些灵感和启发&#xff0c;欢迎收藏关注哦 &#x1f495…
阅读更多...
等保2.0 | Apache Tomcat中间件测评

等保2.0 | Apache Tomcat中间件测评

这里就谈谈等保2.0要求&#xff0c;对应到Apache Tomcat中间件的一些条款要求。 安装步骤略过&#xff0c;我们直接看等保中涉及的一些参数。 首先&#xff0c;做测评的时候我们先要记录相应的软件版本&#xff1a; 查看版本&#xff0c;在tomcat目录下执行/bin/catalina.sh…
阅读更多...
是否应该使用WordPress自动更新的功能

是否应该使用WordPress自动更新的功能

开源程序例如WordPress&#xff0c;使许多人能够轻松创建自己的网站。然而&#xff0c;却存在一个棘手的问题是黑客攻击。开源的性质及其安全透明性让黑客、机器人和脚本小子提供了不断攻击的机会。防止WordPress网站被黑的首要方法是保持WordPress版本、主题和插件的更新。对于…
阅读更多...
突发性网络攻击的应对策略

突发性网络攻击的应对策略

应对突发性网络攻击&#xff0c;推动情报工作转型是重中之重&#xff0c;核心工作在于侦测 (detecting) 与回应 (respond)。负责任和安全的情报政策、程序与工作机制是满足网络安全治理任务的信息基础。正 如美国中情局原局长约翰杜奇提到&#xff0c;“( 网络突然袭击 ) 这种…
阅读更多...
【Linux】倒计时｜进度条｜git｜gdb的实现

【Linux】倒计时｜进度条｜git｜gdb的实现

目录 一、缓冲区 1.缓冲区概念&#xff1a; 2.缓冲区作用&#xff1a; 3.缓冲区刷新策略 4.缓冲区位置 5.总结 二、实现倒计时 三、进度条版本1️⃣ 四、进度条版本2️⃣ 五、使用git命令行 六、Linux调试器-gdb使用 背景 开始使用 一、缓冲区 1.缓冲区概念&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023