蓝桥杯备战

已于 2024-01-29 16:12:55 修改
阅读量1k 收藏 24
点赞数 29
分类专栏： 蓝桥杯 文章标签： 蓝桥杯 职场和发展 java eclipse
于 2024-01-26 21:53:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74952450/article/details/135875382
版权

第二章 基础数据结构

资料来源：尚硅谷java数据结构，程序设计竞赛挑战教程（蓝桥杯专题组编写），CSDN优秀博客整理。

数据结构包括：线性结构和非线性结构。

线性结构

1）线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系

2）线性结构有两种不同的存储结构，即顺序存储结构和链式存储结构。顺序存储的线性表又称顺序表，顺序表中的存储元素是连续的。

3）链式存储的线性表称为链表，链表中存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息。

4）线性结构常见的有：数组，队列，链表和栈。

非线性结构

非线性结构包括：二维数组，多维数组，广义表，树结构，图结构。

常见的数据结构相关教材一般包含这些内容：数组、链表、栈和队列、串、多维数组和广义表、哈希、树和二叉树、图（图的存储、遍历等）、排序等。（常考）

2.1线性表

2.1.1顺序表

特点：顺序存储，随机存取任意元素，删除插入麻烦

顺序表常用数组表示，使用连续的存储空间，存储密度大，其访问和使用方法都很简单。不过数组不够灵活，有3个缺点。

(1)需要占用连续的空间。若某个数组很大，可能没有这么大的连续空间给它用；

✧ 提示：在算法竞赛中，为了简化编程，链表都是用数组模拟的，也就是说，在逻辑上是链表，但是在物理上链表中的数据是用连续空间顺序存储的。这样做的好处是编写代码简单，缺点是浪费了空间，不过只要不超过竞赛题目的空间限制就

(2)不方便删除和插入数据。例如删除数组中的一个数据，需要把后面所有的数据往前移，以填补这个空位，会产生大量的复制开销。在中间插入数据，也同样不方便；

(3)属于静态存储空间，元素个数不能自由补充。

稀疏数组

当一个数组中的大部分元素为0，或者为同一个值的数组，可以使用稀疏数组来保存该数组。

稀疏数组的处理方法：

1、记录数组一共有几行几列，有几个不同的值。

2、把具有不同值的元素的行列及值记录在一个小规模的数组中，从而减小程序的规模。

在这里插入图片描述

如下：

在这里插入图片描述

二维数组转稀疏数组的思路

1、遍历原始的二维数组，得到有效数组的个数sum，

2、根据sum就可以创建稀疏数组sparse ARR int[[sum+1] [3]

3、将二维数组的有效数据存入稀疏数组

稀疏数组转二维数组的思路

1、先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，

2、在读取稀疏数组后几行的数据，并赋值给原始的二维数组即可。

//以五子棋棋盘转化二维数组引入
public static void main(String[] args) {
		// TODO 自动生成的方法存根
		//创建一个二维数组
		//0：没有子 1：黑子 2：白子
		int chessArr1[][] = new int[11][11];
		chessArr1[1][2]=1;
		chessArr1[2][3] = 2;
		chessArr1[3][2]=1;
		//输出原始二维数组
		System.out.println("原始的二维数组：");
		for(int[] row: chessArr1 ) {
			for(int data:row) {
				System.out.printf("%d\t",data);
			}
			System.out.println();
		}
		//将二维数组 转 稀疏数组
		//1.遍历二维数组 的非0数据的个数
		int sum = 0;
		 for(int i = 0; i<chessArr1.length;i++) {
			 for(int j = 0; j < chessArr1[i].length;j++) {
				 if(chessArr1[i][j] != 0) {
					 sum++;
				 }
			 }
		 }
		 //2.创建对应的稀疏数组
		 int sparseArray[][] = new int[sum+1][3];
		 sparseArray[0][0]= chessArr1.length;
		 sparseArray[0][1]= chessArr1[0].length;
		 sparseArray[0][2]= sum;
		 int count = 1;
		 //遍历二维数组，将非零的数据放入sparseArray中；
		 for(int i = 0; i<chessArr1.length;i++) {
			 for(int j = 0; j < chessArr1[i].length;j++) {
				 if(chessArr1[i][j] != 0) {
					 sparseArray[count][0] = i;
					 sparseArray[count][1] = j;
					 sparseArray[count][2] = chessArr1[i][j];
					 count++;
				 }
			 }
		 }
		 System.out.println();
		 System.out.println("得到的稀疏数组：");
		 for(int[] row: sparseArray ) {
				for(int data:row) {
					System.out.printf("%d\t",data);
				}
				System.out.println();
			}
		System.out.println();
		//稀疏数组转二维数组的思路
		/*1、先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，
		 * 2、在读取稀疏数组后几行的数据，并赋值给原始的二维数组即可。
		 */
		int[][] chessArr2 = new int[sparseArray[0][0]][sparseArray[0][1]];
		for(int i = 1; i<sparseArray.length;i++) {
			chessArr2[sparseArray[i][0]][sparseArray[i][1]]=sparseArray[i][2];
		}
		System.out.println("恢复后的二维数组：");
		 for(int[] row: chessArr2 ) {
				for(int data:row) {
					System.out.printf("%d\t",data);
				}
				System.out.println();
			}
		System.out.println();
	
	}
2.1.2 单向链表

特点：随机存储，顺序存取，插入删除方便

链表是有序的列表，它在内存中以节点的方式存储，是链式存储。每个节点包含data域，next域，指向下一个节点，占用的不一定是连续空间。链表分带头节点的和不带头结点的，根据实际需要来确定。
在这里插入图片描述

单链表的创建示意图（添加）

在这里插入图片描述

1、第一种直接添加到链表的尾部

思路：

1、先创建一个head头节点，作用就是表示单链表的头；

2、每添加一个节点，就直接加入到链表的最后；

3、通过一个辅助变量遍历，帮助遍历整个链表。

//定义SingleLinkedListDemo来管理英雄
class SingleLinkedList1{
	//先初始化一个头节点，头节点不要动, 不存放具体的数据
	private HeroNode head = new HeroNode(0, null, null);
	//添加结点到单向链表
	//思路（不考虑编号顺序时）
	//1、找到当前链表的最后节点
	//2、将最后这个节点的next指向新的节点
	public void add(HeroNode heroNode){
		//head不能动，因此我们需要一个辅助遍历temp
		HeroNode temp = head;
		//遍历链表，找到最后
		while(true) {
		//找到链表的最后
			if(temp.next == null){
				break;
			}
			//没有找到最后
			temp = temp.next;
		}
		//当退出while循环时，temp就指向了链表的最后
		//将最后这个节点的next指向新的节点
		temp.next = heroNode;
	}



//定义HeroNode,每个HeroNode对象一个节点
class HeroNode{
	public int no;
	public String name;
	public String nickname;
	public HeroNode next;
	//构造器
	public HeroNode(int hNo, String hName, String hNickname){
		this.no = hNo;
		this.name = hName;
		this.nickname = hNickname;
	}
	//为了显示方便，重写toString()
	@Override
	public String toString() {
		return "HeroNode [no="+no +", name=" + name + ", nickname=" + nickname + "]";
	}
}

2、根据排名将英雄插入到指定位置（如果有这个排名，则添加失败，并给出提示信息）

思路：

1、首先找到新添加的节点的位置，是通过辅助变量（指针），通过遍历来搞定；

2、新的节点.next=temp.text；

3、将temp. next = 新的节点。

//根据排名将英雄插入到指定位置（如果有这个排名，则添加失败，并给出提示信息）
//第二种方式在添加英雄时，根据排名将英雄插入到指定位置
	//(如果有这个排名的英雄，则添加失败，并给出提示)
	public void addByOrder(HeroNode heroNode) {
		//因为头节点不能动，因此我们仍然通过一个指针（变量）来帮助找到添加的位置
		//因为单链表，因为我们找的temp时位于添加位置的前一个结点，否则无法插入
		HeroNode temp = head;
		boolean flag = false;//flag标志添加的编号是非存在，默认false
		while(true) {
			if (temp.next==null) {//temp已经到了链表的最后
				break;
			}
			if(temp.next.no > heroNode.no) {//找到位置了
				break;
			}
			else if(temp.next.no==heroNode.no) {//说明希望添加的heroNode的编号已经存在
				flag = true;//说明编号已经存在
				break;
			}
			temp = temp.next;//
		}
		//判断flag的值
		if(flag){
			System.out.printf("准备加入的英雄的编号%d已经存在了，不能加入\n",heroNode.no);
			
		}
		else {
			heroNode.next = temp.next;
			temp.next = heroNode;
		}
	}
//测试
singleLinkedList.addByOrder(hero1);
singleLinkedList.addByOrder(hero2);
singleLinkedList.addByOrder(hero3);
singleLinkedList.addByOrder(hero3);
singleLinkedList.addByOrder(hero4);

3、修改节点的信息

//修改节点的信息，根据no编号来修改，即no编号不能修改
	public void update(HeroNode newheroNode) {
		//判断是非空
		if(head.next == null) {
			System.out.println("链表为空");
			return;
		}
		//找到需要修改的节点，根据no编号
		//定义一个辅助变量
		HeroNode temp = head.next;
		boolean flag = false;//表示是非找到该节点
		while(true) {
			if(temp == null) {
				break;//已经遍历链表
			}
			if(temp.no == newheroNode.no) {
				//找到
				flag = true;
				break;
			}
			temp = temp.next;
		}
		//根据flag判断是非找到要修改的节点
		if(flag) {
			temp.name = newheroNode.name;
			temp.nickname = newheroNode.nickname;
		}else {
			System.out.printf("没有找到编号%d的节点", newheroNode.no);
		}
	}

//测试修改节点的代码
HeroNode newHeroNode = new HeroNode(2, "小卢", "玉麒麟~~");
singleLinkedList.update(newHeroNode);
//显示
singleLinkedList.list();

4、单链表删除

思路：

1、我们先找到需要删除的节点的前一个节点temp；

2、temp.next = temp.next.next；

3、被删除的节点，将不会有其他引用指向，会被垃圾回收机制回收。

//删除节点
	public void del(int no) {
		//判断是非空
		if(head.next == null) {
			System.out.println("链表为空");
			return;
		}
		HeroNode temp = head;
		boolean flag = true;
		while(true) {
			if(temp.next == null) {
				break;//已经遍历链表
			}
			if(temp.next.no == no) {
				//找到
				temp.next = temp.next.next;
				flag = false;
				break;
			}
			temp = temp.next;
		}
		if(flag) {
			System.out.printf("没有找到编号%d的节点，不能删除\n", no);
		}
	}

singleLinkedList.del(2);
//显示
singleLinkedList.list();

5、查找

	//查找
	public void ind(int no) {
		if(head.next == null) {
			System.out.println("链表为空");
			return;
		}
		HeroNode temp = head.next;
		boolean flag = true;
		while(true) {
			if(temp.next == null) {
				break;//已经遍历链表
			}
			if(temp.no == no) {
				//找到
				System.out.println(temp);
				flag = false;
				break;
			}
			temp = temp.next;
		}
		if(flag) {
			System.out.printf("没有找到编号%d的节点\n", no);
		}
		
	}

总体代码

public class SingleLinkedLIst{
	public static void main(String[] args) {
		//进行测试
		//先创建节点
		HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
		HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
		HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
		HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
		//创建单链表
		SingleLinkedList1 singleLinkedList = new SingleLinkedList1();
		//加入
//		singleLinkedList.add(hero1);
//		singleLinkedList.add(hero2);
//		singleLinkedList.add(hero3);
//		singleLinkedList.add(hero4);
		
		singleLinkedList.addByOrder(hero1);
		singleLinkedList.addByOrder(hero2);
		singleLinkedList.addByOrder(hero3);
		singleLinkedList.addByOrder(hero3);
		singleLinkedList.addByOrder(hero4);
		
		//显示
		singleLinkedList.list();
		
		//测试修改节点的代码
		HeroNode newHeroNode = new HeroNode(2, "小卢", "玉麒麟~~");
		singleLinkedList.update(newHeroNode);
		//显示
		singleLinkedList.list();
		
		singleLinkedList.del(1);
		//显示
		singleLinkedList.list();
		
		singleLinkedList.ind(2);
	}

}

//定义SingleLinkedListDemo来管理英雄
class SingleLinkedList1{
	//先初始化一个头节点，头节点不要动, 不存放具体的数据
	private HeroNode head = new HeroNode(0, null, null);
	//添加结点到单向链表
	//思路（不考虑编号顺序时）
	//1、找到当前链表的最后节点
	//2、将最后这个节点的next指向新的节点
	public void add(HeroNode heroNode){
		//head不能动，因此我们需要一个辅助遍历temp
		HeroNode temp = head;
		//遍历链表，找到最后
		while(true) {
		//找到链表的最后
			if(temp.next == null){
				break;
			}
			//没有找到最后
			temp = temp.next;
		}
		//当退出while循环时，temp就指向了链表的最后
		//将最后这个节点的next指向新的节点
		temp.next = heroNode;
	}
	
	//第二种方式在添加英雄时，根据排名将英雄插入到指定位置
	//(如果有这个排名的英雄，则添加失败，并给出提示)
	public void addByOrder(HeroNode heroNode) {
		//因为头节点不能动，因此我们仍然通过一个指针（变量）来帮助找到添加的位置
		//因为单链表，因为我们找的temp时位于添加位置的前一个结点，否则无法插入
		HeroNode temp = head;
		boolean flag = false;//flag标志添加的编号是非存在，默认false
		while(true) {
			if (temp.next==null) {//temp已经到了链表的最后
				break;
			}
			if(temp.next.no > heroNode.no) {//找到位置了
				break;
			}
			else if(temp.next.no==heroNode.no) {//说明希望添加的heroNode的编号已经存在
				flag = true;//说明编号已经存在
				break;
			}
			temp = temp.next;//
		}
		//判断flag的值
		if(flag){
			System.out.printf("准备加入的英雄的编号%d已经存在了，不能加入\n",heroNode.no);
			
		}
		else {
			heroNode.next = temp.next;
			temp.next = heroNode;
		}
	}
	
	//修改节点的信息，根据no编号来修改，即no编号不能修改
	public void update(HeroNode newheroNode) {
		//判断是非空
		if(head.next == null) {
			System.out.println("链表为空");
			return;
		}
		//找到需要修改的节点，根据no编号
		//定义一个辅助变量
		HeroNode temp = head.next;
		boolean flag = false;//表示是非找到该节点
		while(true) {
			if(temp == null) {
				break;//已经遍历链表
			}
			if(temp.no == newheroNode.no) {
				//找到
				flag = true;
				break;
			}
			temp = temp.next;
		}
		//根据flag判断是非找到要修改的节点
		if(flag) {
			temp.name = newheroNode.name;
			temp.nickname = newheroNode.nickname;
		}else {
			System.out.printf("没有找到编号%d的节点", newheroNode.no);
		}
	}
	
	//删除节点
	public void del(int no) {
		//判断是非空
		if(head.next == null) {
			System.out.println("链表为空");
			return;
		}
		HeroNode temp = head;
		boolean flag = true;
		while(true) {
			if(temp.next == null) {
				break;//已经遍历链表
			}
			if(temp.next.no == no) {
				//找到
				temp.next = temp.next.next;
				flag = false;
				break;
			}
			temp = temp.next;
		}
		if(flag) {
			System.out.printf("没有找到编号%d的节点，不能删除\n", no);
		}
	}
	
	//查找
	public void ind(int no) {
		if(head.next == null) {
			System.out.println("链表为空");
			return;
		}
		HeroNode temp = head.next;
		boolean flag = true;
		while(true) {
			if(temp.next == null) {
				break;//已经遍历链表
			}
			if(temp.no == no) {
				//找到
				System.out.println(temp);
				flag = false;
				break;
			}
			temp = temp.next;
		}
		if(flag) {
			System.out.printf("没有找到编号%d的节点\n", no);
		}
		
	}
	
	//显示链表
	public void list() {
		if(head.next == null) {
			System.out.println("链表为空");
			return;
		}
		//头节点不能动，因此我们需要一个辅助变量
		HeroNode temp = head.next;
		while(true) {
			if(temp == null) {
				break;
			}
			//输出节点信息
			System.out.println(temp);
			//节点后移
			temp = temp.next;
		}
	}
	
}


//定义HeroNode,每个HeroNode对象一个节点
class HeroNode{
	public int no;
	public String name;
	public String nickname;
	public HeroNode next;
	//构造器
	public HeroNode(int hNo, String hName, String hNickname){
		this.no = hNo;
		this.name = hName;
		this.nickname = hNickname;
	}
	//为了显示方便，重写toString()
	@Override
	public String toString() {
		return "HeroNode [no="+no +", name=" + name + ", nickname=" + nickname + "]";
	}
}

大厂面试题

1、获取单链表的长度

public static int getlength(HeroNode head) {
		if(head.next == null) {
			return 0;
		}
		int length = 0;
		HeroNode temp = head.next;
		while (temp!= null) {
			length++;
			temp = temp.next;
		}
		return length;
	}

//配合返回头节点函数一起使用
public HeroNode gethead() {
	return head;
}
//测试
System.out.println(getlength(singleLinkedList.gethead()));

2、查找单链表中的倒数第K个节点

//查找单链表的倒数第K个节点
	public static HeroNode findLastIndexNode(HeroNode head,int index) {
		if(head.next == null) {//链表为空
			return null;
		}
		int length = getlength(head);
		if(index <= 0 || index > length) {//查找位置不合理
			return null;
		}
		HeroNode cur = head.next;
		for(int i = 0; i<length-index4; i++) {//查找正确位置
			cur = cur.next;
		}
		return cur;
	}}
//测试
System.out.println(findLastIndexNode(singleLinkedList.gethead(), 1));

3、将单链表反转

思路：

  • 定义一个新节点 revered = new HeroNode()；
  • 从头到尾遍历原来的链表，每遍历一个节点，摘下，使用后插法加入新链表
  • 将原来的头节点指向新链表的第一个节点
	//将单链表翻转
	public static void reversetList(HeroNode head) {
		//当链表为空或只有一个节点时，直接返回
		if(head.next == null || head.next.next== null) {
			return ;
		}
		HeroNode cul = head.next;//指向原来链表的第一个节点
		HeroNode next = null;//用来保存cul的next节点指针
		HeroNode reversetHead = new HeroNode(0, "", "");//定义一个新链表
		
		while(cul != null) {
			next = cul.next;//保存cul的next节点指针，防止原来链表“断裂”
			cul.next = reversetHead.next;//将cul.next = null;
			reversetHead.next = cul;//将新链表的表头指向cul，；连接起来
			cul = next;//实质上:指向原来cul的下一个节点
		}
		//将head.next指向翻转后的新链表的第一个节点，实际上实现原来链表的翻转
		head.next = reversetHead.next;
	}

4、从头到尾打印单链表

方式1：反向遍历

将单链表翻转，然后再遍历，这样做的缺点是破坏了单链表的原有结构。

方式2：栈

可以利用栈这种数据结构，将各个节点压入栈中，然后利用栈先进后出的特点，就实现逆序打印的效果。

//演示栈的使用
import java.util.Stack;
public class TestStrack {
	public static void main(String[] arge) {
		Stack<String> stack = new Stack();
		
		//入栈
		stack.add("joker");
		stack.add("luhan");
		//出栈
		while (stack.size()>0) {
			System.out.println(stack.pop());
		}
	}
}

第二种方式实现

//可以利用栈这种数据结构，将各个节点压入栈中，然后利用栈先进后出的特点，就实现逆序打印的效果。
	public static void reverPrint(HeroNode head) {
		if(head.next==null) {
			return;
		}
		Stack<HeroNode> stack = new Stack<HeroNode>();
		HeroNode cur = head.next;
		while (cur != null) {
			stack.push(cur);
			cur = cur.next;
		}
		while (stack.size()>0) {
			System.out.println(stack.pop());
		}
	}

下一篇更新内容：双向链表，单向环形链表以及线性表蓝桥杯历年相关真题

彗尧
关注
  • 29
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
备战蓝桥杯
jhy112345678的博客
02-28 277
1.从键盘上输入一个字符，若该字符是大写字母，在屏幕上输出对应的小写字母。若不是大写字母，请给出相应提示：“这不是一个大写字母” 技巧：可以用int cha = 'a' - 'A'表示大小写之间的ASC码值的差 A - Z的差是25 A-a的差是32 #include<iostream> #include<ctime> #include<string> using namespace std; int main() { char ch = 0; cin &gt
蓝桥杯备赛
Roninhay的博客
11-22 251
文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能.
蓝桥杯备战01
m0_62477180的博客
03-10 113
备战蓝桥杯java
蓝桥杯备战刷题one（自用）
热门推荐
gyeolhada的博客
02-25 3万+
蓝桥杯备战刷题one（自用）
蓝桥杯备战蓝桥杯备战蓝桥杯备战
01-14
【描述】：“蓝桥杯备战蓝桥杯备战蓝桥杯备战蓝桥杯备战蓝桥杯备战蓝桥杯备战蓝桥杯备战蓝桥杯备战蓝桥杯备战蓝桥杯备战”这段描述强调了反复进行的备战工作，这可能包括系统的训练计划、模拟测试、算法学习和问题...
蓝桥杯备战.zip蓝桥杯备战.zip蓝桥杯备战.zip
01-08
标题"蓝桥杯备战.zip"表明这是一个与"蓝桥杯"相关的学习资料或训练包，可能是为了参加蓝桥杯比赛而准备的一系列资源。由于标题重复了三次，这可能是用户在强调该文件的重要性和针对性。描述中的内容同样重复，可能是...
bluebridgecup-蓝桥杯备战
04-13
蓝桥杯
蓝桥杯备战基础知识点.doc
03-25
### 蓝桥杯备战基础知识点 #### 链表基础 **链表**是一种常见的数据结构，在计算机科学中有着广泛的应用。链表由一系列节点组成，每个节点包含实际存储的数据和指向下一个节点的指针。 ##### Python 实现 1. **...
C语言蓝桥杯备战.zip
02-05
C语言蓝桥杯备战.zip
蓝桥杯 2024 年第十五届省赛真题 —— 最大异或结点
执梗的博客
07-23 1196
蓝桥杯 2024 年第十五届省赛真题 —— 最大异或结点
#职场发展#其他
2401_82818414的博客
05-28 1584
首先，一闪论文提供了丰富的模板和格式选择，用户可以根据自己的需求和要求轻松定制论文的格式，避免因排版问题而浪费时间。最重要的是，一闪论文还具有强大的查重降重功能，能够自动检测文本的重复率，帮助用户排除抄袭内容，确保文章的原创性。一闪论文是目前市场上一款非常靠谱的论文写作工具，不仅可以帮助用户快速完成论文撰写，还能对文章进行查重降重，确保内容原创性。综上所述，一闪论文是一个非常靠谱、实用、方便的写作工具，不仅能帮助用户快速完成论文撰写，还能确保文章的原创性，是值得推荐的一款软件。
golang 接口
m0_70982551的博客
07-24 872
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 461
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 569
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 550
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 346
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 398
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
学习笔记---java篇（0723）
m0_70630166的博客
07-23 839
java、数据类型、循环、选择等
蓝桥杯备战指南：实战技巧与解题策略
蓝桥杯-叶海荣课件.pptx是一份专门为准备参加蓝桥杯软件类竞赛的学生设计的珍贵资料。蓝桥杯作为一项重要的全国性编程竞赛，其目的是多方面的，既包括组织者的角度——通过实战提升参赛者的技能，培养人才，并通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值