列表、栈、队列

news/2024/5/19 20:17:00/

列表(List)

介绍

一系列有序元素的集合。列表中的元素可以是任意类型,允许重复。

  1. 可通过索引定位、访问列表中的(单个)元素,还可使用切片(slice)操作一次性访问多个元素,从而实现对列表的复杂操作。
  2. 通过对象引用来操作列表,例如:使用append()、insert()、remove()等方法实现动态地插入或删除元素(使用频繁)

了解:Java中提供了多种实现列表的类,如:

  1. ArrayList:基于动态数组实现的列表,支持快速随机访问和插入/删除操作(需要移动大量元素--在开头或中间插入/删除时,被插入/删除位置之后的所有元素都要往前/后移位)。
  2. LinkedList:基于链表实现的列表,支持快速插入/删除(较高效--只需要修改指针即可),不支持随机访问。
  3. Vector:与ArrayList类似,但是线程安全。
  4. Stack(先进后出(FILO)):基于Vector实现的栈。与LinkedList相比,Vector在访问元素时更高效--根据索引值直接获取元素,不需要遍历整个列表。

综上所述,ArrayList适合需要频繁随机访问元素,但不要求线程安全,并且数据量相对较小的场景。LinkedList适合频繁进行插入/删除操作而不需要随机访问元素,常出现在需要处理大量数据的场景。Vector适合需要频繁随机访问元素,并要求线程安全的同时具备动态扩容能力的场景,插入和删除操作少。Stack适合需要按照先进后出原则进行操作的场景,对于多线程并发场景应当使用线程安全的Stack实现类,如ConcurrentLinkedStack。

预备知识

1.包装类(Wrapper Class):

Java中的基本数据类型(int、double、boolean等)不能直接添加到列表中(列表只能包含对象类型),为了解决这个问题,Java提供了对应的包装类(Integer、Double、Boolean等),实现了将基本数据类型转化为对象类型,使得基本数据类型也能被添加至列表。

2.集合(Collection):

一种用于存储对象的容器,并提供一些常用的操作方法,如添加、删除、查找、遍历、排序等。其中,List接口用于存储有序元素的列表。

常用操作

1.初始化列表

/* 初始化列表 */ 
List<Integer> list1=new ArrayList<>();Integer[] nums=new Integer[] {1,2,3,4,5};
List<Integer> list=new ArrayList<>(Arrays.asList(nums)); 

2.访问与更新元素

/* 访问与更新元素  */ 
int num=list.get(1);
list.set(1,0);
 

3.在列表中添加、删除元素

/* 在列表中添加、删除元素 */list.clear();/* 清空列表 */list.add(element);/* 向列表中添加单个个元素 */
list.add(index, element);/* 指定元素位置进行添加 */
/* 举例:list.add(3,6); //在第4个元素的位置插入6 */list.remove(index);/* 删除指定位置 */
list.remove(element);/* 删除指定元素 */
/* 使用注意看看大佬这篇博客: https://blog.csdn.net/qq_36412715/article/details/84071160 */
 

4.遍历列表

/* 遍历列表 */
for(int n:list){n
}
 

5.拼接两个列表

/* 拼接两个列表 */ 
List<Integer> list1=new ArrayList<>(Arrays.asList(new Integer[] {1,2,3,4,5}));
list2.addAll(list1); 
 

6.排序列表

/* 排序列表 */ 
Collections.sort();/* 对列表进行升序排序 */
 

简易实现

/* 简易实现 */ 
class MyList{private int[] nums;private int capa=10;private int size=0;private int ratio=2;public MyList(){}size;public nums[index]nums[index]=s;copyOf
}

public class MyArrayList<E> {private Object[] elements;  // 用数组实现列表private int size;  // 列表大小// 构造方法public MyArrayList(int initialCapacity) {elements = new Object[initialCapacity];size = 0;}// 默认构造方法public MyArrayList() {this(10);}// 添加元素到列表末尾public void add(E e) {if (size == elements.length) {resize();}elements[size] = e;size++;}// 在指定位置添加元素public void add(int index, E e) {if (index < 0 || index > size) {throw new IndexOutOfBoundsException();}if (size == elements.length) {resize();}System.arraycopy(elements, index, elements, index + 1, size - index);elements[index] = e;size++;}// 获取指定位置的元素@SuppressWarnings("unchecked")public E get(int index) {if (index < 0 || index >= size) {throw new IndexOutOfBoundsException();}return (E) elements[index];}// 删除指定位置的元素@SuppressWarnings("unchecked")public E remove(int index) {if (index < 0 || index >= size) {throw new IndexOutOfBoundsException();}E e = (E) elements[index];System.arraycopy(elements, index + 1, elements, index, size - index - 1);elements[size - 1] = null;size--;return e;}// 删除指定元素public boolean remove(E e) {for (int i = 0; i < size; i++) {if (elements[i].equals(e)) {remove(i);return true;}}return false;}// 修改指定位置的元素public void set(int index, E e) {if (index < 0 || index >= size) {throw new IndexOutOfBoundsException();}elements[index] = e;}// 获取列表大小public int size() {return size;}// 判断列表是否为空public boolean isEmpty() {return size == 0;}// 判断列表中是否包含指定元素public boolean contains(E e) {for (int i = 0; i < size; i++) {if (elements[i].equals(e)) {return true;}}return false;}// 清空列表public void clear() {for (int i = 0; i < size; i++) {elements[i] = null;}size = 0;}// 扩容private void resize() {Object[] newElements = new Object[elements.length * 2];System.arraycopy(elements, 0, newElements, 0, size);elements = newElements;}
}




栈(Stack)

介绍

  1. 栈主要用于实现函数调用、表达式求值等需要倒序处理的场景。
  2. 具有先进后出(FILO)的特性,如下图解:

常用操作

方法

描述

时间复杂度

push()

压入栈顶元素

O(1)

pop()

栈顶元素出栈

O(1)

peek()

访问栈顶元素

O(1)

/* 常用操作 */ 
Stack<Integer> stack=new Stack<>();stack.push(1);isEmpty();//判断栈是否为空;

栈的实现

基于链表的实现:

链表实现栈,主要需要考虑链表节点的插入和删除问题。

具体过程:每次插入新元素时,创建一个新节点并将其插入链表头部;每次弹出栈顶元素时,删除链表头部元素并返回其值即可。如下图解:

 

/* linkedlist_stack */
class LinkedListStack{private ListNode stackPeek;private int stkSize=0;public void push(int num){ListNode node=new ListNode(num);node.next=stackPeek;stackPeek=node;stkSize++; }public void pop{int num=peek();stackPeek=stackPeek.next;stkSize--;return num;}
}

public class LinkedListStack {private Node top = null; // 栈顶指针public void push(int value) {Node newNode = new Node(value);if (top == null) top = newNode; // 如果栈为空,将新节点作为栈顶指针else {newNode.next = top; // 将新节点放在栈顶,并更改栈顶指针top = newNode;}}public int pop() {if (top == null) return -1; // 栈为空int value = top.value;top = top.next; // 修改栈顶指针return value;}private static class Node {private int value;private Node next;public Node(int value) {this.value = value;}}
}


基于数组的实现

数组实现栈,主要需要考虑如何实现栈的扩容问题。

具体过程是:当数组中元素个数已满时,开辟一个新的数组,并将原来数组中的元素全部复制到新数组中,然后再把新元素加入新数组。

 

数组栈的主要优势在于插入和删除都可以通过索引直接访问元素。

/* array_stack */add()return stack.remove(size()-1);

public class ArrayStack {private int[] items; // 存放元素的数组private int top = -1; // 栈顶指针private int capacity; // 数组容量public ArrayStack(int capacity) {this.capacity = capacity;items = new int[capacity];}public boolean push(int item) {if (top == capacity - 1) return false; // 栈已满items[++top] = item; // 先将栈指针+1,再赋值return true;}public int pop() {if (top == -1) return -1; // 栈为空int item = items[top--]; // 先取值,再将栈指针-1return item;}
}

两种实现对比

支持操作:

时间效率:

都为O(1),推荐链表栈

空间效率:

数组栈需要预先分配一定大小的内存空间,会常用扩容操作。而链表栈不需要预先分配内存,通过动态增长、缩减空间,相比之下空间利用率更高。

分析总结:

使用数组作为底层实现可以快速插入和删除元素,但是需要考虑扩容问题;而使用链表作为底层实现则不需要考虑扩容问题,但是需要额外的空间存储指针信息。

在实际应用中,根据具体场景选择不同的底层实现方式能够更好地兼顾性能和空间效率。

典型应用

1.括号匹配

假设有一个字符串,其中包含小括号、中括号和大括号3种类型的括号,请编写一个函数判断该字符串中的括号是否匹配。

代码:

import java.util.Stack;public class BracketMatch {public static boolean isMatch(String s) {// 使用 Stack<Character>类型的栈来存储遍历到的括号Stack<Character> stack = new Stack<>();// 当遍历到左括号时,将其压入栈中;// 当遍历到右括号时,判断栈顶元素是否与之匹配,如果匹配则弹出栈顶元素,否则返回 false。 // 最后判断栈是否为空即可。 for (char c : s.toCharArray()) {if (c == '(' || c == '[' || c == '{') stack.push(c);else if (c == ')' && !stack.isEmpty() && stack.peek() == '(') stack.pop();else if (c == ']' && !stack.isEmpty() && stack.peek() == '[') stack.pop();else if (c == '}' && !stack.isEmpty() && stack.peek() == '{') stack.pop(); else return false; // 遇到非法字符直接返回 false}return stack.isEmpty(); // 如果栈为空,则说明所有括号都匹配成功}public static void main(String[] args) {String s1 = "()[]{}"; // trueString s2 = "([)]"; // falseString s3 = "({[]})"; // trueSystem.out.println(isMatch(s1));System.out.println(isMatch(s2));System.out.println(isMatch(s3));}
}

2.表达式求值

假设有一个表达式字符串,其中包含加减乘除四种运算符和括号,请编写一个函数计算该表达式的结果。

代码:

import java.util.Stack;public class ExpressionEvaluation {public static int evaluate(String s) {Stack<Integer> operands = new Stack<>(); // 存储操作数的栈Stack<Character> operators = new Stack<>(); // 存储运算符的栈for (char c : s.toCharArray()) {if (c >= '0' && c <= '9') operands.push(c - '0'); // 如果是数字,则直接将其压入操作数栈中else if (c == '+' || c == '-' || c == '*' || c == '/') { // 如果是运算符while (!operators.isEmpty() && precedence(c) <= precedence(operators.peek())) { // 弹出优先级比当前运算符高或相等的运算符char operator = operators.pop();int b = operands.pop(), a = operands.pop(); // 取出栈顶的两个操作数operands.push(calculate(a, b, operator)); // 计算结果并压回栈中}operators.push(c); // 将当前运算符入栈} else if (c == '(') operators.push(c); // 如果是左括号,则直接入栈else if (c == ')') { // 如果是右括号,则弹出运算符并计算结果,直到遇到左括号while (!operators.isEmpty() && operators.peek() != '(') {char operator = operators.pop();int b = operands.pop(), a = operands.pop();operands.push(calculate(a, b, operator));}operators.pop(); // 弹出左括号} else throw new IllegalArgumentException("Invalid character: " + c); // 非法字符,抛出异常}while (!operators.isEmpty()) { // 计算剩余的运算符char operator = operators.pop();int b = operands.pop(), a = operands.pop();operands.push(calculate(a, b, operator));}return operands.pop(); // 返回最后的结果,即为表达式的值}private static int precedence(char operator) { // 定义运算符的优先级if (operator == '*' || operator == '/') return 2;else if (operator == '+' || operator == '-') return 1;else throw new IllegalArgumentException("Invalid operator: " + operator); // 非法运算符,抛出异常}private static int calculate(int a, int b, char operator) { // 计算两个操作数的结果switch (operator) {case '+': return a + b;case '-': return a - b;case '*': return a * b;case '/': return a / b;default: throw new IllegalArgumentException("Invalid operator: " + operator); // 非法运算符,抛出异常}}public static void main(String[] args) {String s1 = "3+4*2/(1-5)+6/2"; // 7String s2 = "2*(3+4)-5/2"; // 11String s3 = "(1+2)*(3+4)"; // 21System.out.println(evaluate(s1));System.out.println(evaluate(s2));System.out.println(evaluate(s3));}
}

在上述代码中,我们使用了两个栈:一个存储操作数(整型数字),一个存储运算符。

遍历字符串时:

  1. 如果遇到数字则直接压入操作数栈中,
  2. 如果遇到运算符则将其与栈顶运算符比较优先级,如果当前运算符的优先级比栈顶高则入栈,否则弹出栈顶元素并计算结果。
  3. 遇到左括号则直接入栈,遇到右括号则取出运算符并计算结果,直到遇到左括号为止。

最后将剩余的操作数和运算符依次计算并返回即可。

即可。




队列(Queue)

介绍

  1. 用于存储按照时间顺序排列的元素。
  2. 队列具有“先进先出”(FIFO)的特性。如下图解:

常见操作

方法名

描述

时间复杂度

push()

元素入队,即将元素添加至队尾

O(1)

poll()

队首元素出队

O(1)

front()

访问队首元素

O(1)

size()

获取队列的长度

O(1)

isEmpty()

判断队列是否为空

O(1)

队列实现

基于链表的实现

  1. 链表队列实现主要需要考虑节点的插入和删除问题。
  2. 具体过程:每次从队列中添加元素时,创建一个新的链表节点并将其插入到队列的尾部;每次删除元素时,删除链表头部的节点并返回其值。如下图解:

/* linkedlist_queue */
ListNoe front,rear;
queSize=0;push(int num){ListNode node=new ListNode(num);if(front==null){front=node;rear=node;}else{rear.next=node;rear=node;}
}pop(){int num=peek();front=front.next;queSize--;return num;
}

 

public class LinkedListQueue {private Node head = null; // 队首指针private Node tail = null; // 队尾指针public void enqueue(int value) {Node newNode = new Node(value);if (tail == null) { // 如果队列为空,头尾指针都指向新节点head = newNode;tail = newNode;} else {tail.next = newNode; // 将新节点作为尾节点tail = tail.next; // 修改尾节点指针}}public int dequeue() {if (head == null) return -1; // 队列为空int value = head.value;head = head.next; // 修改头节点指针if (head == null) tail = null; // 如果队列中只有一个元素,则需要同时修改尾节点指针return value;}private static class Node {private int value;private Node next;public Node(int value) {this.value = value;}}
}


基于数组的实现

  1. 数组队列实现需要注意当队列数组已满时,需要创建一个新的数组来扩充旧的数组。
  2. 具体过程:当队列数组已满时,让队列尾指针指向新的位置,重新开辟一个新的数组,将原队列中的数据复制到新队列中,并且释放原队列的空间。

/* array_queue */
class sss{int[] num;int front;int queSize;push(int num){ifint rear=(front+queSize)%capa;nums[rear]=num;queSize++;}pop(){peek;front=(front+1)%capa;queSize--;}
};

 

public class ArrayQueue {private int[] items; // 存放元素的数组private int head = 0; // 队头指针private int tail = 0; // 队尾指针private int capacity; // 数组容量public ArrayQueue(int capacity) {this.capacity = capacity;items = new int[capacity];}public boolean enqueue(int item) {if (tail == capacity) return false; // 队列已满items[tail++] = item;return true;}public int dequeue() {if (head == tail) return -1; // 队列为空int item = items[head++];return item;}
}

两种实现对比

时间复杂度:

都为O(1)。

空间复杂度:

跟栈的说法相似。数组实现的队列需要预先分配一定大小的内存空间,在使用过程中如果超过了这个空间限制就需要进行扩容。而链表实现的队列不需要预先分配内存,可以动态增长或者缩小空间,所以空间利用率更高。

放松小时刻

关于栈和队列的一道例题:Problem - 1702

hdu 1702 “Acboy needs your help again!”

ACboy再次需要你的帮助!

时间限制:1000/1000 MS(Java/其他) 内存限制:32768/32768 K (Java/其他)
 

问题描述

阿童被绑架了!!
他非常想念他的母亲,现在非常害怕。你无法想象他被关进的房间有多暗,:(那么可怜。
作为一个聪明的ACMer,你想让ACboy走出怪物的迷宫。但当你到达迷宫的大门时,怪物说:“我听说你很聪明,但如果不能解决我的问题,你会和ACboy一起死去。
怪物的问题显示在墙上:
每个问题的第一行是一个整数N(命令的数量),和一个单词“FIFO”或“FILO”。(你很高兴,因为你知道“FIFO”代表“先进先出”,“FILO”的意思是“先进后出”)。
而接下来的N行,每行是“IN M”或“OUT”,(M代表一个整数)。
而问题的答案是一扇门的通行证,所以如果你想拯救ACboy,请仔细回答问题!
 

输入

输入包含多个测试用例。
第一行有一个整数,表示测试用例的数量。
每个子问题的输入如上所述。
 

输出

对于每个命令“OUT”,您应该输出一个整数,具体取决于单词“FIFO”或“FILO”,或者如果没有任何整数,则应输出单词“None”。

示例输入

4 
4 FIFO 
IN 1 
IN 2 
OUT 
OUT 
4 FILO 
IN 1 
IN 2 
OUT 
OUT 
5 FIFO 
IN 1 
IN 2 
OUT 
OUT 
OUT 
5 FILO 
IN 1 
IN 2 
OUT 
IN 3 
OUT

示例输出

1 
2 
2 
1 
1 
2 
None 
2 
3

2007省赛集训队练习赛(1)

模拟栈和队列,栈是FILO,队列是FIFO。

--分析:分别用栈和队列模拟--

C++代码实现:

#include<bits/stdc++.h>          //C++
using namespace std;
int main(){int t,n,temp;cin>>t;//测试的次数while(t--){string str,str1;queue<int> Q;//定义一个队列stack<int> S;//定义一个栈cin>>n>>str;//输入每组要输入的个数,以及存储方式 for(int i=0;i<n;i++){if(str=="FIFO"){//当为 FIFO时,表示队列 cin>>str1;//输入 IN或者是 OUTif(str1=="IN"){cin>>temp;Q.push(temp);} else if(str1=="OUT"){if(Q.empty()) cout<<"None"<<endl;//队列为空,输出 Noneelse{cout<<Q.front()<<endl;//访问该队首Q.pop();//删除队首元素}}}else{//当为 FILO,表示存储方式是栈cin>>str1;if(str1=="IN"){cin>>temp;S.push(temp);}else if(str1=="OUT"){if(S.empty()) cout<<"None"<<endl;else{cout<<S.top()<<endl;S.pop();}}}}}return 0;
}

//热爱C++的每一天



http://www.ppmy.cn/news/48549.html

相关文章

深度解析OEKO

【深度解析OEKO】 什么是OEKO-TEX Standard 100&#xff1f; OEKO-TEX Standard 100现在是使用最为广泛的纺织品生态标志。OEKO-TEX Standard 100规定的标准是根据最新的科学知识&#xff0c;对纱线、纤维以及各类纺织品的有害物质含量规定限度。只有按照严格检测和检查程序提供…

浏览器输入URL会做哪些事情

1、浏览器输入URL后会检查缓存 检查资源是否在缓存中并且新鲜&#xff0c;如果有跳到转码步骤&#xff0c; 1.1 检查是否新鲜的方法&#xff1a; ---------HTTP1.0中提供的 Expires&#xff0c;储存的值是绝对时间表示缓存日期&#xff1b; ---------HTTP1.1中提供Cache-Contr…

MySQL运维27-MySQL复制的评估方法和注意事项

文章目录 1、概述2、MySQL复制的意义3、MySQL复制实施前的评估方法3.1、必要性的评估3.2、基础设施的评估3.3、对主库影响的评估 4、MySQL复制实施时的注意事项5、总结 1、概述 2、MySQL复制的意义 扩展读能力&#xff1a;从库的最重要意义在于扩展读能力&#xff0c;但不能扩…

操作系统原理 —— 什么是中断?(四)

我们先来看看早期的计算机的工作流程&#xff1a; 如上图&#xff0c;在早期的计算机假设有三个程序需要执行&#xff0c;执行顺序是&#xff1a;先执行程序1&#xff0c;等待程序1结束之后&#xff0c;再开始执行程序2&#xff0c;以此类推&#xff0c;所以它们是串行执行的…

jsp+springboot基于ssm的人才招聘求职网站推荐模拟考试系统java idea

登录需要随机数字验证码 管理员&#xff1a; 招聘管理 求职信息管理 &#xff0c; 招聘信息管理 人员管理 管理注册的用户进行审核操作 公告管理 发布公告新闻 &#xff08;公告我想不到啥意思&#xff0c;可修改或增加别的&#xff09; 个人信息 修改个人信息 招聘者&am…

一天吃透SpringMVC面试八股文

说说你对 SpringMVC 的理解 SpringMVC是一种基于 Java 的实现MVC设计模型的请求驱动类型的轻量级Web框架&#xff0c;属于Spring框架的一个模块。 它通过一套注解&#xff0c;让一个简单的Java类成为处理请求的控制器&#xff0c;而无须实现任何接口。同时它还支持RESTful编程…

Qt扫盲-Qt图表类综述

Qt支持图表类综述 一、概述二、图表类型1. 折线图和柱状图2. 面积图和散点图3. 柱状图4. 饼图5. 盒须图6. 烛台图表7. 星座图图表 三、坐标轴 Axes四、图例五、与图表交互1. 动态绘制数据2. 深入数据3. 缩放和滚动4. 鼠标悬停 六、主题 一、概述 Qt Charts支持创建时尚的、交互…

webpack plugin源码解析(六) CompressionWebpackPlugin

文章目录 作用涉及 webpack API处理 asset 钩子compilation.hooks.processAssets返回或新建缓存&#xff1a;compilation.getCache返回 asset 文件信息&#xff1a;compilation.getAsset文件名匹配函数&#xff1a;compiler.webpack.ModuleFilenameHelpers.matchObject模版字符…

RabbitMQ的介绍和安装

文章目录 1.1 RabbitMQ介绍1.2 RabbitMQ的安装1.2.1 下载镜像1.2.2 安装启动1.2.3 测试 1.1 RabbitMQ介绍 RabbitMQ是一个开源的消息队列中间件&#xff0c;可以用于构建分布式应用程序&#xff0c;使应用程序能够快速、可靠地处理大量消息。它实现了AMQP&#xff08;高级消息队…

MyBatis小技巧

一、MyBatis中接口代理机制及使用 我们不难发现&#xff0c;以前编写dao/mapper实现类中的方法代码很固定&#xff0c;基本上就是一行代码&#xff0c;通过SqlSession对象调用insert、delete、update、select等方法&#xff0c;这个类中的方法没有任何业务逻辑&#xff0c;既然…

八、express框架解析

文章目录 前言一、express 路由简介1、定义2、基础使用 二、express 获取参数1、获取请求报文参数2、获取路由参数 三、express 响应设置1、一般响应设置2、其他响应设置 四、express 防盗链五、express 路由模块化1、模块中代码如下&#xff1a;2、主文件中代码如下&#xff1…

常见的Web漏洞

一、SQL 注入 SQL 注入就是通过把 SQL 命令插入到 Web 表单&#xff0c;递交或输入域名或页面请求的查询字符串&#xff0c;最终达到欺骗服务器执行恶意的 SQL 命令的目的。 1、原理&#xff1a; 网站数据过滤不合格&#xff0c;过分依赖用户输入的数据&#xff0c;没有过滤用…

SpringBoot配置多环境,dev,prod,test

springboot与maven配置多环境 开发任何的项目至少都需要三个环境&#xff0c;分别是 开发环境 测试环境 生产环境 环境不同意味着配置也是不相同的&#xff0c;比如数据库&#xff0c;文件路径等等配置&#xff0c;那么如何解决这么多环境整合在一起既不混乱又能很优雅呢&…

Maven项目中出现【不再支持目标选项 1.5】的解决办法

1 快速解决【单项目】 本方法只适用于单个项目&#xff0c;新建项目使用maven还会出现问题。 在pom.xml配置&#xff1a; <properties><maven.compiler.source>11</maven.compiler.source><maven.compiler.target>11</maven.compiler.target>&l…

grpc实战-pb文件生成问题/空消息体问题

报错信息&#xff1a; proto: message pb.Empty is already registered See https://protobuf.dev/reference/go/faq#namespace-conflict 对比老版本的工具生成的xxxx.pb.go文件。import导入的proto链接不一样&#xff1a; 旧版本&#xff1a;import github.com/golang/proto…

C++篇 ---- 命名空间namespace

由于在c语言中在定义时可能会出现重命名现象&#xff0c;造成空间冲突&#xff0c;c语言中有命名冲突&#xff1a;1 和库冲突。2 互相之间的冲突&#xff0c;变量命名冲突。所以c中就有了对其改进的关键字namespace&#xff0c;针对重定义&#xff0c;解决空间冲突。 文章目录 …

数据库实验 | 第1关:建立和调用存储过程(不带输出参数的存储过程)

任务描述 本关任务&#xff1a; 该实验是针对数据表jdxx&#xff0c;该数据表有四个字段&#xff0c;分别是省份(sf)、城市(cs)、区县(qxmc)、街道(name)。 例如&#xff0c;查询天心区(qxmc)的所有字段的值结果如图所示 任务要求 建立存储过程 dqxx(in city varchar(10),i…

一篇文章讲清 SEO 最核心的内容

当今的数字营销时代&#xff0c;SEO是吸引用户流量的重要手段。SEO指的是搜索引擎优化&#xff0c;它是为了提高网站在搜索引擎结果页面上的排名而采取的一系列技术和策略。 当用户在搜索引擎中输入关键词时&#xff0c;搜索引擎会根据一定的算法对网站进行排名&#xff0c;并…

【Go】四、面向对象

文章目录 面向对象1、匿名字段2、接口&#xff08;❌&#xff09;2.1、类型与接口的关系2.2、空接口2.3、类型断言 面向对象 1、匿名字段 ​ go只提供类型而不写字段名的方式&#xff0c;也就是匿名字段&#xff0c;也称为嵌入字段 1、不写字段名&#xff0c;只给出类型 2、…

JavaScript如何删除css

我们在前端开发当中&#xff0c;常常需要动态地添加、修改或删除DOM元素和CSS样式。DOM和CSS都是前端开发中不可或缺的部分&#xff0c;而JavaScript作为一种脚本语言&#xff0c;可以对DOM和CSS进行操作。 本文将重点介绍如何使用JavaScript来删除CSS&#xff0c;包括以下几个…