<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[a647777的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/a647777</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; a647777]]></copyright><item><title><![CDATA[大模型量化--PrefixQuant]]></title><link>https://blog.youkuaiyun.com/a647777/article/details/145559490</link><guid>https://blog.youkuaiyun.com/a647777/article/details/145559490</guid><author>a647777</author><pubDate>Thu, 20 Feb 2025 22:22:57 +0800</pubDate><description><![CDATA[本文作者来自香港大学、上海AI Lab、同济大学。模型量化（Quantization），可以降低模型显存占用，提升推理速度，是大模型部署的关键技术。现有的量化方案，大多采用per token的动态量化范式，这样可以忽略激活值的token-wise outliers，而重点处理权重的channel-wise outliers。动态量化和静态量化- 动态量化和静态量化，是针对模型激活值（activation） 量化的两种范式。]]></description><category></category></item><item><title><![CDATA[大模型量化--BiLLM]]></title><link>https://blog.youkuaiyun.com/a647777/article/details/145482781</link><guid>https://blog.youkuaiyun.com/a647777/article/details/145482781</guid><author>a647777</author><pubDate>Sun, 09 Feb 2025 15:56:28 +0800</pubDate><description><![CDATA[BiLLM，一种PTQ大模型二值化量化方法]]></description><category></category></item><item><title><![CDATA[菜鸡的leetcode刷题笔记-数组中的重复数字]]></title><link>https://blog.youkuaiyun.com/a647777/article/details/120979677</link><guid>https://blog.youkuaiyun.com/a647777/article/details/120979677</guid><author>a647777</author><pubDate>Tue, 26 Oct 2021 20:45:32 +0800</pubDate><description><![CDATA[前言
leetcode上，剑指offer，：
题目地址
解题思路
本题比较简单
1.哈希表
遍历数组，每个元素放入哈希表中，若该数字已经在哈希表中存在了，那么就返回该数字
class Solution {
    public int findRepeatNumber(int[] nums) {
        Set&lt;Integer&gt; dic = new HashSet&lt;&gt;();
        for(int num : nums){
            if(dic.con]]></description><category></category></item><item><title><![CDATA[菜鸡的leetcode刷题笔记-左旋转字符串]]></title><link>https://blog.youkuaiyun.com/a647777/article/details/120959489</link><guid>https://blog.youkuaiyun.com/a647777/article/details/120959489</guid><author>a647777</author><pubDate>Mon, 25 Oct 2021 20:49:22 +0800</pubDate><description><![CDATA[前言
leetcode上，剑指offer，左旋转字符串：
题目地址
解题思路
本题比较简单
1.字符串拆分拼接
把字符串拆分，拆分位置为需要旋转的字符的个数，然后再拼接起来便可
JAVA里面对字符串拆分可以使用substring数组
代码如下：
class Solution {
    public String reverseLeftWords(String s, int n) {
        String res = new String();
        res = s.substring(n]]></description><category></category></item><item><title><![CDATA[菜鸡的leetcode刷题笔记-替换字符串中的空格]]></title><link>https://blog.youkuaiyun.com/a647777/article/details/120832377</link><guid>https://blog.youkuaiyun.com/a647777/article/details/120832377</guid><author>a647777</author><pubDate>Mon, 18 Oct 2021 19:57:20 +0800</pubDate><description><![CDATA[前言
leetcode上，剑指offer，复杂链表的复制：
题目地址
解题思路
对于一个普通链表的复制，我们可以从头到尾，遍历节点，复制这个链表，但是对于这个复杂链表，由于一个节点会有random指针指向一个不确定的节点，而这个节点按照顺序可能还没有被创建，因此不能通过这种方式复制。
1.回溯+哈希表
具体思路是，使用一个哈希表，记录每一个原始链表节点对应的复制出来的新链表节点的创建情况，如果已经创建了，就放到这个哈希表中，如果没有被创建，哈希表中就没有。
然后我们开始遍历原始链表，从头节点开始，检查这个原]]></description><category></category></item><item><title><![CDATA[菜鸡的leetcode刷题笔记-反转链表]]></title><link>https://blog.youkuaiyun.com/a647777/article/details/120817039</link><guid>https://blog.youkuaiyun.com/a647777/article/details/120817039</guid><author>a647777</author><pubDate>Sun, 17 Oct 2021 22:22:22 +0800</pubDate><description><![CDATA[前言
leetcode上，剑指offer，反转链表：
题目地址
解题思路
1.迭代
其实很简单，我只需要遍历链表的节点，然后把当前节点next指针指向的节点，替换成上一个节点便可，因此需要单独保存以下上一个节点，同时，也需要保存一下下一个节点，因为原来的链表的顺序不能乱。
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListN]]></description><category></category></item><item><title><![CDATA[菜鸡的leetcode刷题笔记-从尾到头打印链表]]></title><link>https://blog.youkuaiyun.com/a647777/article/details/120751705</link><guid>https://blog.youkuaiyun.com/a647777/article/details/120751705</guid><author>a647777</author><pubDate>Wed, 13 Oct 2021 21:25:36 +0800</pubDate><description><![CDATA[前言
leetcode上，剑指offer，从尾到头打印链表：
题目地址
基本知识
什么是链表：
链表是一种数据结构，里面存放了一系列数据，类似于数组。不同之处在于，数组中的数据在内存中的存储空间是连续的，因此可以直接通过元素的索引取出元素。但链表中的数据在内存中的存储空间不是连续的，链表的每一个数据节点包含数据、指向下一个节点的指针两部分，因此链表获取某个特定节点，只能从头一个一个往下找。

链表的优点在于，不需要连续的存储单元，修改节点的复杂度较低，数据在修改节点时，需要把其余所有的元素移动位置，复杂度较]]></description><category></category></item><item><title><![CDATA[菜鸡的LeetCode刷题笔记-包含min函数的栈]]></title><link>https://blog.youkuaiyun.com/a647777/article/details/120731921</link><guid>https://blog.youkuaiyun.com/a647777/article/details/120731921</guid><author>a647777</author><pubDate>Tue, 12 Oct 2021 21:18:33 +0800</pubDate><description><![CDATA[前言
leetcode上，剑指offer，包含min函数的栈：
题目地址
解题思路
对于栈来说，pop、push、peek的时间复杂度都是O(1)，但是如果要找最小值的话，时间复杂度就是O(n)，因为需要遍历栈中的元素，那么如何降低时间复杂度呢？就用空间换时间，构造一个辅助栈，维护这个栈，使得栈顶的元素始终为原始栈中的最小元素便可。
class MinStack {

    Stack&lt;Integer&gt; stack1,stack2;
    /** initialize your data s]]></description><category></category></item><item><title><![CDATA[菜鸡的LeetCode刷题笔记-两个栈实现队列]]></title><link>https://blog.youkuaiyun.com/a647777/article/details/120712914</link><guid>https://blog.youkuaiyun.com/a647777/article/details/120712914</guid><author>a647777</author><pubDate>Tue, 12 Oct 2021 20:46:48 +0800</pubDate><description><![CDATA[文章目录前言1.基础知识1.1 数据结构：栈1.1 数据结构：队列2.解题思路2.1 解题思路2.1.1 一个栈实现插入，一个栈实现删除
前言
leetcode上，剑指offer，用两个栈实现队列：
题目地址
1.基础知识
1.1 数据结构：栈
栈是一种数据结构，简单来说，数据像大饼一样被叠放在一起，数据只能放在栈的最上方，在取出数据的时候，只能从最上方取。栈中，添加数据的时候，就叫做入栈，取出数据的时候就叫做出栈，如下图所示：

1.1 数据结构：队列
队列与栈类似，也是一种数据结构，一种特殊的线性表，和]]></description><category></category></item><item><title><![CDATA[JAVA中的枚举类]]></title><link>https://blog.youkuaiyun.com/a647777/article/details/109291397</link><guid>https://blog.youkuaiyun.com/a647777/article/details/109291397</guid><author>a647777</author><pubDate>Wed, 28 Oct 2020 10:05:17 +0800</pubDate><description><![CDATA[文章目录什么是枚举类枚举类的成员变量、方法和构造器枚举类实现接口包含抽象方法的枚举类
什么是枚举类
某些情况下，一个类的对象是有限的、固定的，比如一周有7天、一年有12个月等。这种情况下，就需要使用枚举类。JAVA中借助enum关键字构建枚举类，enum关键字和class、interface关键字地位相同，所以一个JAVA源文件中最多只能定义一个public修饰的枚举类，并且Java源文件必须和该枚举类类名相同。例如：
public enum seasonEnum {
	SPRING,SUMMER,FALL]]></description><category></category></item><item><title><![CDATA[JAVA中的Lambda表达式]]></title><link>https://blog.youkuaiyun.com/a647777/article/details/109238636</link><guid>https://blog.youkuaiyun.com/a647777/article/details/109238636</guid><author>a647777</author><pubDate>Mon, 26 Oct 2020 13:37:47 +0800</pubDate><description><![CDATA[文章目录Lambda表达式简介Lambda表达式与函数式接口二级目录三级目录
Lambda表达式简介
Lambda表达式用于将代码块作为参数传入方法中，有的时候，在你创建某个方法的时候，你并不知道方法应该对参数进行怎样的操作，只有到了使用的时候，才能真正确定。这种情境下，就可以借助接口来实现，具体可以使用接口的实现类、匿名内部类和Lambda表达式来实现：
//Command接口用以封装方法的”处理行为“
interface Command{
//	process代表了处理行为，具体处理行为是怎样的，现在无]]></description><category></category></item><item><title><![CDATA[JAVA中的内部类]]></title><link>https://blog.youkuaiyun.com/a647777/article/details/109180556</link><guid>https://blog.youkuaiyun.com/a647777/article/details/109180556</guid><author>a647777</author><pubDate>Fri, 23 Oct 2020 10:50:35 +0800</pubDate><description><![CDATA[文章目录前言什么是JAVA中的内部类非静态内部类静态内部类
前言
李刚老师《JAVA疯狂讲义》第5版，第6章学习笔记。
什么是JAVA中的内部类
大多数情况下，类会被定义为一个单独的程序单元，但是有些时候，也会把一个类放在另一个类的内部定义。定义在一个类内部的类就是内部类。
由于内部类定义在一个类的内部，因此除了public，还可以使用private、protected和static三个访问修饰符修饰（外部类不可使用这三个访问修饰符修饰）。
为什么会这样呢？
外部类的上一级程序结构是包，所以外部类只有两种作]]></description><category></category></item><item><title><![CDATA[JAVA中的接口]]></title><link>https://blog.youkuaiyun.com/a647777/article/details/108954743</link><guid>https://blog.youkuaiyun.com/a647777/article/details/108954743</guid><author>a647777</author><pubDate>Mon, 19 Oct 2020 21:47:13 +0800</pubDate><description><![CDATA[文章目录前言什么是接口二级目录三级目录
前言
李刚老师《JAVA疯狂讲义》第5版，第6章学习笔记。
什么是接口
二级目录
三级目录

]]></description><category></category></item><item><title><![CDATA[JAVA中的抽象类]]></title><link>https://blog.youkuaiyun.com/a647777/article/details/108917132</link><guid>https://blog.youkuaiyun.com/a647777/article/details/108917132</guid><author>a647777</author><pubDate>Wed, 07 Oct 2020 19:57:25 +0800</pubDate><description><![CDATA[文章目录前言什么是抽象类与抽象方法如何定义抽象类和抽象方法
前言
李刚老师《JAVA疯狂讲义》第5版，第6章学习笔记。
什么是抽象类与抽象方法
编写一个类时，常常会定义一些方法，方法用以描述类的行为，为此，这些方法应该具有方法体。但是，某些情况下，父类只是知道子类中应该包含怎样的方法，但是无法准确知道子类应该如何准确实现这一方法，那么，这些没有方法体的方法，就是抽象方法，而包含这些抽象方法的类，就是抽象类。
抽象类是从多个具有相同特征的类中抽象出来的，这个类作为子类的模板，可以保证子类设计的统一性。
例如，]]></description><category></category></item><item><title><![CDATA[JAVA-缓存实例的不可变类]]></title><link>https://blog.youkuaiyun.com/a647777/article/details/108879300</link><guid>https://blog.youkuaiyun.com/a647777/article/details/108879300</guid><author>a647777</author><pubDate>Sun, 04 Oct 2020 10:40:28 +0800</pubDate><description><![CDATA[前言：
李刚老师《JAVA疯狂讲义》第5版，第6章学习笔记。
不可变类的实例状态不可变，可以方便的被多个对象共享。若程序经常使用相同的不可变类实例，则应考虑缓存改实例，从而避免反复创建该对象，降低系统开销。
实现缓存的方式有多种，以下举例借助数组实现缓存：



...]]></description><category></category></item><item><title><![CDATA[JAVA中的final修饰符]]></title><link>https://blog.youkuaiyun.com/a647777/article/details/108822516</link><guid>https://blog.youkuaiyun.com/a647777/article/details/108822516</guid><author>a647777</author><pubDate>Sun, 27 Sep 2020 21:04:45 +0800</pubDate><description><![CDATA[文章目录前言1.final修饰变量1.1 final修饰成员变量1.2 final修饰局部变量1.1 final修饰基本类型和引用类型变量2.final修饰方法3.final修饰类
前言
李刚老师《JAVA疯狂讲义》第5版，第5章学习笔记。
JAVA中的final修饰符可以用来修饰变量、方法和类，用于表示被修饰的变量、方法和类不可变。
1.final修饰变量
final变量获得初始值后，就无法被重新赋值，当其修饰成员变量和实例变量时，有所不同。修饰基本类型变量和引用类型变量时也有所不同
1.1 final修]]></description><category></category></item><item><title><![CDATA[JAVA中的初始化块]]></title><link>https://blog.youkuaiyun.com/a647777/article/details/108789049</link><guid>https://blog.youkuaiyun.com/a647777/article/details/108789049</guid><author>a647777</author><pubDate>Fri, 25 Sep 2020 09:58:54 +0800</pubDate><description><![CDATA[文章目录前言1.什么是初始化块2.初始化块与构造器3.静态初始化块4.初始化块执行顺序
前言
李刚老师《JAVA疯狂讲义》第5版，第5章学习笔记。
1.什么是初始化块
初始化块是类的第4种成员(成员变量、方法、构造器)，与构造器作用有些类似，用于对JAVA对象进行初始化操作。例如：
public class Animal {
	//定义初始化块
	{
		int a = 6;
		if(a&gt;4) {
			System.out.println("Animal初始化块，局部变量a的值大于4");
		}]]></description><category></category></item><item><title><![CDATA[JAVA中的继承和组合]]></title><link>https://blog.youkuaiyun.com/a647777/article/details/108777472</link><guid>https://blog.youkuaiyun.com/a647777/article/details/108777472</guid><author>a647777</author><pubDate>Thu, 24 Sep 2020 18:04:37 +0800</pubDate><description><![CDATA[文章目录前言1.JAVA中继承的局限性2.JAVA中组合的实现
前言
李刚老师《JAVA疯狂讲义》第5版，第5章学习笔记。
1.JAVA中继承的局限性
2.JAVA中组合的实现

]]></description><category></category></item><item><title><![CDATA[JAVA中多态的简单理解]]></title><link>https://blog.youkuaiyun.com/a647777/article/details/108775536</link><guid>https://blog.youkuaiyun.com/a647777/article/details/108775536</guid><author>a647777</author><pubDate>Thu, 24 Sep 2020 16:08:11 +0800</pubDate><description><![CDATA[文章目录前言JAVA中的多态
前言
李刚老师《JAVA疯狂讲义》第5版，第5章学习笔记。
JAVA中的多态
JAVA中的多态指的是，相同的变量，调用相同的方法，结果却不一样。具体如下：
//定义一个Person类
public class Person{
	//Person类的成员变量
	int age = 10;
	//Person类的方法
	public void eat() {
		System.out.println("我是人的吃饭方法");
	}
}
//定义一个Person类的子类，Police]]></description><category></category></item><item><title><![CDATA[JAVA中类的继承]]></title><link>https://blog.youkuaiyun.com/a647777/article/details/108752691</link><guid>https://blog.youkuaiyun.com/a647777/article/details/108752691</guid><author>a647777</author><pubDate>Wed, 23 Sep 2020 17:04:25 +0800</pubDate><description><![CDATA[文章目录前言1.什么是继承2.父类方法的重写3.super关键字4.父类的构造器
前言
李刚老师《JAVA疯狂讲义》第5版，第5章学习笔记。
1.什么是继承
继承是面向对象编程的三大特征之一，是实现代码复用的重要手段。
编程时，相同的一段代码最好只写一次。试想，比如有两个类，一个NBA球员类，一个湖人球员类（湖人总冠军！！！），NBA球员类里面定义了一个成员变量，叫球员底薪。我湖人球员类也不搞继承这一套，自己也定义一个成员变量，球员底薪。要是有一天，NBA的规则变了，球员底薪变了，那么，由于不存在继承关系，]]></description><category></category></item></channel></rss>