搜索到
48
篇与
的结果
-
![[windows] 懒人操作--powershell命令简写]()
-
![[java] Base64 utils文件]()
[java] Base64 utils文件 在项目启动目录创建 utils -> Base64.java/** * Base64工具类 * */ public final class Base64 { static private final int BASELENGTH = 128; static private final int LOOKUPLENGTH = 64; static private final int TWENTYFOURBITGROUP = 24; static private final int EIGHTBIT = 8; static private final int SIXTEENBIT = 16; static private final int FOURBYTE = 4; static private final int SIGN = -128; static private final char PAD = '='; static final private byte[] base64Alphabet = new byte[BASELENGTH]; static final private char[] lookUpBase64Alphabet = new char[LOOKUPLENGTH]; static { for (int i = 0; i < BASELENGTH; ++i) { base64Alphabet[i] = -1; } for (int i = 'Z'; i >= 'A'; i--) { base64Alphabet[i] = (byte) (i - 'A'); } for (int i = 'z'; i >= 'a'; i--) { base64Alphabet[i] = (byte) (i - 'a' + 26); } for (int i = '9'; i >= '0'; i--) { base64Alphabet[i] = (byte) (i - '0' + 52); } base64Alphabet['+'] = 62; base64Alphabet['/'] = 63; for (int i = 0; i <= 25; i++) { lookUpBase64Alphabet[i] = (char) ('A' + i); } for (int i = 26, j = 0; i <= 51; i++, j++) { lookUpBase64Alphabet[i] = (char) ('a' + j); } for (int i = 52, j = 0; i <= 61; i++, j++) { lookUpBase64Alphabet[i] = (char) ('0' + j); } lookUpBase64Alphabet[62] = (char) '+'; lookUpBase64Alphabet[63] = (char) '/'; } private static boolean isWhiteSpace(char octect) { return (octect == 0x20 || octect == 0xd || octect == 0xa || octect == 0x9); } private static boolean isPad(char octect) { return (octect == PAD); } private static boolean isData(char octect) { return (octect < BASELENGTH && base64Alphabet[octect] != -1); } /** * Encodes hex octects into Base64 * * @param binaryData Array containing binaryData * @return Encoded Base64 array */ public static String encode(byte[] binaryData) { if (binaryData == null) { return null; } int lengthDataBits = binaryData.length * EIGHTBIT; if (lengthDataBits == 0) { return ""; } int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP; int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP; int numberQuartet = fewerThan24bits != 0 ? numberTriplets + 1 : numberTriplets; char encodedData[] = null; encodedData = new char[numberQuartet * 4]; byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0; int encodedIndex = 0; int dataIndex = 0; for (int i = 0; i < numberTriplets; i++) { b1 = binaryData[dataIndex++]; b2 = binaryData[dataIndex++]; b3 = binaryData[dataIndex++]; l = (byte) (b2 & 0x0f); k = (byte) (b1 & 0x03); byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0); byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0); byte val3 = ((b3 & SIGN) == 0) ? (byte) (b3 >> 6) : (byte) ((b3) >> 6 ^ 0xfc); encodedData[encodedIndex++] = lookUpBase64Alphabet[val1]; encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)]; encodedData[encodedIndex++] = lookUpBase64Alphabet[(l << 2) | val3]; encodedData[encodedIndex++] = lookUpBase64Alphabet[b3 & 0x3f]; } // form integral number of 6-bit groups if (fewerThan24bits == EIGHTBIT) { b1 = binaryData[dataIndex]; k = (byte) (b1 & 0x03); byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0); encodedData[encodedIndex++] = lookUpBase64Alphabet[val1]; encodedData[encodedIndex++] = lookUpBase64Alphabet[k << 4]; encodedData[encodedIndex++] = PAD; encodedData[encodedIndex++] = PAD; } else if (fewerThan24bits == SIXTEENBIT) { b1 = binaryData[dataIndex]; b2 = binaryData[dataIndex + 1]; l = (byte) (b2 & 0x0f); k = (byte) (b1 & 0x03); byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0); byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0); encodedData[encodedIndex++] = lookUpBase64Alphabet[val1]; encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)]; encodedData[encodedIndex++] = lookUpBase64Alphabet[l << 2]; encodedData[encodedIndex++] = PAD; } return new String(encodedData); } /** * Decodes Base64 data into octects * * @param encoded string containing Base64 data * @return Array containind decoded data. */ public static byte[] decode(String encoded) { if (encoded == null) { return null; } char[] base64Data = encoded.toCharArray(); // remove white spaces int len = removeWhiteSpace(base64Data); if (len % FOURBYTE != 0) { return null;// should be divisible by four } int numberQuadruple = (len / FOURBYTE); if (numberQuadruple == 0) { return new byte[0]; } byte decodedData[] = null; byte b1 = 0, b2 = 0, b3 = 0, b4 = 0; char d1 = 0, d2 = 0, d3 = 0, d4 = 0; int i = 0; int encodedIndex = 0; int dataIndex = 0; decodedData = new byte[(numberQuadruple) * 3]; for (; i < numberQuadruple - 1; i++) { if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++])) || !isData((d3 = base64Data[dataIndex++])) || !isData((d4 = base64Data[dataIndex++]))) { return null; } // if found "no data" just return null b1 = base64Alphabet[d1]; b2 = base64Alphabet[d2]; b3 = base64Alphabet[d3]; b4 = base64Alphabet[d4]; decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4); decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf)); decodedData[encodedIndex++] = (byte) (b3 << 6 | b4); } if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))) { return null;// if found "no data" just return null } b1 = base64Alphabet[d1]; b2 = base64Alphabet[d2]; d3 = base64Data[dataIndex++]; d4 = base64Data[dataIndex++]; if (!isData((d3)) || !isData((d4))) {// Check if they are PAD characters if (isPad(d3) && isPad(d4)) { if ((b2 & 0xf) != 0)// last 4 bits should be zero { return null; } byte[] tmp = new byte[i * 3 + 1]; System.arraycopy(decodedData, 0, tmp, 0, i * 3); tmp[encodedIndex] = (byte) (b1 << 2 | b2 >> 4); return tmp; } else if (!isPad(d3) && isPad(d4)) { b3 = base64Alphabet[d3]; if ((b3 & 0x3) != 0)// last 2 bits should be zero { return null; } byte[] tmp = new byte[i * 3 + 2]; System.arraycopy(decodedData, 0, tmp, 0, i * 3); tmp[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4); tmp[encodedIndex] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf)); return tmp; } else { return null; } } else { // No PAD e.g 3cQl b3 = base64Alphabet[d3]; b4 = base64Alphabet[d4]; decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4); decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf)); decodedData[encodedIndex++] = (byte) (b3 << 6 | b4); } return decodedData; } /** * remove WhiteSpace from MIME containing encoded Base64 data. * * @param data the byte array of base64 data (with WS) * @return the new length */ private static int removeWhiteSpace(char[] data) { if (data == null) { return 0; } // count characters that's not whitespace int newSize = 0; int len = data.length; for (int i = 0; i < len; i++) { if (!isWhiteSpace(data[i])) { data[newSize++] = data[i]; } } return newSize; } } -
![[spring boot] spring boot 中redis 工具类]()
[spring boot] spring boot 中redis 工具类 在项目启动目录创建 utils -> RedisCache.javaimport java.util.Collection; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; import java.util.concurrent.TimeUnit; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.redis.core.BoundSetOperations; import org.springframework.data.redis.core.HashOperations; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.core.ValueOperations; import org.springframework.stereotype.Component; /** * spring redis 工具类 **/ @SuppressWarnings(value = {"unchecked", "rawtypes"}) @Component public class RedisCache { @Autowired public RedisTemplate redisTemplate; /** * 缓存基本的对象，Integer、String、实体类等 * * @param key 缓存的键值 * @param value 缓存的值 */ public <T> void setCache(final String key, final T value) { redisTemplate.opsForValue().set(key, value); } /** * 缓存基本的对象，Integer、String、实体类等 * * @param key 缓存的键值 * @param value 缓存的值 * @param timeout 时间 * @param timeUnit 时间颗粒度 */ public <T> void setCache(final String key, final T value, final Integer timeout, final TimeUnit timeUnit) { redisTemplate.opsForValue().set(key, value, timeout, timeUnit); } /** * 设置有效时间 * * @param key Redis键 * @param timeout 超时时间 * @return true=设置成功；false=设置失败 */ public boolean expire(final String key, final long timeout) { return expire(key, timeout, TimeUnit.SECONDS); } /** * 设置有效时间 * * @param key Redis键 * @param timeout 超时时间 * @param unit 时间单位 * @return true=设置成功；false=设置失败 */ public boolean expire(final String key, final long timeout, final TimeUnit unit) { return redisTemplate.expire(key, timeout, unit); } /** * 获取有效时间 * * @param key Redis键 * @return 有效时间 */ public long getExpire(final String key) { return redisTemplate.getExpire(key); } /** * 判断 key是否存在 * * @param key 键 * @return true 存在 false不存在 */ public Boolean hasKey(String key) { return redisTemplate.hasKey(key); } /** * 获得缓存的基本对象。 * * @param key 缓存键值 * @return 缓存键值对应的数据 */ public <T> T getCache(final String key) { ValueOperations<String, T> operation = redisTemplate.opsForValue(); return operation.get(key); } /** * 删除单个对象 * * @param key */ public boolean delete(final String key) { return redisTemplate.delete(key); } /** * 删除集合对象 * * @param collection 多个对象 * @return */ public boolean delete(final Collection collection) { return redisTemplate.delete(collection) > 0; } /** * 缓存List数据 * * @param key 缓存的键值 * @param dataList 待缓存的List数据 * @return 缓存的对象 */ public <T> long setCacheList(final String key, final List<T> dataList) { Long count = redisTemplate.opsForList().rightPushAll(key, dataList); return count == null ? 0 : count; } /** * 获得缓存的list对象 * * @param key 缓存的键值 * @return 缓存键值对应的数据 */ public <T> List<T> getCacheList(final String key) { return redisTemplate.opsForList().range(key, 0, -1); } /** * 缓存Set * * @param key 缓存键值 * @param dataSet 缓存的数据 * @return 缓存数据的对象 */ public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet) { BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key); Iterator<T> it = dataSet.iterator(); while (it.hasNext()) { setOperation.add(it.next()); } return setOperation; } /** * 获得缓存的set * * @param key * @return */ public <T> Set<T> getCacheSet(final String key) { return redisTemplate.opsForSet().members(key); } /** * 缓存Map * * @param key * @param dataMap */ public <T> void setCacheMap(final String key, final Map<String, T> dataMap) { if (dataMap != null) { redisTemplate.opsForHash().putAll(key, dataMap); } } /** * 获得缓存的Map * * @param key * @return */ public <T> Map<String, T> getCacheMap(final String key) { return redisTemplate.opsForHash().entries(key); } /** * 往Hash中存入数据 * * @param key Redis键 * @param hKey Hash键 * @param value 值 */ public <T> void setCacheMapValue(final String key, final String hKey, final T value) { redisTemplate.opsForHash().put(key, hKey, value); } /** * 获取Hash中的数据 * * @param key Redis键 * @param hKey Hash键 * @return Hash中的对象 */ public <T> T getCacheMapValue(final String key, final String hKey) { HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash(); return opsForHash.get(key, hKey); } /** * 获取多个Hash中的数据 * * @param key Redis键 * @param hKeys Hash键集合 * @return Hash对象集合 */ public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys) { return redisTemplate.opsForHash().multiGet(key, hKeys); } /** * 删除Hash中的某条数据 * * @param key Redis键 * @param hKey Hash键 * @return 是否成功 */ public boolean deleteCacheMapValue(final String key, final String hKey) { return redisTemplate.opsForHash().delete(key, hKey) > 0; } /** * 获得缓存的基本对象列表 * * @param pattern 字符串前缀 * @return 对象列表 */ public Collection<String> keys(final String pattern) { return redisTemplate.keys(pattern); } } -
![[小程序] uniApp 使用本地缓存]()
[小程序] uniApp 使用本地缓存 在util 创建一个storage 目录 并在该目录下创建 storage.js/** * 判断字符串是否是json字符串 * @param {string} str */ const isJsonString = str => { try { const toObj = JSON.parse(str); if (toObj && typeof toObj === 'object') { return true } } catch {} return false } /** * 设置缓存 * @param {string} name * @param {string | Array } value */ export function set(name, value) { if (value && typeof value == 'object') { //设置json缓存数据 uni.setStorageSync(name, JSON.stringify(value)); } else { //设置缓存数据 uni.setStorageSync(name, value); } } /** * 获取缓存 * @param {string} name */ export function get(name) { //获取缓存数据 var data = uni.getStorageSync(name); if (data) { if (isJsonString(data)) { //json字符串转对象 return JSON.parse(data); } return data; } return null; } /** * 移除缓存 * @param {string} name */ export function remove(name) { // 清除某项缓存 uni.removeStorageSync(name); } /** * 清空缓存 */ export function clear() { // 清空缓存 uni.clearStorageSync(); } module.exports = { set, get, remove, clear } -
![[其他] 实习文件]()
-
![[Java] mybatis-plus 联表查询]()
[Java] mybatis-plus 联表查询 前言作为mybatis的增强工具，mybatis-plus的出现极大的简化了开发中的数据库操作，但是长久以来，它的联表查询能力一直被大家所诟病。一旦遇到left join或right join的左右连接，手写上一大段的sql语句。mybatis-plus-join 介绍MyBatis-Plus-Join （简称 MPJ）是一个 MyBatis-Plus 的增强工具，在 MyBatis-Plus 的基础上只做增强不做改变，为简化开发、提高效率而生。特性无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑无感引入, 支持MP风格的查询, 您会MP就会MPJ, 无需额外的学习成本兼容MP的别名、逻辑删除、枚举列、TypeHandle列等特性支持注解形式一对一、一对多和连表查询形式的一对一和一对多代码托管github.com | gitee.com使用官方文档 -
![[TypeScript] TS01]()
[TypeScript] TS01 TypeScriptTypeScript 与JavaScript的区别TypeScript （TS）是JavaScript（JS） 的一个超集（即：JavaScript所拥有的TypeScript同样拥有），TypeScript 在 JavaScript基础上进行了类型的支持，使开发更高效TypeScript是静态类型的编程语言，JavaScript是动态类型编程语言静态类型：在编译期进行类型检查动态类型：在执行期进行类型检查编译和执行的顺序：先编译再运行因此typeScript相对于JavaScript更早发现代码的问题安装TypeScript由于node.js/浏览器仅认识js，需要将TS转译成JS代码，使代码能执行npm install -g typescript # 检查是否安装成功 由于typescript提供tsc命令 tsc -v==问题==由于控制台认为tsc命令不是个安全的命令，需要执行一管理员身份运行修改：以管理员身份运行 PowerShell输入 set-ExecutionPolicy RemoteSigned输入是或者Y 即可创建目录（自己命名）==尽量用英文命名==在目录下面创建hello.ts并写入console.log("hello TypeScript")编译 tsc hello.ts在同级目录下会自动生成一个hello.js 的文件运行 node hello.js将会运行 hello.js 的代码简化运行ts 命令由于执行 ts代码需要先执行 tsc 再执行node 分为两步，为了方便将这两步合并安装 ts-node 包npm install -g ts-node运行时ts-node hello.ts==注意==：在内部将ts转化为js代码， 但没有生成js文件，直接运行了这个转化的js代码，并不是单纯的将两步合并起来TypeScript常用类型TS类型提示JS中有类型number/string 但在并不会检查是否发生变化，因此会导致问题的出现，而且编译器不会进行提示TS会进行代码错误提示TS类型注解// let 变量名:变量类型 = 变量值 let age: number = 20TS基础类型JS中有的 原始类型number/string/boolean/null/undefined/symbol对象类型Object(数组，对象，函数)TS中增加联合类型，自定义类型（类型别名），接口，元组，字面量类型，枚举，void，any等// 简单类型 let age: number = 20; let name: string = "张三"; let sex: boolean = true; //... // 复杂 let family: string[] = ["爸爸", "妈妈"] // 定义一个字符串类型的数组 let family: Array(string) = ["爸爸", "妈妈"] // 定义一个字符串类型的数组 // 联合类型 let data: (number | string)[] = [12, "李四", "王五"]//定义一个字符串或者是数值类型的数组 // 注意：| 的优先级没有[] 高，因此(number | string)[] 和 number | string[]是两种结果 // 类型别名 ~type 名称 = 类型~ type NumberOrString = number | string let data: NumberOrString = 12 let data2: NumberOrString = "12" // 函数类型 function add(num1: number, num2: number): number{ return num1 + num2; } // 表达式类型 const add = (num1: number, num2: number): number => { return num1 + num2; } // void 类型表示该函数没有返回值 // 可选参数，注意：可选参数只能出现在必选参数的后面 function slice(str: string, start:number, end?:number): string {} // 接口：interface 接口名{} interface Person { name :string age: number } let P:Person = {name:"张三", age:18}type 和 interface 的区别type是个类型赋值，因此在定义时需要用 = 进行赋值，可以对任意类型进行别名interface 是个类 不需要用=，只能对对象使用，其他类型不能使用，接口中可以使用继承接口继承interface Point2D {x: number,y: number}; interface Point3D extends Point2D {z: number}元组由于数组的不定长的原因，在某些场景下虽然数组能满足要求，但不适用，例如定位经纬度等，因此需要有定长的数组来实现。元组：一种特殊的数组，知道数组中的元素个数，以及特定索引对应的类型let Position: [number, number] = [39, 144] // 元组中只能出现两元素，并且两个都是number类型TS中类型推论能推导出当前变量或对象的类型或者拥有的属性，即可省略类型注解在变量值初始化时在函数返回值时类型检查机制依旧存在TS类型断言在操作DOM时获取标签，但默认是获取的对象所有用的类型均为HTMLElement 所包含的属性为所有标签的公共属性，某些特殊的属性针对特殊标签并没有，因此使用断言获取指定类型的标签，例如：<a href="http://ilstudy.vip" id=“BlogUrl”>星如雨博客</a>let BlogUrl = document.getElementById("BlogUrl");// 获取的类型是HTMLElement // 使用 BlogUrl.href 的时候会报错 // 使用断言 let BlogUrl = document.getElementById("BlogUrl") as HTMLAnchorElement; // 再次使用 BlogUrl.href正常 //另一种写法， 不建议这种写法 会和 react 语法冲突 let BlogUrl = <HTMLAnchorElement>document.getElementById("BlogUrl");控制台查看指定元素的类型$0, 使用 console.dir($0) 手动查看当前元素具体类型，在列表的最后字面量类型变量使用const关键字let str1 = "123" // 类型为string const str2 = "123" // 类型为"123" // const 是将值直接作为了类型，const声明的为常量，值不能发生改变 // 使用场景，一般与联合类型使用，确定某些值，中进行选择枚举类型是字面量类型和联合类型共同的结果，枚举类型=字面量类型+联合累心enum Direction{Up,Down,Left,Right}; let dir: "Up" | "Down" | "Left" | "Right"; // 访问枚举成员 Direction.Up; //... //枚举成员的值 默认是从0开始1，2，3，....自增的关系 enum Direction{Up = 10,Down,Left,Right};//从10开始11，12，13，....自增的关系 //字符串类型的枚举 enum Direction{Up= "Up",Down = "Down",Left = "Left",Right = "Right"};//字符串类型没有默认自增长any类型any类型取消所有的变量类型判断，变成为任意类型，代码也不会给予相应的提示，失去TS的代码类型检查功能，容易出现错误。对于刚命名的 变量没有给类型，并且没有初始值时，此时的类型为any类型typeof获取变量的类型代码上下文使用，类似于别名变量类型：利用类型推论，自动识别变量类型TS中Class关键字class Person{ // 属性或方法 } let p = new Person()class 构造函数class Person{ // 构造函数没有返回值 constructor(/*变量*/){ // this.变量名 ；访问该类中的属性和方法 } }class 继承extends js中代码继承父类，公共属性使用继承，父级是 class类型属性与方法的继承，重写implements 实现接口 TS中特有，父级是interface类型属性与方法的继承、实现class 修饰符修饰符等级public公共的（所有位置均可访问），默认修饰符protected受保护的（类内和子类中可用，实例对象无法使用）private私有的（当前类中可见，实例化对象和子类中不能使用）readonly 关键字只能在构造函数中修改被readonly修饰的属性，其他地方无法修改被readonly修饰的属性的属性值，被readonly修饰的属性可以有默认属性值readonly只能修饰属性，不能修饰方法TS类型兼容性两种类型系统结构化类型系统（Structural Type System）标明类型系统（Nominal Type System）TS中采用的是结构化类型系统：类型检查关注的是值所具有的属性，即是两个对象所具有的相同的属性以及属性类型，则认为他们是相同类型的，对于对象来讲y对象所具有的属性，包含x所具有的属性，在x中都有，则说明x兼容y（属性多的可以赋值给属性少的）class point{x:nuumber,y:number} class point2D{x:nuumber,y:number} class point3D{x:nuumber,y:number，z:number} // pint类与point2D类只有类名不同，但具有相同的属性，则认为point和point2D是相同的属性以及属性类型是否相同 let p1:point = new point2D(); let p2:point = new point3D(); //向上兼容接口兼容性interface和class 相似，并且可以相互兼容函数兼容性函数：参数个数，参数类型，函数返回值参数个数兼容：参数少的可以赋值给参数多的参数类型兼容：相同位置的参数进行兼容，原始类型或对象类型（对象为参数兼容）返回值兼容：返回值类型相同的相互兼容，返回值为对象的参照对象属性个数兼容 -
![[数据结构] 特殊线性表：广义表]()
[数据结构] 特殊线性表：广义表 广义表广义表又称列表(List)，是 n≥0 个元素 (a1,a2,a3,...,an) 的优先序列，其中ai是原子数据类型或者是一个广义表，记LS=(a1,a2,a3,...,an)LS : 表示表名ai : 表示元素，通常小写字母表示元素是原子数据类型，大写字母表示元素是广义表广义表表头广义表的第一个元素(a1),可以是一个原子类型也可以是一个广义表广义表表尾广义表中除了第一个元素之外的其他元素组成的广义表 --> 表尾是一个表广义表可以使用 "()" 表示，其中()的最深层数表示表的深度，表的次序 ：一个直接前驱，一个直接后继例如LS = (a1) : LS中有一个元素 表头为 a1，表尾为 ()LS = (a1, a2) ：LS中有两个元素 表头为 a1，表尾为 (a2)LS = (a1, ()) ：LS中有两个元素 表头为 a1，表尾为 (())LS = (a1, a2,()) ：LS中有三个元素 表头为 a1，表尾为 (a2,())表的共享两个广义表 A，B, 其中A和 B 的关系 B = (A)表的递归有一个广义表 A，其中 A = (A) -
![[数据结构] 线性表之链式存储：单链表]()
[数据结构] 线性表之链式存储：单链表 定义线性表的链式存储又称单链表，它是只通过一组任意的存储单元来存储线性表的数据元素。为建立数据元素之间的线性关系，每个链表节点除了存放元素自身的信息外，还需要存放指向其后继的指针。typedef struct Node{ ElementType data; // 数据域，存放数据 struct Node *next; // 指针域，存放其后继节点的地址 }LNode;头指针和头结点的区别不管带不带头节点，头指针始终指向链表的第一个节点，而头结点是带头结点的链表中的第一个节点，节点数据域通常不存储信息。头结点的有点：由于第一个数据节点的位置被存放在头结点的指针域中，云次在链表的第一个位置上的操作和在表的其他位置操作一致，无需进行特殊处理。无论链表是否为空，其头指针都指向头结点的非空指针(空表中头结点的指针域为空)，因此空表和非空表的处理也得到了统一。链表基本操作InitLinkList(&L); // 初始化链表 BeforeHeader(&L, data); // 头插法 AfterHeader(&L, data); // 尾插法 BeforeInsert(p, data); // p 节点之前插入 AfterInsert(p, data); // p 节点之后插入 BeforeDelete(p, &data); // 删除 p 节点之前节点 AfterDelete(p, &data); // 删除 p 节点之后节点 ...特殊链表双链表循环链表循环双链表静态链表
![[windows] 懒人操作--powershell命令简写](https://fastly.jsdelivr.net/npm/typecho-joe-next@6.0.0/assets/thumb/42.jpg)
![[java] Base64 utils文件](https://fastly.jsdelivr.net/npm/typecho-joe-next@6.0.0/assets/thumb/14.jpg)
![[spring boot] spring boot 中redis 工具类](https://fastly.jsdelivr.net/npm/typecho-joe-next@6.0.0/assets/thumb/29.jpg)
![[小程序] uniApp 使用本地缓存](https://fastly.jsdelivr.net/npm/typecho-joe-next@6.0.0/assets/thumb/26.jpg)
![[其他] 实习文件](https://fastly.jsdelivr.net/npm/typecho-joe-next@6.0.0/assets/thumb/9.jpg)
![[Java] mybatis-plus 联表查询](https://fastly.jsdelivr.net/npm/typecho-joe-next@6.0.0/assets/thumb/7.jpg)
![[TypeScript] TS01](http://ilstudy.vip/usr/uploads/2022/12/987153907.png)
![[数据结构] 特殊线性表：广义表](https://fastly.jsdelivr.net/npm/typecho-joe-next@6.0.0/assets/thumb/12.jpg)
![[数据结构] 线性表之链式存储：单链表](https://fastly.jsdelivr.net/npm/typecho-joe-next@6.0.0/assets/thumb/31.jpg)