尚硅谷 java数据结构与算法 学习笔记(一)

最新推荐文章于 2023-02-21 01:08:49 发布
最新推荐文章于 2023-02-21 01:08:49 发布
阅读量5.6k 收藏 105
点赞数 12
分类专栏： 学习笔记 文章标签： 算法 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43691773/article/details/110420321
版权

这里写目录标题

线性结构和 非线性结构

在这里插入图片描述

稀疏数组SparseArray

需求

记录棋盘的位置 可用用二位数组将它保存 ,但是会发现记录很多没有意义的数据很多空间浪费 可以用稀疏数组进行优化
在这里插入图片描述

介绍

稀疏数组就是压缩缩多余的冗余数据
在这里插入图片描述
第一行的记录原表的行列数和 非0值的个数
在这里插入图片描述

实例

在这里插入图片描述
在这里插入图片描述

代码实现

package com.luyi.DataStructures.sparse;

import java.util.Date;

/**
 * @author 卢意
 * @create 2020-12-01 9:26
 */
public class SparseArray {
   
	public static void main(String[] args) {
   
		// 创建一个原始的二维数组 11 * 11
		// 0 表示 没有棋子 1表示黑子 2表示白子
		int chessArray[][] = new int[11][11];
		chessArray[1][2] = 1;
		chessArray[2][3] = 2;
		// 输出原始的二维数组
		System.out.println("输出原始的二维数组");
		for(int row[] : chessArray){
   
			for (int data : row){
   
				System.out.print(data + "\t");
			}
			System.out.println();
		}

		// 将二维数组转为稀疏数组的思路
		// 1 先遍历 二维数组 得到 非0 数据的个数
		int sum = 0;
		for(int i = 0; i < chessArray.length; i++){
   
			for(int j = 0; j<chessArray.length; j++ ){
   
				if(chessArray[i][j] != 0){
   
					sum++;
				}
			}
		}
		System.out.println("非0数据的个数 sum="+ sum);
		// 2 创建对应的稀疏数组
		int sparseArray[][] = new int[sum+1][3];
		// 给稀疏数组赋值
		sparseArray[0][0] = 11;
		sparseArray[0][1] = 11;
		sparseArray[0][2] = sum;

		// 遍历二维数组 将非0的值存放到稀疏数组中
		int index = 1;
		for(int i = 0; i < chessArray.length; i++){
   
			for(int j = 0; j<chessArray.length; j++ ){
   
				if(chessArray[i][j] != 0){
   
					sparseArray[index][0] = i;
					sparseArray[index][1] = j;
					sparseArray[index][2] = chessArray[i][j];
					index++;
				}
			}
		}
		// 输出稀疏数组
		System.out.println("得到的稀疏数组为:");
		for (int i = 0;i<sum+1;i++){
   
			System.out.print(sparseArray[i][0] + "\t");
			System.out.print(sparseArray[i][1] + "\t");
			System.out.print(sparseArray[i][2] + "\t");
			System.out.println();
		}

		// 稀疏数组恢复成二维数组
		// 1 读取稀疏数组的第一行 根据第一行的数据,  创建原始的二维数组
		// 2 在读取稀疏数组的后几行 并赋值
		int row = sparseArray[0][0];
		int cos = sparseArray[0][1];
		int newChessArray[][] = new int[row][cos];
		for(int i = 0; i < row; i++){
   
			for(int j = 0; j < cos; j++ ){
   
				newChessArray[i][j] = 0;
			}
		}
		for (int i = 1; i < sparseArray.length;i++){
   
			newChessArray[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
		}

		System.out.println("输出恢复的二维数组");
		for(int rows[] : chessArray){
   
			for (int data : rows){
   
				System.out.print(data + "\t");
			}
			System.out.println();
		}

	}

}

代码执行结果

输出原始的二维数组
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
非0数据的个数 sum=2
得到的稀疏数组为:
11 11 2
1 2 1
2 3 2
输出恢复的二维数组
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0

队列

介绍

在这里插入图片描述
上图的清晰图 rear待表队列的尾部 front代表数据的头部 存入数据时 front不变 rear变化 存数据时 rear位置不变 front 的位置在变化
在这里插入图片描述

数组模拟队列思路

rear == maxSize-1 为满 front指向队列头部的头一个位置 rear指向队列尾部的具体位置
在这里插入图片描述

代码实现

package com.luyi.DataStructures.queue;


import java.util.Scanner;

/**
 * @author 卢意
 * @create 2020-12-01 10:08
 * 数组模拟队列
 */
public class ArrayQueueDemo {
   
	public static void main(String[] args) {
   
		// 测试
		// 创建一个队列
		ArrayQueue arrayQueue = new ArrayQueue(3);
		char key = ' '; // 接收用户输入
		Scanner scanner = new Scanner(System.in);
		boolean loop = true; // 控制循环
		// 输出一个菜单
		while (loop){
   
			System.out.println("s(show): 显示对列");
			System.out.println("e(exit): 退出程序");
			System.out.println("a(add): 添加数据到对列");
			System.out.println("g(get): 从对列取出数据");
			System.out.println("h(head): 查看对列头的数据");
			key = scanner.next().charAt(0); //接收这个字符
			switch (key) {
   
				case 's':
					arrayQueue.showQueue();
					break;
				case 'a':
					System.out.println("输入一个数");
					int value = scanner.nextInt();
					arrayQueue.addQueue(value);
					break;
				case 'g':
					try {
   
						System.out.println("取出的数据:"+arrayQueue.getQueue());
					} catch (Exception e){
   
						System.out.println(e.getMessage());
					}
					break;
				case 'h':
					try {
   
						System.out.println("队列头部的数据:"+arrayQueue.headQueue());
					} catch (Exception e){
   
						System.out.println(e.getMessage());
					}
					break;
				case 'e':
					scanner.close();
					loop = false;
					break;
				default :
					break;
			}
		}
		System.out.println("程序退出");

	}
}

// 使用数组模拟队列  编写一个ArrayQueue类
class ArrayQueue {
   
	private int maxSize; // 表示数组的最大容量
	private int front; // 队列头部
	private int rear; // 队列尾部
	private int[] arr; // 存放数据  模拟队列

	// 创建队列的构造器
	public ArrayQueue(int maxSize){
   
		this.maxSize = maxSize;
		arr= new int[maxSize];
		front = rear = -1; // 队列头部和尾部 front指向队列头部的头一个位置  rear指向队列尾部的具体位置
	}

	// 判断队列是否满
	public Boolean isFull(){
   
		return rear == maxSize - 1;
	}

	// 判断对列是否为空
	public Boolean isEmpty(){
   
		return rear == front;
	}

	// 添加数据到对列
	public void addQueue(int n){
   
		// 判断队列是否满
		if(isFull()){
   
			System.out.println("队列满,不能加入数据");
			return;
		}
		// rear 后移
		arr[++rear] = n;
	}

	// 数据出队列
	public int getQueue(){
   
		// 判断对垒是否空
		if(isEmpty()){
   
			throw new RuntimeException("队列为空不能取数据");
		}
		return arr[++front];
	}

	// 显示对列的所有数据
	public void showQueue(){
   
		// 判断队列是否为空
		if(isEmpty()){
   
			System.out.println("队列为空");
			return;
		}
		for (int i = 0; i < arr.length; i++){
   
			System.out.println("arr["+i+"]="+arr[i]);
		}
	}

	// 显示对列的头部的数据  不是取出数据
	public int headQueue(){
   
		// 判断是否为空
		if(isEmpty()){
   
			throw new RuntimeException("队列为空,没有头数据");
		}
		return arr[front + 1];
	}
}

控制台结果

s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
s
队列为空
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a
输入一个数
10
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
s
arr[0]=10
arr[1]=0
arr[2]=0
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a
输入一个数
20
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a
输入一个数
30
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
s
arr[0]=10
arr[1]=20
arr[2]=30
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a
输入一个数
40
队列满,不能加入数据
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
h
队列头部的数据:10
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
g
取出的数据:10
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
h
队列头部的数据:20
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
g
取出的数据:20
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
g
取出的数据:30
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
g
队列为空不能取数据
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
h
队列为空,没有头数据
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据

问题

现在队列经历了加满 也全部取出 当前列表理论上为空
但是任然无法加入数据 这个数组无法复用 只能使用一次 没有到达复用的效果
需要将这个数组由算法改造成一个环形数组(取模)
在这里插入图片描述

数组模拟环形队列

注意现在调整了front 和 rear 队列的
在这里插入图片描述

环形队列代码实现

package com.luyi.DataStructures.queue;

import java.util.Scanner;

/**
 * 环形数组对列
 * @author 卢意
 * @create 2020-12-01 13:54
 */
public class CircleArrayQueue {
   
	public static void main(String[] args) {
   
		// 测试
		// 创建一个环形队列
		CircleArray arrayQueue = new CircleArray(4); // 设置为4 但是数组的有效空间是3
		char key = ' '; // 接收用户输入
		Scanner scanner = new Scanner(System.in);
		boolean loop = true; // 控制循环
		// 输出一个菜单
		while (loop){
   
			System.out.println("s(show): 显示对列");
			System.out.println("e(exit): 退出程序");
			System.out.println("a(add): 添加数据到对列");
			System.out.println("g(get): 从对列取出数据");
			System.out.println("h(head): 查看对列头的数据");
			key = scanner.next().charAt(0); //接收这个字符
			switch (key) {
   
				case 's':
					arrayQueue.showQueue();
					break;
				case 'a':
					System.out.println("输入一个数");
					int value = scanner.nextInt();
					arrayQueue.addQueue(value);
					break;
				case 'g':
					try {
   
						System.out.println("取出的数据:"+arrayQueue.getQueue());
					} catch (Exception e){
   
						System.out.println(e.getMessage());
					}
					break;
				case 'h':
					try {
   
						System.out.println("队列头部的数据:"+arrayQueue.headQueue());
					} catch (Exception e){
   
						System.out.println(e.getMessage());
					}
					break;
				case 'e':
					scanner.close();
					loop = false;
					break;
				default :
					break;
			}
		}
		System.out.println("程序退出");

	}
}


// 使用数组模拟队列  编写一个ArrayQueue类
class CircleArray  {
   
	private int maxSize; // 表示数组的最大容量
	// front 的变量的含义 做调整 就指向队列的第一个元素 也就是 arr[front] 是第一个头元素
	// front初始值变为0
	private int front; // 队列头部
	// rear 变量的含义做一个调整 rear指向队列的最后元素的后一个位置 因为希望空出一个空间做约定  rear的初始值为0
	private int rear; // 队列尾部
	private int[] arr; // 存放数据  模拟队列

	// 创建队列的构造器
	public CircleArray(int maxSize){
   
		this.maxSize = maxSize;
		arr= new int[maxSize];
		//front = rear = 0 ; // 队列头部和尾部 front指向队列头部的头一个位置  rear指向队列尾部的具体位置
	}

	// 判断队列是否满
	public boolean isFull(){
   
		return (rear + 1)% maxSize == front;
	}

	// 判断对列是否为空
	public boolean isEmpty(){
   
		return rear == front;
	}

	// 添加数据到对列
	public void addQueue(int n){
   
		// 判断队列是否满
		if(isFull()){
   
			System.out.println("队列满,不能加入数据");
			return;
		}
		// rear指向对位的后一个位置 直接将数据加入  在后移rear指针
		arr[rear] = n;
		// 要考虑取模 如果rear已经在 数组的最后位置  需要进行取模到数组的开始部分
		rear = (rear + 1) % maxSize;
	}

	// 数据出队列
	public int getQueue(){
   
		// 判断对垒是否空
		if(isEmpty()){
   
			throw new RuntimeException("队列为空不能取数据");
		}
	 	// 这里需要分析出front是 指向队列的第一个元素
		// 1 先把 front对应的值 保存到临时变量
		// 2 将front 后移
		// 3 将临时保存的变量返回
		int value = arr[front];
		front = (front + 1) % maxSize;
		return value;
	}

	// 显示对列的所有数据
	public void showQueue(){
   
		// 判断队列是否为空
		if(isEmpty()){
   
			System.out.println("队列为空");
			return;
		}
		// 思路: 从front开始遍历, 遍历多少个元素
		//
		for (int i = front; i < front + size(); i++){
   
			System.out.println("arr["+ i % maxSize +"]="+arr[i % maxSize]);
		}
	}

	// 显示对列的头部的数据  不是取出数据
	public int headQueue(){
   
		// 判断是否为空
		if(isEmpty()){
   
			throw new RuntimeException("队列为空,没有头数据");
		}
		return arr[front];
	}

	// 求出当前队列的有效数据的个数
	public int size() {
   
		return  (rear + maxSize - front) % maxSize;
	}
}

运行结果

s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
s
队列为空
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a
输入一个数
10
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a 20
输入一个数
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
s
arr[0]=10
arr[1]=20
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a 
输入一个数
30
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
s
arr[0]=10
arr[1]=20
arr[2]=30
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a
输入一个数
40
队列满,不能加入数据
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据

g
取出的数据:10
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
s
arr[1]=20
arr[2]=30
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a 10
输入一个数
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
s
arr[1]=20
arr[2]=30
arr[3]=10
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a 70
输入一个数
队列满,不能加入数据
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
h 
队列头部的数据:20
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
g 
取出的数据:20
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
g
取出的数据:30
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
g
取出的数据:10
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
g
队列为空不能取数据
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a 50
输入一个数
s(show): 显示对列
e(exit): 退出程序
a(add): 添加数据到对列
g(get): 从对列取出数据
h(head): 查看对列头的数据
a

链表

在这里插入图片描述

小结上图:

  1. 链表是以节点的方式来存储, 是链式存储
  2. 每个节点包含 data 域， next 域：指向下一个节点.
  3. 如图：发现 链表的各个节点不一定是连续存储.
  4. 链表分 带头节点的链表和 没有头节点的链表，根据实际的需求来确定

单链表

单链表看似连续 但是并不是 这只是逻辑结构
在这里插入图片描述

不考虑排名

在这里插入图片描述

考虑排名

在这里插入图片描述

修改

思路(1) 先找到该节点，通过遍历，(2) temp.name = newHeroNode.name ; temp.nickname= newHeroNode.nickname

删除

在这里插入图片描述

代码实现

package com.luyi.DataStructures.linkedlist;

/**
 * @author 卢意
 * @create 2020-12-01 21:10
 */
public class SingleLinkedListDemo {
   

	public static void main(String[] args) {
   
		// 先创建节点
		HeroNode heroNode1 = new HeroNode(1, "宋江", "及时雨");
		HeroNode heroNode2 = new HeroNode(2, "卢俊义", "玉麒麟");
		HeroNode heroNode3 = new HeroNode(3, "吴用", "智多星");
		HeroNode heroNode4 = new HeroNode(4, "林冲", "豹子头");

		// 创建一个链表
		SingleLinkedList singleLinkedList = new SingleLinkedList();
		// 加入
//		singleLinkedList.add(heroNode1);
//		singleLinkedList.add(heroNode2);
//		singleLinkedList.add(heroNode3);
//		singleLinkedList.add(heroNode4);
		/**
		 * 结果:
		 * HeroNode{no=1, name='宋江', nickName='及时雨'}
		 * HeroNode{no=2, name='卢俊义', nickName='玉麒麟'}
		 * HeroNode{no=3, name='吴用', nickName='智多星'}
		 * HeroNode{no=4, name='林冲', nickName='豹子头'}
		 */
		// 加入按照编号的顺序
		singleLinkedList.addByOrder(heroNode1);
		singleLinkedList.addByOrder(heroNode4);
		singleLinkedList.addByOrder(heroNode2);
		singleLinkedList.addByOrder(heroNode3);
		singleLinkedList.addByOrder(heroNode3);
		/**
		 * 结果
		 * 准备插入的英雄的编号[3]已存在,不能加入!
		 * HeroNode{no=1, name='宋江', nickName='及时雨'}
		 * HeroNode{no=2, name='卢俊义', nickName='玉麒麟'}
		 * HeroNode{no=3, name='吴用', nickName='智多星'}
		 * HeroNode{no=4, name='林冲', nickName='豹子头'}
		 */
		// 显示
		singleLinkedList.list();

		// 测试 修改节点
		HeroNode newHeroNode = new HeroNode(2, "小卢", "小麒麟");
		HeroNode newHeroNode1 = new HeroNode(5, "小卢", "小麒麟");
		singleLinkedList.update(newHeroNode );
		singleLinkedList.update(newHeroNode1 );
		/**
		 * 结果
		 * HeroNode{no=1, name='宋江', nickName='及时雨'}
		 * HeroNode{no=2, name='卢俊义', nickName='玉麒麟'}
		 * HeroNode{no=3, name='吴用', nickName='智多星'}
		 * HeroNode{no=4, name='林冲', nickName='豹子头'}
		 * 没有找到编号为[5]的节点
		 * 修改后的链表情况
		 *
		 * HeroNode{no=1, name='宋江', nickName='及时雨'}
		 * HeroNode{no=2, name='小卢', nickName='小麒麟'}
		 * HeroNode{no=3, name='吴用', nickName='智多星'}
		 * HeroNode{no=4, name='林冲', nickName='豹子头'}
		 */
		// 修改后的显示
		System.out.println("修改后的链表情况");
		System.out.println();
		singleLinkedList.list();

		System.out.println("删除一个节点");
		singleLinkedList.delete(1);
		singleLinkedList.delete(2);
		singleLinkedList.delete(3);
		singleLinkedList.delete(4);
		singleLinkedList.list();
		/**
		 * 结果
		 * 删除一个节点
		 * 链表为空
		 */

	}
}
// 定义一个单向链表 管理我们的英雄
class SingleLinkedList {
   
	// 初始化一下头结点  头结点不要动 不存放具体的数据
	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 = temp.next;
		}
		// 当退出white循环时, temp 就指向了链表的最后
		temp.next = heroNode;
	}

	// 第二种添加英雄的方式, 根据排名将英雄插入到指定位置
	// 如果有这个排名, 则添加失败 并给出提示
	public void addByOrder(HeroNode heroNode){
   
		// 因为头结点不能动 因此我们任然通过一个辅助指针(变量) 来帮助找到添加的位置
		// 因为是单列表 temp是要找到添加节点的前一个节点, 否则插入不了
		HeroNode temp = head;
		boolean flag = false; // 标志添加的编号是否存在 默认为false
		while(true) {
   
			if(temp.next == null) {
    // 说明已经到了链表的最后了
				break;
			}
			if (temp.next.no > heroNode.no) {
    // 位置找到了 在temp和temp.next之间插入该节点
				break;
最低0.47元/天 解锁文章
Java全栈百度工程师
关注
  • 12
    点赞
  • 踩
  • 105
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
尚硅谷JAVA基础笔记简单整理（一）
qq_45390826的博客
05-11 397
如果一个分支都无法匹配，那么一个分支都不会执行（注意是分支，一个case为一个分支，和分支外需要执行的语句没有关系），如果想要无法匹配也需要执行分支，那么可以增加default关键字（类似于else）。可以使用大小写来实现关键字名称的定义，比如 public 是关键字，不可作为标识符，但是Public 是可以作为标识符的。运算规则：判断条件表达式的结果，如果为true，那么执行任意表达式1的值，如果为false，那么执行任意表达式2的值。这里的类型是元素中类型最大的那一种，最小使用的类型为int类型。
【思维导图】Java基础笔记整理
一顿输出
03-15 1765
访问控制权限 抽象类与接口 : 参考资料 : https://blog.csdn.net/wei_zhi/article/details/52736350?spm=1001.2014.3001.5502 浅拷贝和深拷贝 :
数据结构_Java【学习笔记】线性表 + 符号表
做笔记，记录学习中遇到的问题。
02-21 334
本文的主要内容是记录了下面的数据结构的代码实现：顺序表、链表（单向链表、双向链表、链表反转、快慢指针、约瑟夫问题）、栈（括号匹配问题、逆波兰表达式）、队列；除了这些线性表外，还有符号表。
Java数据结构和算法学习笔记
zth13015409853的博客
01-05 900
Java程序员必须要掌握的几种数据结构和算法
数据结构与问题求解.java语言描述(第4版)英文版
11-04
英文书名为"Data Structures & Problem Solving Using Java(4th Edition)" 于09年出版,中文版于11年8月出版
韩顺平老师尚硅谷Java数据结构与算法194集笔记
10-12
这是我从B站上看韩老师讲的数据结构与算法后整理的笔记 代码经过运行，欢迎批评指正 有些地方我感觉还是挺难的 大都经过我自己的语言进行描述，韩老师中期的表达可能或多或少也影响可阅读性，望先生们见谅
Java数据结构与算法-笔记-代码-课件-资料
05-17
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、...
尚硅谷Java数据结构与java算法.zip
最新发布
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： ...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
2019尚硅谷java版数据结构算法学习.zip
01-14
算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
Java版数据结构与算法读书笔记（一）
02-11 1421
数据结构是数据之间相互存在的一种或多种特定关系元素的集合。 按逻辑结构来划分 集合机构 线性结构 树形结构 图形结构 物理结构 从内存和存储顺序来划分 1.顺序存储结构 2.链式存储结构 根据上面的结构，Java抽象出来对应的类 线性表（List） Java里面最基本的线性顺序结构就是数组。 对于添加和删除消耗会大一些，因为需要维护index。 Java里面典型的实现类是ArrayL...
java 数据结构笔记
weixin_40954192的博客
09-11 317
前言 数据结构就是指一组数据的存储结构，算法就说操作数据的一组方法。 数据结构和算法相辅相成。 数据结构为算法服务，算法则需要作用在指定数据结构之上。 复杂度 数据结构与算法解决的问题是如何更快，更省的存储和处理数据，那么我们就需要一个考量资源消耗和效率的方法，就说复杂度分析。 从低阶到高阶的复杂度有：O(1)、O(logn)、O(n)、O(nlogn)、O(n2)。 时间复杂度 概念介绍 表示算法的执行时间与数据规模之间的关系称为时间复杂度 所有代码的执行时间T（n）和每行代码...
Java数据结构初学笔记
培勤
04-12 7696
深入理解数据机构及何时使用它们将对变成工作有极大的帮助。除基本数据类型和字符串外，数组是Java支持的最简单的数据结构。数组是一系列的数据元素，它们都属于某种基本类型和类。数组被视为单个实体，就像基本数据类型变量一样，但包含多个可被独立存取的元素。需要存储和访问相关信息时，数组很有用。数组最大的缺点在于，不能改变其大小以存储更多或更少的元素。这意味着您不能向已满的数组中加入新的元素。由于链表和向量
数据结构与算法分析笔记与总结(java实现)--二叉树笔记
小菜鸟也想飞的博客
02-15 1035
数据结构与算法分析笔记与总结(java实现)--二叉树1：二叉树笔记
算法与数据结构细节复习笔记（Java实现）
书忆江南的IT博客
04-24 1394
本笔记涉及代码：https://github.com/hackeryang/Algorithms-Fourth-Edition-Exercises 1．Java中的length属性是针对数组说的，比如说声明了一个数组，想知道这个数组的长度则用到了length这个属性，例如有个数组int[] a，那么a的长度就是a.length。length()方法是针对字符串String说的，如果想看这个字符串...
算法和数据结构(b站尚硅谷韩老师教程学习笔记)
M1275601161的博客
07-21 3404
教程学习地址： https://www.bilibili.com/video/BV1E4411H73v 一、数据结构和算法的关系 数据data结构(structure)是一门研究组织数据方式的学科，有了编程语言也就有了数据结构.学好数据结构可以编写出更加漂亮,更加有效率的代码。 要学习好数据结构就要多多考虑如何将生活中遇到的问题,用程序去实现解决. 程序 = 数据结构 + 算法 数据结构是算法的基础, 换言之，想要学好算法，需要把数据结构学到位。 总结：数据结构是基石，研究数据方式；算法是是数据处理更
《尚硅谷30天入门Java》学习笔记1
chizi123321的博客
08-18 571
第0天–准备工作 1.工具之印象笔记 浏览器插件、Android、Windows客户端。chrome印象笔记插件可以实现减藏页面，做笔记！ 一个浏览器插件的网站 之前拖插件到拓展程序这里，显示crx_header_invalid程序包无效，可将插件的后缀名改成zip重新试一试。 2.工具之editplus 很好用的一个文本编辑器 3.去申请了ider的学生认证 4.养成记笔记的习惯 5.完善自己的目录 6.学习经验：边听边思考、边做笔记。三分看，七分练，看得懂，练得熟。看了是会忘的，重复记忆！！！ 7.几
（尚硅谷笔记）java基础----面向对象（上）
qq_38938670的博客
04-01 941
面向对象的三条主线： Java类及类的成员：属性、方法、构造器；代码块、内部类 面向对象的三大特征：封装性、继承性、多态性、（抽象性） 其它关键字：this、super、static、final、abstract、interface、package、import 举例代码 如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性（非static），意味着，如果我们修改一个对象的属性a，则不影响另外一个对象的属性a的值。 属性和局部变量的相同点和不同点： 相同点 定
失忆症crowd_完成对象属性的失忆症吗？
cumei1658的博客
07-12 836
失忆症crowd 对Chen＆Wyble的再分析，2015年 (Reanalysis of Chen & Wyble, 2015) Chen and Wyble published an interesting paper (2015) where they demonstrate that participants cannot report attributes of attended...
java数据结构与算法笔记
07-25
Java数据结构与算法笔记是在学习B站尚硅谷Java数据结构与算法视频时所做的记录。\[1\]这个笔记包括了稀疏数组的作用和一个代码实例，以及不同时间复杂度的案例和空间复杂度的概念。\[2\]\[3\]在这个笔记中，你可以学习到如何使用稀疏数组来处理特定的数据结构问题，以及如何分析算法的时间复杂度和空间复杂度。这些知识对于理解和设计高效的算法非常重要。 #### 引用[.reference_title] - *1* *2* *3* [Java数据结构与算法笔记](https://blog.csdn.net/qq_48687532/article/details/119328669)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值