<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[LuKeYY825的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/LuKeYY825</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; LuKeYY825]]></copyright><item><title><![CDATA[C++多态]]></title><link>https://blog.youkuaiyun.com/LuKeYY825/article/details/108811223</link><guid>https://blog.youkuaiyun.com/LuKeYY825/article/details/108811223</guid><author>LuKeYY825</author><pubDate>Sat, 26 Sep 2020 15:14:02 +0800</pubDate><description><![CDATA[多态
我们知道继承是代码复用的一种体现，而多态是接口复用的一种体现，即：同一接口不同形态。

静多态（函数重载/模板）
编译阶段确定函数的调用
动多态（虚函数）
运行阶段确定函数的调用
宏多态（不常用）
预编译阶段确定函数的调用


动多态：由虚函数机制提供支持

虚函数处理机制：
①编译阶段：将函数入口地址写入在只读数据段（.rodata段），具体存放在虚函数表（vftale）中。
②链接完成后：函数入口地址存放在只读数据段
③运行阶段：将指令和数据（虚函数入口地址）加载到内存中


虚函数表（vftab]]></description><category></category></item><item><title><![CDATA[寻找树中两个结点的最低公共祖先]]></title><link>https://blog.youkuaiyun.com/LuKeYY825/article/details/108564617</link><guid>https://blog.youkuaiyun.com/LuKeYY825/article/details/108564617</guid><author>LuKeYY825</author><pubDate>Sat, 19 Sep 2020 13:46:28 +0800</pubDate><description><![CDATA[寻找树中两个结点的最低公共祖先
Q:在树中寻找两个结点的最低公共祖先，是什么意思呢？
A:树是由根节点衍生左右孩子继续衍生左右孩子的左右孩子。所以呢树中的两个结点是一定拥有最低公共祖先（这两个结点Q:是在这个祖先结点衍生的孩子中）至于最低：就是第一个公共祖先。



树是二叉树并且是BST树嘛？
我们根据BST树（二叉搜索树/二叉排序树）的特性：树中任意结点的val大于左孩子的val。
如果该结点是这两个结点的最低公共祖先
那么他的val一定是大于等于其中一个结点的val，并且小于另外一个结点的val
或者]]></description><category></category></item><item><title><![CDATA[关于快排的优化]]></title><link>https://blog.youkuaiyun.com/LuKeYY825/article/details/108075056</link><guid>https://blog.youkuaiyun.com/LuKeYY825/article/details/108075056</guid><author>LuKeYY825</author><pubDate>Tue, 18 Aug 2020 13:27:39 +0800</pubDate><description><![CDATA[快排优化博客链接：https://blog.youkuaiyun.com/qq_38289815/article/details/82718428

]]></description><category></category></item><item><title><![CDATA[关于快速排序的一些分析]]></title><link>https://blog.youkuaiyun.com/LuKeYY825/article/details/108072119</link><guid>https://blog.youkuaiyun.com/LuKeYY825/article/details/108072119</guid><author>LuKeYY825</author><pubDate>Tue, 18 Aug 2020 13:25:46 +0800</pubDate><description><![CDATA[快速排序
快速排序：由冒泡排序而改进而来。
快速排序由C. A. R. Hoare在1960年提出。
它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

上面是一些官方的分析。简单的来讲，快排就是选择一个基准，然后利用头尾指针寻找比基准大，比基准小的数据，进行交换，直到头指针和尾指针相遇，将基准放到指针位置。如果基准最后的位置左右还有数据，依]]></description><category></category></item><item><title><![CDATA[关于调节AVL树的平衡（左右旋）]]></title><link>https://blog.youkuaiyun.com/LuKeYY825/article/details/107955780</link><guid>https://blog.youkuaiyun.com/LuKeYY825/article/details/107955780</guid><author>LuKeYY825</author><pubDate>Wed, 12 Aug 2020 15:33:51 +0800</pubDate><description><![CDATA[关于调节AVL树的平衡（左右旋）
AVL树：具有以下性质的二叉搜索树：左右孩子也都是AVL树，并且左右子树高度差的绝对值不超过1（平衡因子为-1，0，1中的一个）。
平衡因子：该节点右子树和左子树的高度差，这个数字即是这个结点的平衡因子。
也就是说：AVL树是在BST树的基础上增加了平衡因子的概念，变成了平衡二叉搜索树。

关于结点类型和树的设计：
typedef int KeyType;
typedef struct AVLNode{
	AVLNode*left;
	AVLNode*right;
	AVL]]></description><category></category></item><item><title><![CDATA[C++设计模式：单例模式（懒汉模式，痴汉模式，双重锁机制模式）]]></title><link>https://blog.youkuaiyun.com/LuKeYY825/article/details/107912165</link><guid>https://blog.youkuaiyun.com/LuKeYY825/article/details/107912165</guid><author>LuKeYY825</author><pubDate>Mon, 10 Aug 2020 15:06:55 +0800</pubDate><description><![CDATA[C++设计模式：单例模式（懒汉模式，痴汉模式，双重锁机制模式）
所谓单例模式就是这个类只生成一个对象，那么如何做到让他只生成一个对象呢？

将构造放在private访问限定符下；
在public访问限定符下提供一个结构调用构造；
通过访问标记是否为空而判断是创建对象还是返回对象


懒汉模式： 延时加载，需要的时候再加载（下面的普通单例模式和双重锁机制都是懒汉模式）
痴汉模式： 贪婪加载，对象提前加载

话不多说，上才艺！！！

普通单例模式

class SingleTon
{
public:
	stat]]></description><category></category></item><item><title><![CDATA[C++设计模式：工厂模式(简单工厂模式，工厂方法模式，抽象工厂模式)]]></title><link>https://blog.youkuaiyun.com/LuKeYY825/article/details/107907367</link><guid>https://blog.youkuaiyun.com/LuKeYY825/article/details/107907367</guid><author>LuKeYY825</author><pubDate>Mon, 10 Aug 2020 11:40:16 +0800</pubDate><description><![CDATA[设计模式：工厂模式
工厂模式：是一种创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
工厂模式分为三种：

简单工厂模式
工厂方法模式
抽象工厂模式


简单工厂模式：
一个工厂，通过switch语句来提供不同类型的对象的创建。试用于规模固定，不容易发生产品变动。
缺点：不满足开放-封闭原则，当出现新产品的时候，需要在switch里加case语句
开放-封闭原则

开放原则：新版本设计时可以使用旧版本的代码
封]]></description><category></category></item><item><title><![CDATA[C++设计模式：观察者模式（监听者模式）]]></title><link>https://blog.youkuaiyun.com/LuKeYY825/article/details/107893915</link><guid>https://blog.youkuaiyun.com/LuKeYY825/article/details/107893915</guid><author>LuKeYY825</author><pubDate>Sun, 09 Aug 2020 15:03:47 +0800</pubDate><description><![CDATA[C++设计模式：观察者模式（监听者模式）
所谓观察者监听者模式就是：当观察者观察到事件到来之后，通知对该事件感兴趣的监听者进行相应的操作
需要解决的问题：

观察者需要做的事情？
①事件到来的时候，通知感兴趣的监听者
②事件到来之前，先把监听者和事件的关系进行注册
如何通知对该事件感兴趣的监听者？
调用该监听者的接口（函数）。
如何处理监听者和事件之间的关系？
可能存在一个监听者对多个事件感兴趣，所以这里我们用C++中STL的map映射容器（一对多）。
key存放事件名称，value存放一个vector容器]]></description><category></category></item><item><title><![CDATA[关于数据库（MySQL）存储引擎，索引，事务，锁的概念总结]]></title><link>https://blog.youkuaiyun.com/LuKeYY825/article/details/107593985</link><guid>https://blog.youkuaiyun.com/LuKeYY825/article/details/107593985</guid><author>LuKeYY825</author><pubDate>Mon, 27 Jul 2020 17:10:23 +0800</pubDate><description><![CDATA[关于数据库（MySQL）存储引擎，索引，事务，锁的概念总结

存储引擎
查看当前版本数据库支持的存储引擎：show engines;

此处主要概述MyISAM，InnoDB，MEMORY，ARCHIVE四个存储引擎。
MyISAM
1&gt;不支持外键（可以设置，但不生效）
2&gt;支持全文索引
3&gt;不支持事务（但有类似事务的伪事务）
4&gt;支持B+树的索引
5&gt;支持表锁
6&gt;数据存放在磁盘中
InnoDB
1&gt;支持外键
2&gt;不支持全文索引
3&gt;支持事务
4&gt]]></description><category></category></item><item><title><![CDATA[关于const修饰指针的几种情况]]></title><link>https://blog.youkuaiyun.com/LuKeYY825/article/details/106735110</link><guid>https://blog.youkuaiyun.com/LuKeYY825/article/details/106735110</guid><author>LuKeYY825</author><pubDate>Sat, 13 Jun 2020 18:07:53 +0800</pubDate><description><![CDATA[const和（星号）结合一般分为以下四种情况*
const int *a = &amp;b; //情况1
int const *a = &amp;b; //情况2
int *const a = &amp;b; //情况3
const int* const a =&amp;b; //情况4

情况一和情况二： const位于星号的左侧
const就是用来修饰指针所指向的变量，即指针指向为常量（与const放在变量声明符中的位置无关，所以情况一和情况二视为同种）
int b =500;
const int *a]]></description><category></category></item><item><title><![CDATA[二维数组中的查找]]></title><link>https://blog.youkuaiyun.com/LuKeYY825/article/details/104508729</link><guid>https://blog.youkuaiyun.com/LuKeYY825/article/details/104508729</guid><author>LuKeYY825</author><pubDate>Wed, 26 Feb 2020 01:06:34 +0800</pubDate><description><![CDATA[在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序，请完成一个函数，输入一个二维数组和一个整数，判断数组中是否含有这个数字
首先实现一个二维数组转一维数组的表达方式，因为二维数组本身就是又一维数组延伸而来的，即将一个一维数组等份分割即可构成一个二维数组。
假设二维数组arr的  行数为：rows      列数为：columns
那么用一维数组brr表示arr...]]></description><category></category></item><item><title><![CDATA[查找数组中重复的数字]]></title><link>https://blog.youkuaiyun.com/LuKeYY825/article/details/104442609</link><guid>https://blog.youkuaiyun.com/LuKeYY825/article/details/104442609</guid><author>LuKeYY825</author><pubDate>Sun, 23 Feb 2020 21:11:59 +0800</pubDate><description><![CDATA[查找数组中重复的数字
情况1：
在一个长度为n的数组里的所有数字都在0~1的范围内。数组中某些数字是重复的，但不知道是哪几个数字重复了，也不知道数字重复了几次，找出任意一个重复的数字。
例如：长度为7的数组{2，3，1，0，2，5，3}，应该输出2或者3。
方法一：先将数组进行排序，然后从到尾扫描就好。
缺点：需要O（nlogn）的时间。
方法二：利用哈希表，从头到尾扫描数组，每扫到一个数字查看哈...]]></description><category></category></item><item><title><![CDATA[判断链表是否有环并找到进入环的那个结点]]></title><link>https://blog.youkuaiyun.com/LuKeYY825/article/details/94551844</link><guid>https://blog.youkuaiyun.com/LuKeYY825/article/details/94551844</guid><author>LuKeYY825</author><pubDate>Wed, 03 Jul 2019 15:43:21 +0800</pubDate><description><![CDATA[判断链表是否有环并找到进入环的那个结点
单链表的三种情况：
1，尾结点接到头结点上 （循环链表）
2，尾结点接到链表中间（数字6形状）
3，无环，存在结点指向null
思想：定义两个指针，fast指针跑的速度是slow的二倍
1，如果两指针相遇，那么就有环（有环的话，他们两都会一直在环里跑，而fast的速度是slow的两倍，所以会相遇）
2，如果fast指针不跑了，说明遇到了null，即表示没有环...]]></description><category></category></item><item><title><![CDATA[判断两个单链表是否相交]]></title><link>https://blog.youkuaiyun.com/LuKeYY825/article/details/94544923</link><guid>https://blog.youkuaiyun.com/LuKeYY825/article/details/94544923</guid><author>LuKeYY825</author><pubDate>Wed, 03 Jul 2019 10:00:41 +0800</pubDate><description><![CDATA[判断两个单链表是否相交
单链表也就是每一个结点包括一个数据域和一个指针域，那么如果两个单链表相交，即两个链表呈现Y形状

那么怎么怎来实现这个算法呢
typedef int ElemType;

typedef struct _Node
{
	ElemType data;
	struct _Node *next;
}LNode, *LinkList;

想到第一个方法，那就是定义两个指针，内嵌循环...]]></description><category></category></item><item><title><![CDATA[将字符串中的特定元素移动至字符串尾部]]></title><link>https://blog.youkuaiyun.com/LuKeYY825/article/details/93710861</link><guid>https://blog.youkuaiyun.com/LuKeYY825/article/details/93710861</guid><author>LuKeYY825</author><pubDate>Thu, 27 Jun 2019 11:14:10 +0800</pubDate><description><![CDATA[###将字符串中的特定元素移动至字符串尾部###
首先得到一个字符串，第一步想法一定是将字符串从头遍历，
#include &lt;stdio.h&gt;
#include&lt;assert.h&gt;

void Delete(char *str,char pos)
{
assert(str!=NULL);
   int count=0;                            ...]]></description><category></category></item><item><title><![CDATA[折半查找法]]></title><link>https://blog.youkuaiyun.com/LuKeYY825/article/details/88926792</link><guid>https://blog.youkuaiyun.com/LuKeYY825/article/details/88926792</guid><author>LuKeYY825</author><pubDate>Sun, 31 Mar 2019 12:16:31 +0800</pubDate><description><![CDATA[折半查找法：即在一个有序数列中，拿着需要查找的数字，与数列中间项进行比较，如果大于中间项，那么把中间项变为最小项接着进行对比，以此类推。（如果小于，是一样的方法）
具体操作如下：
void zbcz(int n)
{
&nbsp;int a[15] = { 15,14,13,12,11,10,9,8,7,6,5,4,3,2,1 };
&nbsp;int min=1;
&nbsp;int max=1...]]></description><category></category></item><item><title><![CDATA[求π的近似值]]></title><link>https://blog.youkuaiyun.com/LuKeYY825/article/details/88926649</link><guid>https://blog.youkuaiyun.com/LuKeYY825/article/details/88926649</guid><author>LuKeYY825</author><pubDate>Sun, 31 Mar 2019 12:07:09 +0800</pubDate><description><![CDATA[π/4=1-1/3+1/5-1/7+…
根据这个表达式，我们可以从数学角度来思考，这里的每一项可以构成一个数列。
也就是一分之一+负的三分之一+五分之一+负的七分之一
不难发现每一项的分母是2n-1，然后偶数项为负，奇数项为正
具体操作如下：
 double j = 0;
 for (double n = 1; (2 * n) - 1 &lt;= pow(10 * 1.0, 6); n++)
 {...]]></description><category></category></item><item><title><![CDATA[丢弃个位得到个位，丢弃最高位得到最高位]]></title><link>https://blog.youkuaiyun.com/LuKeYY825/article/details/88910957</link><guid>https://blog.youkuaiyun.com/LuKeYY825/article/details/88910957</guid><author>LuKeYY825</author><pubDate>Sun, 31 Mar 2019 11:53:24 +0800</pubDate><description><![CDATA[给出一个数字
（1）求出它是几位数
（2）分别输出每一位数字
（3）按逆序输出各位数字
（1）方法：求一个数是几位数，每次给它除以10，然后丢弃余数，直到为0结束。如123÷10=12（丢弃余数）
具体操作过程如下：


...]]></description><category></category></item></channel></rss>