内功之--链表

最新推荐文章于 2023-09-13 23:19:54 发布
最新推荐文章于 2023-09-13 23:19:54 发布
阅读量109 收藏 1
点赞数
分类专栏： java 文章标签： 单链表 双链表 循环链表 java数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuruizai110/article/details/104271291
版权

  1. 单链表

  • 链表内存存储
 头指针地址data域next域
head150110a2180
  120  
  130a4

 

170

 

  140a6null
  150a1110
  180a3130

 

 

 

 

 

 

 

 

 

总结：1.链表是以节点的方式存储的，是链式存储。

           2.各个节点不一定连续。

          3.链表分带头结点的链表和不带头节点的链表

          4.每个节点包含data域，next域：指向下一个节点

  • 实例

单链表基本操作

代码：

/** 
 * Project Name:leetcode 
 * File Name:SingleLinkedList.java 
 * Package Name:singlelinkedList 
 * Date:2020年2月5日下午4:18:04 
 * Copyright (c) 2020, chenzhou1025@126.com All Rights Reserved. 
 * 
*/

package singlelinkedList;

import java.util.Stack;

/**
 * ClassName:SingleLinkedList <br/>
 * Function: TODO ADD FUNCTION. <br/>
 * Reason: TODO ADD REASON. <br/>
 * Date: 2020年2月5日 下午4:18:04 <br/>
 * 
 * @author yrz
 * @version
 * @see
 */
public class SingleLinkedListDemo {
	public static void main(String[] args) {
		SingleLinkedList singleLinkedList = new SingleLinkedList();
		Node node1 = new Node(1, "宋江", "及时雨");
		Node node2 = new Node(2, "吴用", "智多星");
		Node node3 = new Node(3, "卢俊义", "玉麒麟");
		Node node4 = new Node(4, "林冲", "豹子头");

//		singleLinkedList.add(node1);
//		singleLinkedList.add(node4);
//		singleLinkedList.add(node3);
//		singleLinkedList.add(node2);

		singleLinkedList.addByOrder(node1);
		singleLinkedList.addByOrder(node2);
		singleLinkedList.addByOrder(node3);
		singleLinkedList.addByOrder(node4);
		singleLinkedList.List();
		System.out.println();
//		Node node5 = new Node(3, "鲁智深", "花和尚");
//		singleLinkedList.update(node5);
//		singleLinkedList.List();
//		System.out.println();
//		singleLinkedList.delete(node5);
//		singleLinkedList.List();
//		int res = SingleLinkedListDemo.getLength(singleLinkedList.getHeadNode());
//		System.out.println("res=" + res);
//
//		System.out.println();

		// 找到倒数第key个节点
//		Node indexNode = SingleLinkedListDemo.getNodeInfo(singleLinkedList.getHeadNode(), 1);
//
//		System.out.println(indexNode);

		// 反转链表
//		System.out.println();
//		SingleLinkedListDemo.reverseSingLinkedList(singleLinkedList.getHeadNode());
//
//		singleLinkedList.List();
		//倒序输出链表
		System.out.println("-------------");
		SingleLinkedListDemo.reverseprint(singleLinkedList.getHeadNode());
	}

	// 获取单链表有效个数

	public static int getLength(Node headNode) {
		// 链表为空，返回0
		if (headNode.next == null) {
			return 0;
		}

		Node temp = headNode;// 临时指针变量，用于遍历链表节点使用。
		int count = 0;// 记录有效节点的变量
		while (true) {
			if (temp.next != null) {
				count++;
				temp = temp.next;
			} else {
				break;
			}
		}

		return count;
	}

	// 获取倒数第K个节点信息
	public static Node getNodeInfo(Node headNode, int index) {
		// 空链表
		if (headNode.next == null) {
			return null;
		}
		// 获取链表大小
		int size = 0;
		Node temp = headNode;
		size = SingleLinkedListDemo.getLength(headNode);
		// index校验
		if (index < 0 || index > size) {
			return null;
		}
		// 找到倒数倒数第k个节点位置
		for (int i = 0; i <= size - index; i++) {
			temp = temp.next;
		}
		return temp;
	}

	// 单链表反转

	public static void reverseSingLinkedList(Node headNode) {
		if (headNode.next == null) {
			return;
		}
		Node temp = headNode;
		Node curNextNode = null;// 当前节点的下一个节点
		Node reverseNode = new Node(0, "", "");

		while (temp.next != null) {

			curNextNode = temp.next.next;// 当前有效节点的下一个节点
			temp.next.next = reverseNode.next;// 新链表的头节点的下一个节点给反转链表头节点的下一个节点
			reverseNode.next = temp.next;// 反转链表头节点和新节点连接
			temp.next = curNextNode;// 指针后移

		}

		headNode.next = reverseNode.next;
	}

	// 从尾到头打印单链表（使用栈）
	public static void reverseprint(Node headNode) {
		if (headNode.next == null) {
			return ;
		}
		Node temp = headNode;
		Stack<Node> stack = new Stack<Node>();
		while (temp.next != null) {
				stack.add(temp.next);
				temp = temp.next;
		}
		
		while(stack.size()>0) {
			System.out.println(stack.pop());
		}
	
	}

}

//创建链表
class SingleLinkedList {
	// 初始化头节点
	Node headNode = new Node(0, "", "");

	public Node getHeadNode() {
		return headNode;
	}

	// 直接添加链表尾部
	public void add(Node node) {
		Node temp = headNode;// 指针变量，从头节点开始遍历
		while (true) {
			// 判断是不是链表尾部
			if (temp.next == null) {
				break;
			}
			// temp后移
			temp = temp.next;
		}
		// 此时指针指向最后一个节点，节点的next指向新节点。添加元素完成
		temp.next = node;
	}

	// 添加节点时，根据no将英雄插入指定位置
	public void addByOrder(Node node) {
		boolean flag = false;// 用于判断添加节点是否重复
		Node temp = headNode;
		while (true) {
			// 判断是否是链表尾部，是的话直接添加
			if (temp.next == null) {
				break;
			}
			// 判断添加节点是否重复
			if (temp.next.no == node.no) {
				flag = true;
				break;
			}
			// 判断插入位置
			if (temp.next.no > node.no) {
				break;
			}
			// 指针后移
			temp = temp.next;
		}

		if (flag) {
			System.out.println("当前添加节点已存在，编号是" + node.no);
		} else {
			// 插入新节点
			node.next = temp.next;
			temp.next = node;
		}

	}

	// 修改节点
	public void update(Node node) {
		Node temp = headNode;
		boolean flag = false;
		while (true) {
			// 判断链表是否为空
//			if (temp.next == null) {
//				break;
//			}
			// 找到要修改的节点
			if (temp.no == node.no) {
				flag = true;
				break;
			}
			// 指针后移
			temp = temp.next;
		}

		if (flag) {
			temp.name = node.name;
			temp.nickname = node.nickname;
		}
	}

	// 删除指定节点
	public void delete(Node node) {
		Node temp = headNode;
		boolean flag = false;
		while (true) {
			// 链表最后，退出
			if (temp.next == null) {
				break;
			}
			// 找到要删除的节点的前一个节点
			if (node.no == temp.next.no) {
				flag = true;
				break;
			}
			temp = temp.next;
		}

		if (flag) {
			temp.next = temp.next.next;
		} else {
			System.out.printf("要删除的%d节点不存在\n", node.no);
		}

	}

	// 遍历链表
	public void List() {
		Node temp = headNode;
		while (true) {
			// 判断链表是否为空
			if (temp.next != null) {
				System.out.println(temp.next.toString());
				temp = temp.next;
			} else {
				break;
			}

		}
	}
}

//创建节点
class Node {
	int no;
	String name;
	String nickname;
	Node next;

	public Node(int no, String name, String nickname) {
		this.no = no;
		this.name = name;
		this.nickname = nickname;
	}

	@Override
	public String toString() {
		return "Node [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
	}

}
  • 面试题

     一.  获取单链表有效个数

// 获取倒数第K个节点信息
	public static Node getNodeInfo(Node headNode, int index) {
		// 空链表
		if (headNode.next == null) {
			return null;
		}
		// 获取链表大小
		int size = 0;
		Node temp = headNode;
		size = SingleLinkedListDemo.getLength(headNode);
		// index校验
		if (index < 0 || index > size) {
			return null;
		}
		// 找到倒数倒数第k个节点位置
		for (int i = 0; i <= size - index; i++) {
			temp = temp.next;
		}
		return temp;
	}


       二. 单链表反转

       思路分析：

// 单链表反转

	public static void reverseSingLinkedList(Node headNode) {
		if (headNode.next == null) {
			return;
		}
		Node temp = headNode;
		Node curNextNode = null;// 当前节点的下一个节点
		Node reverseNode = new Node(0, "", "");

		while (temp.next != null) {

			curNextNode = temp.next.next;// 当前有效节点的下一个节点
			temp.next.next = reverseNode.next;// 新链表的头节点的下一个节点给反转链表头节点的下一个节点
			reverseNode.next = temp.next;// 反转链表头节点和新节点连接
			temp.next = curNextNode;// 指针后移

		}

		headNode.next = reverseNode.next;
	}

       三. 从尾到头打印单链表（使用栈）

// 从尾到头打印单链表（使用栈）
	public static void reverseprint(Node headNode) {
		if (headNode.next == null) {
			return ;
		}
		Node temp = headNode;
		Stack<Node> stack = new Stack<Node>();
		while (temp.next != null) {
				stack.add(temp.next);
				temp = temp.next;
		}
		
		while(stack.size()>0) {
			System.out.println(stack.pop());
		}
	
	}

2.双链表

  • 单向链表的缺点 

        查找方向只有一个，双向链表可以向前或者向后查找

       双向链表可以可以自行删除节点，单向节点不能自动删除，需要辅助节点

双向链表基本操作：

思路

 

代码实现：

/** 
 * Project Name:leetcode 
 * File Name:DoubleLinkedList.java 
 * Package Name:singlelinkedList 
 * Date:2020年2月7日上午11:36:36 
 * Copyright (c) 2020, chenzhou1025@126.com All Rights Reserved. 
 * 
*/

package singlelinkedList;

/**
 * ClassName:DoubleLinkedList <br/>
 * Function: TODO ADD FUNCTION. <br/>
 * Reason: TODO ADD REASON. <br/>
 * Date: 2020年2月7日 上午11:36:36 <br/>
 * 
 * @author yrz
 * @version
 * @see
 */
public class DoubleLinkedListDemo {
	public static void main(String[] args) {
		DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
		Node2 node1 = new Node2(1, "宋江", "及时雨");
		Node2 node2 = new Node2(2, "吴用", "智多星");
		Node2 node3 = new Node2(3, "卢俊义", "玉麒麟");
		Node2 node6 = new Node2(6, "林冲", "豹子头");

		doubleLinkedList.addData(node1);
		doubleLinkedList.addData(node2);
		doubleLinkedList.addData(node3);
		doubleLinkedList.addData(node6);
		doubleLinkedList.List();
		System.out.println();

		Node2 node4 = new Node2(4, "鲁智深", "花和尚");

		doubleLinkedList.addByOrder(node4);
		doubleLinkedList.List();
		System.out.println();

		// 删除节点
		doubleLinkedList.deleteNode(6);
		doubleLinkedList.List();

		// 修改节点信息
		System.out.println();
		doubleLinkedList.update(new Node2(4, "xxx", "ccc"));
		doubleLinkedList.List();

	}
}

//双向链表
class DoubleLinkedList {
	// 初始化头节点
	Node2 headNode = new Node2(0, "", "");

	public Node2 getHeadNode() {
		return headNode;
	}

	// 添加节点到链表尾部

	public void addData(Node2 node) {
		Node2 temp = headNode;
		while (true) {
			// 判断是否是链表尾部，是的话直接添加
			if (temp.next == null) {
				break;
			} else {
				temp = temp.next;
			}
		}

		temp.next = node;
		node.pre = temp;
	}

	// 添加按顺序插入节点
	public void addByOrder(Node2 node) {
		boolean flag = false;// 用于判断添加节点是否重复
		Node2 temp = headNode;
		while (true) {
			// 判断是否是链表尾部，是的话直接添加
			if (temp.next == null) {
				break;
			}
			// 判断添加节点是否重复
			if (temp.next.no == node.no) {
				flag = true;
				break;
			}
			// 判断插入位置
			if (temp.next.no > node.no) {
				break;
			}
			// 指针后移
			temp = temp.next;
		}

		if (flag) {
			System.out.println("当前添加节点已存在，编号是" + node.no);
		} else {
			// 插入新节点
			// 插入节点和后一个节点连接
			temp.next.pre = node;
			node.next = temp.next;
			// 插入节点和前一个节点连接
			temp.next = node;
			node.pre = temp;
		}

	}

	// 删除节点
	public void deleteNode(int no) {
		Node2 temp = headNode;
		boolean flag = false;
		while (true) {
			// 链表最后，退出
			if (temp.next == null) {
				break;
			}
			// 找到要删除的节点的前一个节点
			if (no == temp.next.no) {
				flag = true;
				break;
			}
			temp = temp.next;
		}

		if (flag) {
			//最后一个节点，释放指针
			if (temp.next.next != null) {
				//后继元素的前驱指向前一个元素
				temp.next.next.pre = temp.next.pre;
			}
			//前驱元素的后继指向后继元素
			temp.next.pre.next = temp.next.next;

			// temp.next = temp.next.next;
		} else {
			System.out.printf("要删除的%d节点不存在\n", no);
		}

	}

	// 修改节点
	public void update(Node2 node) {
		Node2 temp = headNode;
		boolean flag = false;
		while (true) {
			// 判断链表是否为空
//				if (temp.next == null) {
//					break;
//				}
			// 找到要修改的节点
			if (temp.no == node.no) {
				flag = true;
				break;
			}
			// 指针后移
			temp = temp.next;
		}

		if (flag) {
			temp.name = node.name;
			temp.nickname = node.nickname;
		}
	}

	// 遍历链表
	public void List() {
		Node2 temp = headNode;
		while (true) {
			// 判断链表是否为空
			if (temp.next != null) {
				System.out.println(temp.next.toString());
				temp = temp.next;
			} else {
				break;
			}

		}
	}

}

//创建节点
class Node2 {
	int no;
	String name;
	String nickname;
	Node2 next;// 后继节点
	Node2 pre;// 前驱节点

	public Node2(int no, String name, String nickname) {
		this.no = no;
		this.name = name;
		this.nickname = nickname;
	}

	@Override
	public String toString() {
		return "Node [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
	}

}

3.循环链表

  • Josephu约瑟夫问题

思路：

1.创建一个环形链表来表示这个圈：

2.出队列

 

代码实现：

/** 
 * Project Name:leetcode 
 * File Name:Josephu.java 
 * Package Name:singlelinkedList 
 * Date:2020年2月8日下午10:07:05 
 * Copyright (c) 2020, chenzhou1025@126.com All Rights Reserved. 
 * 
*/

package singlelinkedList;

/**
 * ClassName:Josephu <br/>
 * Function: TODO ADD FUNCTION. <br/>
 * Reason: TODO ADD REASON. <br/>
 * Date: 2020年2月8日 下午10:07:05 <br/>
 * 
 * @author yrz
 * @version
 * @see
 */
public class Josephu {

	public static void main(String[] args) {
		CircularLinkedList circularLinkedList = new CircularLinkedList();
		circularLinkedList.add(15);
		circularLinkedList.List();
		System.out.println();
		circularLinkedList.countNode(1, 2, 15);
	}
}

//创建循环链表
class CircularLinkedList {
	//第一个节点
	Node3 first = null;

	// 添加节点
	public void add(int nums) {
		// 校验nums
		if (nums < 1) {
			return;
		}
		// 辅助指针
		Node3 temp = null;

		for (int i = 1; i <= nums; i++) {
			// 第一个节点
			Node3 node = new Node3(i);
			if (i == 1) {
				first = node;
				first.setNext(node);// 构成环
				temp = first;
			} else {
				temp.setNext(node);// 指向下一个节点
				node.setNext(first);// 构成环
				temp = node;// 指针后移
			}
		}

	}

	/**
	 * 出环
	 * @author Administrator 
	 * @param startNo--从第几个开始
	 * @param count--数几下
	 * @param nums --一共几个节点
	 * @since JDK 1.6
	 */
	public void countNode(int startNo, int count, int nums) {
		Node3 temp = first;
		// 校验数据
		if (startNo < 1 || count > nums) {
			System.out.println("数据错误");
			return;
		}
		// 事先指向链表最后一个节点
		while (true) {
			if (temp.getNext() == first) {
				break;
			}

			temp = temp.getNext();
		}
		// 报数前，将first和temp移动startNo-1次
		for (int i = 0; i < startNo - 1; i++) {
			first = first.getNext();
			temp = temp.getNext();
		}
		// 报数时，将first和temp移动count-1次
		while (true) {
			if (temp == first) {
				break;
			}
			for (int i = 0; i < count - 1; i++) {
				first = first.getNext();
				temp = temp.getNext();
			}

			// 出圈
			System.out.printf("出圈小孩编号%d\n", first.getNo());
			first = first.next;
			temp.next = first;
		}

		System.out.printf("最后一个出圈小孩编号%d\n", first.getNo());
	}

	// 遍历链表
	public void List() {
		Node3 temp = first;
		while (true) {
			System.out.printf("编号%d\n", temp.getNo());
			if (temp.next == first) {
				break;
			}
			temp = temp.next;
		}

	}
}

//创建节点
class Node3 {
	int no;
	Node3 next;

	public Node3(int no) {
		this.no = no;
	}

	public int getNo() {
		return no;
	}

	public void setNo(int no) {
		this.no = no;
	}

	public Node3 getNext() {
		return next;
	}

	public void setNext(Node3 next) {
		this.next = next;
	}

}

 

 

 

 

yuruizai110
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
编程内功心法-编程算法题库
07-14
### 编程内功心法—编程算法题库解析 #### 一、力扣题集概览 **力扣题集**是针对编程面试而设计的一系列算法题目，旨在帮助学习者掌握各种算法技巧和数据结构的应用。这些题目涵盖了广泛的难度级别，从简单到复杂...
程序员内功修炼-V1.0.pdf
04-05
文档中可能详细介绍了数组、链表、栈、队列、树（二叉树、堆、AVL树、红黑树等）、图、散列表等基本数据结构，以及排序（冒泡排序、选择排序、插入排序、快速排序、归并排序等）、查找（线性查找、二分查找、哈希...
Mongodb联合查询
chenzhou123520的专栏
08-19 1433
在关系型数据库中，通过连接运算符可以实现多个表联合查询。而非关系型数据库的特点是表之间属于弱关联，Mongodb作为Nosql代表，其本身特性不建议对多Collection关联处理，不过对于有些需要对多表关联处理的需求，Mongodb也可以实现。主要分为两种方式：简单手工关联和DBRef方式关联   1.简单手工关联 下图表示帖子和用户两个Collection的ER图： 首先将auth...
mysql乐观锁实现_mysql实现乐观锁实例(demo)
weixin_36163672的博客
01-18 1425
本文参考：https://blog.csdn.net/seapeak007/article/details/53490156，感谢老铁的辛苦付出。乐观锁介绍：乐观锁( Optimistic Locking ) 相对悲观锁而言，乐观锁假设认为数据一般情况下不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果发现冲突了，则让返回用户错误的信息，让用户决定如何去做。那么我们...
内功之--队列
yuruizai110的博客
02-04 119
一.队列介绍 有序列表，可以用数组和链表实现。 先进先出。 二.数组模拟队列 1.队列是有序的，可以使用数组来模拟。MaxSize是数组的最大容量。 2.front和rear变量记录队列前后端的下标。front随着取出数据而变化，rear随着添加数据而变化。 3.当在队列中加入元素时： 判断队列是否满： 满的条件：rear == MaxSize - 1 rear下标后移...
内功之--稀疏数组
yuruizai110的博客
02-02 188
线性结构 数据元素之间存在一对一的线性关系。 存储结构。顺序存储（数组）和链式存储（链表） 。顺序存储的线性表称为顺序表，顺序表中的元素是连续的。 链表中的元素不一定是连续的。 常见的线性结构：数组，对列，链表和栈。 非线性结构 树，图 一.什么是稀疏数组？ 当一个数组中大部分元素为0，或者为同一个值时，可以用稀疏数组来保存该数组。 稀疏数组处理方...
内功之--哈希表
yuruizai110的博客
03-08 148
一.什么是哈希表 散列表(Hash table,也叫哈希表),是根据关键码值(Key value)而直接进行访问的数据结构.也就是说,它通 过把关键码值映射到表中一个位置来访问记录,以加快查找的速度.这个映射函数叫做散列函数,存放记录的数组 叫做散列表. 二.实现一个需求 有一个公司,当有新的员工来报道时,要求将该员工的信息加入(id,性别,年龄,名...
修炼内功---数据结构与算法4---链表结构
zhangdonghang
12-22 151
前置知识 &lt;?php /** * array_splice — 去掉数组中的某一部分并用其它值取代 * array array_splice ( array &amp;$input , int $offset [, int $length = count($input) [, mixed $replacement = array() ]] ) * 把 input 数组中由 offs...
编程内功修炼 - 算法
weixin_30784501的博客
08-24 163
编程内功讲什么？ 主要讲解以下算法： 分治法 堆排序 二叉树 动态规划 贪心算法 图 算法的作用： 算法解决了哪些问题？ 互联网信息的访问检测，海量数据的管理 在一个交通图中，寻找最近的路 人类基因工程，dna有10万个基因，处理这些基因序列需要复杂的算法支持 上面的算法是我们没有接触到，或者是封装到底层的东西，那么作为程序员，在日常...
刷题日记3.9-环形链表
Peace_1ove的博客
03-09 50
环形链表题目解决总结 题目 给定一个链表，判断链表中是否有环。 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。 如果链表中存在环，则返回 true 。 否则，返回 false 。 你能用 O(1)（即，常量）内存解决此问题吗？ 示例1： 输入：head = [3,2
C语言内功修炼---指针详讲（初阶）
稻草人敲代码的博客
09-13 184
都说会用一门语言几个礼拜就可以了。这句话我不敢苟同，至少在我学习C语言指针之后就不这么觉得了。不信？//代码1//代码2这两行代码出自《C陷阱和缺陷》我相信大部分人在第一次看这俩行代码都是一脸懵逼。是不是头皮发麻？这是啥东西？如果你是这样，那么请收起你的骄傲，再也不要觉得C语言很“简单”，谦虚一点，好好学习！好了，其实无论你能否一眼看出来以上代码所表示的意思，我觉得都不应该轻视任何一门语言，编程世界，浩瀚无边，人外有天，天外有人。
程序员内功修炼-V1.0和面试思维导图.zip
01-22
1. **基础编程知识**：包括但不限于数据结构（如数组、链表、树、图等）、算法（排序、查找、动态规划等）、操作系统原理（进程、线程、内存管理）、网络协议（TCP/IP五层模型、HTTP协议等）等。 2. **高级编程技能...
编程之禅--绝对经典
11-02
总的来说，《编程之禅--绝对经典》不仅是一本技术指南，更是一本引导程序员修炼内功的心法。通过阅读和实践书中的内容，程序员可以提升自己的编程思维，掌握解决问题的方法，从而在编程道路上更进一步。
计算机程序设计之内功心法
02-20
《计算机程序设计之内功心法》是一本专为算法初学者和有经验的程序员精心编写的教程。这本书深入浅出地介绍了程序设计的核心概念和算法基础，旨在帮助读者建立起坚实的编程思维和技能。 首先，书中的内容可能涵盖...
web项目安全漏洞防御实战
yuruizai110的博客
04-20 872
LK最近在对已有项目进行安全漏洞防御，现在将一些心得分享出来和大家一起讨论.主要是从下面几个方面进行漏洞修复。 1. 跨站脚本攻击漏洞（xss） 2. 敏感数据未加密传输 3. 验证机制缺陷 4. Cookie中未设HttpOnly标识 5. 危险的HTTP方法未禁用 1.跨站脚本攻击漏洞（xss） 先来了解一下什么是xss 概念 xss又叫css（cross site script...
itextpdf使用
yuruizai110的博客
04-08 674
LK最近项目中要进行对pdf的操作，具体需求是要在现有pdf文件末尾加入一下文字。 首先需要准备的jar包，itextpdf-5.5.5.jar和itext-asian-5.2.0.jar jar包可以在maven仓库中下 >https://mvnrepository.com/ 下完以后新建项目导入就行 代码 package test; import java.io.File...
springcloud整合nacos
yuruizai110的博客
06-15 645
springcloud整合nacos
算法小记-链表
yuruizai110的博客
04-08 575
基础决定高度
链表-遍历链表pta
最新发布
07-17
链表是一种常见的数据结构，它由一系列结点构成，每个结点包含一个数据元素和一个指向下一个结点的指针。链表中的每个结点都可以在内存中分散存储，因此链表能够动态地分配内存空间，可以在程序运行时动态地创建和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值