atom.xml

<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
    <id>https://theNefelibata.github.io/</id>
    <title>theNefelibata</title>
    <updated>2022-04-27T15:04:46.079Z</updated>
    <generator>https://github.com/jpmonette/feed</generator>
    <link rel="alternate" href="https://theNefelibata.github.io/"/>
    <link rel="self" href="https://theNefelibata.github.io/atom.xml"/>
    <subtitle>温故而知新</subtitle>
    <logo>https://theNefelibata.github.io/images/avatar.png</logo>
    <icon>https://theNefelibata.github.io/favicon.ico</icon>
    <rights>All rights reserved 2022, theNefelibata</rights>
    <entry>
        <title type="html"><![CDATA[C++智能指针实现]]></title>
        <id>https://theNefelibata.github.io/post/czhi-neng-zhi-zhen-shi-xian/</id>
        <link href="https://theNefelibata.github.io/post/czhi-neng-zhi-zhen-shi-xian/">
        </link>
        <updated>2021-06-06T14:47:37.000Z</updated>
        <content type="html"><![CDATA[<p><code>std::share_prt</code></p>
<p><code>std:unique_ptr</code></p>
<p><code>std::weak_ptr</code></p>
<h3 id="深拷贝与浅拷贝">深拷贝与浅拷贝</h3>
<ul>
<li>深拷贝优缺点
<ul>
<li>优点：每一个对象（即使是通过拷贝构造函数实例化的对象）的指针都有指向的内存空间，而不是共享，这样在释放的时候就不存在重复释放或者是内存泄漏问题了</li>
<li>缺点：内存开销大</li>
</ul>
</li>
<li>浅拷贝优缺点
<ul>
<li>通过拷贝构造函数实例化的指针数据变量指向的是共享的内存空间，因此内存开销小。</li>
<li>对象析构的时候可能会重复释放或造成内存泄漏。</li>
</ul>
</li>
</ul>
<h2 id="引用计数">引用计数：</h2>
<h3 id="对浅拷贝进行优化">对浅拷贝进行优化</h3>
<pre><code class="language-cpp">struct RefValue 
{

	RefValue(const char* pszName);
	~RefValue();

	void AddRef();
	void Release();

	char* m_pszName;
	int   m_nCount;
};

RefValue::RefValue(const char* pszName)
{
	m_pszName = new char[strlen(pszName)+1];
	
	m_nCount = 1;

}

RefValue::~RefValue()
{

	if (m_pszName != NULL)
	{
		delete m_pszName;
		m_pszName = NULL;
	}
}

void RefValue::AddRef()
{
	m_nCount++;
}

void RefValue::Release()
{
	if (--m_nCount == 0)
	{
		delete this;
	}
	
}
</code></pre>
<p>在进行浅拷贝时加入一个变量保存引用次数，引用一次数值+1，释放一次数值-1，当引用计数为0时，进行delete或者free();</p>
<p>仍然存在的问题：</p>
<ul>
<li>如果对其中某一个类对象中的资源进行了修改，那么所有引用该资源的对象全部会被修改，这显然是错误的</li>
</ul>
<h2 id="写时拷贝">写时拷贝：</h2>
<p>使用引用计数时，当发生共享资源被改变的时候，将共享资源重新复制一份进行修改，不改变共享资源本身。</p>
<h2 id="智能指针实现">智能指针实现：</h2>
<p>首先一个智能指针是一个类，通过构造函数与析构函数实现资源的分配与回收：</p>
<pre><code class="language-cpp">#include &lt;iostream&gt;

using namespace std;

class smart_ptr{
public:
    explicit smart_ptr(){
        _ptr = new int;
        cout&lt;&lt;&quot;alloc ptr.&quot;&lt;&lt;endl;
    }
    ~smart_ptr(){
        delete _ptr;
        cout&lt;&lt;&quot;delete ptr.&quot;&lt;&lt;endl;
    }
    int* get(){
        return _ptr;
    }
private:
    int* _ptr;
};

int main(){
    smart_ptr ptr;
    return 0;
}
</code></pre>
<p>这个类可以完成智能指针的最基本功能：对超出作用域的对象进行释放，但它缺少了：</p>
<ul>
<li>这个类只适用于int</li>
<li>这个类用起来不像指针</li>
<li>拷贝该类对象会引发程序行为异常</li>
</ul>
<h3 id="模板化">模板化：</h3>
<p>要让这个类能够包装任意类型的指针，需要把它变成一个类模板：</p>
<pre><code class="language-cpp">#include &lt;iostream&gt;

using namespace std;

class A{
public:
    void get(){
    cout&lt;&lt;&quot;the val of this class is:&quot;&lt;&lt;val&lt;&lt;endl;
}
private:
    int val = 1;
};
template &lt;typename T&gt;
class smart_ptr{
public:
    explicit smart_ptr(T* ptr = nullptr): _ptr(ptr){
        cout&lt;&lt;&quot;alloc ptr.&quot;&lt;&lt;endl;
    }
    ~smart_ptr(){
        delete _ptr;
        cout&lt;&lt;&quot;delete ptr.&quot;&lt;&lt;endl;
    }
    T* get(){
        return _ptr;
    }
private:
    T* _ptr;
};

int main(){
    smart_ptr&lt;A&gt; ptr(new A);
    ptr.get()-&gt;get();
    smart_ptr&lt;int&gt; ptr2(new int(5));
    cout&lt;&lt;&quot;the value of ptr2:&quot;&lt;&lt;*(ptr2.get())&lt;&lt;endl;
    return 0;
}
</code></pre>
<p>好了，通过将这个类模板化，我们可以将这个智能指针用于任何类型。</p>
<p>输出为：</p>
<pre><code>alloc ptr.
the val of this class is:1
alloc ptr.
the value of ptr2:5
delete ptr.
delete ptr.
</code></pre>
<h3 id="运算符重载">运算符重载：</h3>
<p>为了让这个类用起来更像一个指针，我们还需要对以下的运算符进行重载：</p>
<pre><code class="language-cpp">T&amp; operator*() const{ return *_ptr;}
T* operator-&gt;() const{ return _ptr;}
</code></pre>
<pre><code class="language-cpp">int main(){
    smart_ptr&lt;A&gt; ptr(new A);
    ptr-&gt;get();
    (*ptr).get();
    return 0;
}
</code></pre>
<p>输出：</p>
<pre><code class="language-cpp">alloc ptr.
the val of this class is:1
the val of this class is:1
delete ptr.
</code></pre>
<h3 id="拷贝构造和赋值">拷贝构造和赋值：</h3>
<p>我们应该如何定义拷贝的行为，假设有如下代码：</p>
<pre><code class="language-cpp">smart_ptr&lt;A&gt; ptr1(new B); //B是A的子类
smart_ptr&lt;A&gt; ptr2{ptr1};
</code></pre>
<pre><code class="language-cpp">template &lt;typename T&gt;
class smart_ptr {
  …
  smart_ptr(smart_ptr&amp; other)
  {
    ptr_ = other.release();//拷贝构造函数让传入的对象失去所有权，同时拷贝对象接管所有权
  }
  smart_ptr&amp; operator=(smart_ptr&amp; rhs)
  {
		//这里首先调用拷贝构造函数创建一个临时类smart_ptr(rhs)，this指针和rhs交换
		//临时对象拿到this之前维护的指针随着临时对象的析构回收
    smart_ptr(rhs).swap(*this);
    return *this;
  }
  …
  T* release()
  {
    T* ptr = ptr_;
    ptr_ = nullptr;
    return ptr;
  }
  void swap(smart_ptr&amp; rhs)
  {
    using std::swap;
    swap(ptr_, rhs.ptr_);
  }
  …
};
</code></pre>
<h3 id="移动指针">移动指针：</h3>
<pre><code class="language-cpp">template &lt;typename T&gt;
class smart_ptr {
  …
  smart_ptr(smart_ptr&amp;&amp; other)
  {
    ptr_ = other.release();
  }
  smart_ptr&amp; operator=(smart_ptr rhs)
  {
    smart_ptr(rhs).swap(*this);
    return *this;
  }
  …
};
</code></pre>
<p>修改的地方：</p>
<ul>
<li>把拷贝构造函数中的参数类型  <code>smart_ptr&amp;</code> 改成了  <code>smart_ptr&amp;&amp;</code>；现在它成了移动构造函数。</li>
<li>把赋值函数中的参数类型  <code>smart_ptr&amp;</code> 改成了 <code>smart_ptr</code>，在构造参数时直接生成新的智能指针，从而不再需要在函数体中构造临时对象。现在赋值函数的行为是移动还是拷贝，完全依赖于构造参数时走的是移动构造还是拷贝构造。</li>
</ul>
<p>根据 C++ 的规则，如果我提供了移动构造函数而没有手动提供拷贝构造函数，那后者自动被禁用</p>
<pre><code class="language-cpp">int main(){
    smart_ptr&lt;A&gt; ptr1{new B};
    //ptr-&gt;get();
    //(*ptr).get();
    smart_ptr&lt;A&gt; ptr2{std::move(ptr1)};
    ptr2-&gt;get();
    return 0;
}
</code></pre>
<p>输出为：</p>
<pre><code class="language-cpp">alloc ptr.
the val of this class is:1
delete ptr.
delete ptr.
</code></pre>
<h3 id="子类指针向基类指针的转换">子类指针向基类指针的转换：</h3>
<pre><code class="language-cpp">template&lt;typename U&gt;
    explicit smart_ptr(smart_ptr&lt;U&gt;&amp;&amp; other){
        _ptr = other.relese();
    }
</code></pre>
<h3 id="引用计数-2">引用计数：</h3>
<p>上面的智能指针基本完成了unique_ptr的功能，一个对象只能被单个unique_ptr拥有，显然不能满足所有使用场景，一种常见的情况是：多个智能指针同时拥有一个对象，当他们全部失效时，这个对象也同时会被删除，这也就是shared_ptr了。多个不同的shared_ptr不仅可以共享一个对象，同时还应共享同一计数器。</p>
<p>计数器接口：</p>
<pre><code class="language-cpp">class share_count{
public:
    share_count();
    void add_account();
    long reduce_count();
    long get_count() const;
};
</code></pre>
<p>这个share_count类除构造函数外有三个方法：增加计数，减少计数，获取计数。增加计数不需要返回值，减少计数需要返回当前计数以判断是不是最后一个共享计数的share_ptr。</p>
<pre><code class="language-cpp">class shared_count{
public:
    shared_count() : _count(1){}
    void add_account(){
        ++_count;
    }
    long reduce_count(){
        return --_count;
    }
    long get_count() const{
        return _count;
    }

private:
    long _count;
};
</code></pre>
<p>加下来我们就可以将引用计数器加入到我们的智能指针里了：</p>
<pre><code class="language-cpp">template &lt;typename T&gt;
class smart_ptr{
    explicit smart_ptr(T* ptr = nullptr): _ptr(ptr) {
     if(ptr){
         _shared_count = new shared_count();
     }   
    }
    ~smart_ptr(){
        if(_ptr &amp;&amp; !_shared_count-&gt;reduce_count()){
            delete _ptr;
            delete _shared_count;
        }
    }
private:
    smart_ptr* _ptr;
    shared_count* _shared_count;
};
</code></pre>
<p>逻辑很清晰，当然我们还有更多细节需要处理：</p>
<pre><code class="language-cpp">void swap(smart_ptr&amp; rhs){
        using std::swap;
        swap(_ptr, rhs._ptr);
        swap(_shared_count, rhs._shared_count);
    }
</code></pre>
<p>赋值函数可以不变，但是拷贝构造函数和移动构造函数需要更新：</p>
<pre><code class="language-cpp">		//赋值函数
    smart_ptr&amp; operator=(smart_ptr rhs){
        rhs.swap(*this);
        return *this;
    }
    //拷贝构造函数
    smart_ptr(const smart_ptr&amp; other){
        _ptr = other._ptr;
        if(_ptr){
            other._shared_count-&gt;add_account();
            _shared_count = other._shared_count;
        }
    }
    template&lt;typename U&gt;
    explicit smart_ptr(const smart_ptr&lt;U&gt;&amp; other){
        _ptr = other._ptr;
        if(_ptr){
            other._shared_count-&gt;add_account();
            _shared_count = other._shared_count;
        }
    }
    //移动构造函数
    template&lt;typename U&gt;
    explicit smart_ptr(smart_ptr&lt;U&gt;&amp;&amp; other){
        _ptr = other._ptr;
        if(_ptr){
            _shared_count = other._shared_count;
            other._ptr = nullptr;
        }
    }
</code></pre>
<p>因为模板的实例之间并不天然就有friend关系，所以上面的代码会报错，我们需要在smart_ptr的定义中显式的声明：</p>
<pre><code class="language-cpp">template&lt;typename U&gt;
friend class smart_ptr;
</code></pre>
<p>添加一个获取当前引用计数的函数：</p>
<pre><code class="language-cpp">long use_count() const{
        if(_ptr){
            return _shared_count-&gt;get_count();
        }else{
            return 0;
        }
    }
</code></pre>
<p>测试一下：</p>
<pre><code class="language-cpp">class A{
public:
    void get(){
    cout&lt;&lt;&quot;the val of this class is:&quot;&lt;&lt;val&lt;&lt;endl;
		}
		virtual ~A()=default;
private:
    int val = 1;
};

class B:public A{
public:
    void getb() {
        cout &lt;&lt; &quot;the val of this class is:&quot; &lt;&lt; bval &lt;&lt; endl;
    }
private:
    int bval = 2;
};
int main(){
    smart_ptr&lt;B&gt; ptr1{new B};
    cout&lt;&lt;&quot;use count of ptr1 is:&quot;&lt;&lt;ptr1.use_count()&lt;&lt;endl;
    smart_ptr&lt;A&gt; ptr2;
    cout&lt;&lt;&quot;use count of ptr2 is:&quot;&lt;&lt;ptr2.use_count()&lt;&lt;endl;
    ptr2 = ptr1;
    cout&lt;&lt;&quot;use count of ptr2 is:&quot;&lt;&lt;ptr2.use_count()&lt;&lt;endl;
    cout&lt;&lt;&quot;use count of ptr1 is:&quot;&lt;&lt;ptr1.use_count()&lt;&lt;endl;
    return 0;
}
</code></pre>
<p>输出为：</p>
<pre><code class="language-cpp">use count of ptr1 is:1
use count of ptr2 is:0
use count of ptr2 is:2
use count of ptr1 is:2
</code></pre>
<h3 id="指针类型转换">指针类型转换：</h3>
<p>首先需要添加构造函数，允许在对智能指针内部的指针对象赋值时，使用一个现有的智能指针的共享计数：</p>
<pre><code class="language-cpp">template&lt;typename U&gt;
    smart_ptr(const smart_ptr&lt;U&gt;&amp; other, T* ptr){
        _ptr = ptr;
        if(_ptr){
            other._shared_count-&gt;add_account();
            _shared_count = other._shared_count;
        }
    }
</code></pre>
<pre><code class="language-cpp">template&lt;typename T, typename U&gt;
smart_ptr&lt;T&gt; dynamic_pointer_cast(const smart_ptr&lt;U&gt;&amp; other){
    T* ptr = dynamic_cast&lt;T*&gt;(other.get());
    return smart_ptr&lt;T&gt;(other, ptr);
}
</code></pre>
<p>测试：</p>
<pre><code class="language-cpp">int main(){
    smart_ptr&lt;B&gt; ptr1{new B};
    cout&lt;&lt;&quot;use count of ptr1 is:&quot;&lt;&lt;ptr1.use_count()&lt;&lt;endl;
    smart_ptr&lt;A&gt; ptr2;
    cout&lt;&lt;&quot;use count of ptr2 is:&quot;&lt;&lt;ptr2.use_count()&lt;&lt;endl;
    ptr2 = ptr1;
    cout&lt;&lt;&quot;use count of ptr2 is:&quot;&lt;&lt;ptr2.use_count()&lt;&lt;endl;
    cout&lt;&lt;&quot;use count of ptr1 is:&quot;&lt;&lt;ptr1.use_count()&lt;&lt;endl;
    smart_ptr&lt;B&gt; ptr3 = dynamic_pointer_cast&lt;B&gt;(ptr2);
    cout&lt;&lt;&quot;use count of ptr3 is:&quot;&lt;&lt;ptr3.use_count()&lt;&lt;endl;
    return 0;
</code></pre>
<p>输出：</p>
<pre><code class="language-cpp">use count of ptr1 is:1
use count of ptr2 is:0
use count of ptr2 is:2
use count of ptr1 is:2
use count of ptr3 is:3
</code></pre>
<p>完整代码(待完善)：</p>
<pre><code class="language-cpp">class shared_count{
public:
    shared_count() : _count(1){}
    void add_account(){
        ++_count;
    }
    long reduce_count(){
        return --_count;
    }
    long get_count() const{
        return _count;
    }

private:
    long _count;
};

template &lt;typename T&gt;
class smart_ptr{
public:
    template&lt;typename U&gt;
    friend class smart_ptr;
    //构造函数
    explicit smart_ptr(T* ptr = nullptr): _ptr(ptr) {
     if(ptr){
         _shared_count = new shared_count();
     }
    }
    //智能指针类型转换
    template&lt;typename U&gt;
    smart_ptr(const smart_ptr&lt;U&gt;&amp; other, T* ptr){
        _ptr = ptr;
        if(_ptr){
            other._shared_count-&gt;add_account();
            _shared_count = other._shared_count;
        }
    }
    //赋值函数
    smart_ptr&amp; operator=(smart_ptr rhs){
        rhs.swap(*this);
        return *this;
    }
    //拷贝构造函数
    smart_ptr(const smart_ptr&amp; other){
        _ptr = other._ptr;
        if(_ptr){
            other._shared_count-&gt;add_account();
            _shared_count = other._shared_count;
        }
    }
    template&lt;typename U&gt;
    smart_ptr(const smart_ptr&lt;U&gt;&amp; other){
        _ptr = other._ptr;
        if(_ptr){
            other._shared_count-&gt;add_account();
            _shared_count = other._shared_count;
        }
    }
    //移动构造函数
    template&lt;typename U&gt;
    smart_ptr(smart_ptr&lt;U&gt;&amp;&amp; other){
        _ptr = other._ptr;
        if(_ptr){
            _shared_count = other._shared_count;
            other._ptr = nullptr;
        }
    }
    ~smart_ptr(){
        if(_ptr &amp;&amp; !_shared_count-&gt;reduce_count()){
            delete _ptr;
            delete _shared_count;
        }
    }
    void swap(smart_ptr&amp; rhs){
        using std::swap;
        swap(_ptr, rhs._ptr);
        swap(_shared_count, rhs._shared_count);
    }
    long use_count() const{
        if(_ptr){
            return _shared_count-&gt;get_count();
        }else{
            return 0;
        }
    }
    /*
     * 重载运算符
     */
    T&amp; operator*() const{ return *_ptr;}
    T* operator-&gt;() const{ return _ptr;}

    T* get() const {
        return _ptr;
    }
private:
    T* _ptr;
    shared_count* _shared_count;
};

template&lt;typename T, typename U&gt;
smart_ptr&lt;T&gt; dynamic_pointer_cast(const smart_ptr&lt;U&gt;&amp; other){
    T* ptr = dynamic_cast&lt;T*&gt;(other.get());
    return smart_ptr&lt;T&gt;(other, ptr);
}
</code></pre>
]]></content>
    </entry>
    <entry>
        <title type="html"><![CDATA[LeetCode 存在重复元素]]></title>
        <id>https://theNefelibata.github.io/post/leetcode-cun-zai-chong-fu-yuan-su/</id>
        <link href="https://theNefelibata.github.io/post/leetcode-cun-zai-chong-fu-yuan-su/">
        </link>
        <updated>2021-04-19T15:31:23.000Z</updated>
        <content type="html"><![CDATA[<h2 id="ii题目">II题目：</h2>
<p>给定一个整数数组和一个整数 k，判断数组中是否存在两个不同的索引 i 和 j，使得 nums [i] = nums [j]，并且 i 和 j 的差的 绝对值 至多为 k。</p>
<pre><code class="language-other">示例 1:

输入: nums = [1,2,3,1], k = 3
输出: true
示例 2:

输入: nums = [1,0,1,1], k = 1
输出: true
示例 3:

输入: nums = [1,2,3,1,2,3], k = 2
输出: false
</code></pre>
<h2 id="iii题解">III题解：</h2>
<p>维护一个大小为K的队列Q，遍历nums，如果nums[i]在队列Q中，则返回True，否则，将nums[i]加入队列Q，将Q多余元素出队。</p>
<figure data-type="image" tabindex="1"><img src="https://res.craft.do/user/preview/3d558d30-7d8a-2616-b1b6-30cf7984eb4b/doc/7237F646-A02F-4975-84A8-2AD1B64CA456/633B44AA-7AA4-4834-850E-92153760C8F0_1" alt="Drawing" loading="lazy"></figure>
<pre><code class="language-python">class Solution:
	def containsNearbyDuplicate(self, nums: List[int], k: int) -&gt; bool:
		queue = []
		if k == 0:
			return False
		for i in nums:
			if i not in queue:
				if len(queue) &lt; k:
					queue.append(i)
				else:
					queue.pop(0)
					queue.append(i)
			else:
				return True
		return False
</code></pre>
<h2 id="iii题目">III题目：</h2>
<p>给你一个整数数组 nums 和两个整数 k 和 t 。请你判断是否存在 两个不同下标 i 和 j，使得 <code>abs(nums[i] - nums[j]) &lt;= t</code>  ，同时又满足 <code>abs(i - j) &lt;= k</code> 。</p>
<p>如果存在则返回 true，不存在返回 false。</p>
<pre><code class="language-python">示例 1：

输入：nums = [1,2,3,1], k = 3, t = 0
输出：true
示例 2：

输入：nums = [1,0,1,1], k = 1, t = 2
输出：true
示例 3：

输入：nums = [1,5,9,1,5,9], k = 2, t = 3
输出：false
</code></pre>
<h2 id="iii题解-2">III题解</h2>
<p>从头开始遍历数组，对于当前下标i，为下标为[i-k,i+k]的元素构造桶🪣，对于每个i我们只需看前面是否有无效桶，将nums[i-(k+1)]的桶删除。</p>
<figure data-type="image" tabindex="2"><img src="https://res.craft.do/user/preview/3d558d30-7d8a-2616-b1b6-30cf7984eb4b/doc/7237F646-A02F-4975-84A8-2AD1B64CA456/C260CF26-75CD-4983-8BF1-2EF05A4F5405_1" alt="Drawing" loading="lazy"></figure>
<p>对于元素nums[i]，获取当前桶id，如果存在的话说明找到符合条件的元素，如果当前桶没有元素，则比较相邻桶，有元素的话做差比较，如果没找到，将当前元素装入桶中。</p>
<ul>
<li>分桶时，如果t=0, 则<code>nums[i]//t</code> 不可行，考虑<code>nums[i]//t+1</code> ;</li>
<li>若<code>nums[i]&lt;0</code>，进行<code>(x+1)//(t+1)-1</code></li>
</ul>
<figure data-type="image" tabindex="3"><img src="https://res.craft.do/user/preview/3d558d30-7d8a-2616-b1b6-30cf7984eb4b/doc/7237F646-A02F-4975-84A8-2AD1B64CA456/E01AEB84-A925-42A0-8406-34CE0294762D_1" alt="Drawing" loading="lazy"></figure>
<h2 id="iii代码">III代码</h2>
<pre><code class="language-python">class Solution:
	def containsNearbyAlmostDuplicate(self, nums: List[int], k: int, t: int) -&gt; bool:
		def getID(x, t):
			return (x+1)//(t+1)-1 if x&lt;0 else x//(t+1)
		
		n = len(nums)
		m = {}
		for i in range(n):
			x = nums[i]
			idx = getID(x, t)
			if idx in m:
				return True
			l , r = idx-1, idx+1
			if l in m and abs(x - m[l]) &lt;= t:
				return True
			if r in m and abs(x - m[r]) &lt;= t:
				return True
			m[idx] = x
			if i &gt;= k:
				m.pop(getID(nums[i-k],t))
		return False
</code></pre>
]]></content>
    </entry>
    <entry>
        <title type="html"><![CDATA[Git基础]]></title>
        <id>https://theNefelibata.github.io/post/git-ji-chu/</id>
        <link href="https://theNefelibata.github.io/post/git-ji-chu/">
        </link>
        <updated>2021-04-04T09:45:32.000Z</updated>
        <content type="html"><![CDATA[<h2 id="版本管理和git的设计">版本管理和Git的设计</h2>
<h3 id="版本管理的需求">版本管理的需求</h3>
<figure data-type="image" tabindex="1"><img src="https://theNefelibata.github.io//post-images/1617529645552.jpg" alt="" loading="lazy"></figure>
<ul>
<li><em><strong>时间机器</strong></em>：
<ul>
<li>全量方案：保存项目的每一个版本的完整信息</li>
<li>增量方案：保存每一版的修改，版本一+补丁=版本二</li>
</ul>
</li>
</ul>
<table>
<thead>
<tr>
<th style="text-align:center"></th>
<th style="text-align:center">优点</th>
<th style="text-align:center">缺点</th>
<th style="text-align:center">使用场景</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align:center">全量方案</td>
<td style="text-align:center">简单、快速</td>
<td style="text-align:center">重复存储，浪费空间</td>
<td style="text-align:center">代码，文本</td>
</tr>
<tr>
<td style="text-align:center">增量方案</td>
<td style="text-align:center">存储空间小</td>
<td style="text-align:center">需要运算，降低了性能，增加了运算时间</td>
<td style="text-align:center">视频，大型二进制文件</td>
</tr>
</tbody>
</table>
<p><img src="https://theNefelibata.github.io//post-images/1617529669702.jpg" alt="" loading="lazy"><br>
系统记录了每一个修改版本的完整信息，存储在.git中</p>
<p><em><strong>文件命名</strong></em><br>
使用文件的SHA-1值来命名文件。<br>
<img src="https://theNefelibata.github.io//post-images/1617529678048.jpg" alt="" loading="lazy"></p>
<h3 id="tree结构和暂存区">Tree结构和暂存区</h3>
<p><img src="https://theNefelibata.github.io//post-images/1617529699670.jpg" alt="" loading="lazy"><br>
<em><strong>目录结构和对应关系</strong></em><br>
<img src="https://theNefelibata.github.io//post-images/1617529689632.jpg" alt="" loading="lazy"><br>
Tree是文件夹，blob是二进制文件<br>
<img src="https://theNefelibata.github.io//post-images/1617529709801.jpg" alt="" loading="lazy"><br>
<em><strong>暂存区</strong></em><br>
文件状态<br>
<img src="https://theNefelibata.github.io//post-images/1617529730491.jpg" alt="" loading="lazy"></p>
<table>
<thead>
<tr>
<th style="text-align:center">code</th>
<th style="text-align:center">index</th>
<th style="text-align:center">SHA-1</th>
<th style="text-align:center">Status</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align:center">在</td>
<td style="text-align:center">在</td>
<td style="text-align:center">不匹配</td>
<td style="text-align:center">modified</td>
</tr>
<tr>
<td style="text-align:center">不存在</td>
<td style="text-align:center">在</td>
<td style="text-align:center"></td>
<td style="text-align:center">removed</td>
</tr>
<tr>
<td style="text-align:center">在</td>
<td style="text-align:center">不存在</td>
<td style="text-align:center"></td>
<td style="text-align:center">added</td>
</tr>
</tbody>
</table>
<h3 id="协同和分支">协同和分支</h3>
<p><em><strong>分布式的版本控制</strong></em><br>
每个人的电脑上都存放一个完整的版本仓库<br>
<em><strong>冲突和合并</strong></em><br>
如果两个人修改了同一个文件File1，第一个人push，没有问题，第二个外人push，会提示File1冲突，需要解决冲突再提交</p>
<p><img src="https://theNefelibata.github.io//post-images/1617529758128.jpg" alt="" loading="lazy"><br>
<em><strong>分支</strong></em><br>
<img src="https://theNefelibata.github.io//post-images/1617529812308.jpg" alt="" loading="lazy"><br>
<em><strong>合并</strong></em><br>
merge、rebase、cherry-pick</p>
<h2 id="常用git命令">常用Git命令</h2>
<ul>
<li><code>git init</code>
<ul>
<li>git初始化命令</li>
<li>将一个文件夹初始化为git仓库</li>
</ul>
</li>
<li><code>git add filename</code>
<ul>
<li><code>git add ./*</code> 将所有文件添加到暂存区</li>
<li>将filename文件添加到暂存区</li>
</ul>
</li>
<li><code>git status</code>
<ul>
<li>查看暂存区状态</li>
</ul>
</li>
<li><code>git reset HEAD--a.txt</code>
<ul>
<li>将文件移出暂存区</li>
</ul>
</li>
<li><code>git cat-file -p SHA-1</code>
<ul>
<li>查看SHA-1文件内容</li>
</ul>
</li>
<li><code>git ls-files --stage</code>
<ul>
<li>查看暂存区内容</li>
</ul>
</li>
<li><code>git commit -m ‘ ‘</code>
<ul>
<li>将暂存区文件提交到git仓库</li>
</ul>
</li>
<li><code>git branch name</code>
<ul>
<li>创建一个名为name的分支</li>
</ul>
</li>
<li><code>git checkout name</code>
<ul>
<li>切换到某个分支</li>
<li>回到某个历史分支<code>git checkout SHA-1</code></li>
<li><code>git checkout -b name</code> 创建一个分支并切换到分支</li>
</ul>
</li>
<li><code>git merge branch-name</code>
<ul>
<li>将分支branch-name合并到当前分支</li>
</ul>
</li>
<li>合并失败：
<ul>
<li><code>git merge --abort</code>放弃合并</li>
<li>手动解决冲突后再提交，然后合并</li>
</ul>
</li>
<li><code>git log</code>
<ul>
<li>查看git日志</li>
</ul>
</li>
<li><code>git pull (origin main)</code>
<ul>
<li>将远程仓库的内容合并到本地仓库</li>
</ul>
</li>
<li><code>git push</code>
<ul>
<li>将本地仓库的内容push到远程仓库</li>
</ul>
</li>
<li><code>git stash</code>
<ul>
<li>将当前修改放入一个列表
<ul>
<li><code>git stash list</code></li>
<li><code>git stash apply</code></li>
</ul>
</li>
<li><code>git stash show/drop/clear</code></li>
</ul>
</li>
</ul>
]]></content>
    </entry>
    <entry>
        <title type="html"><![CDATA[LeetCode 森林中的兔子]]></title>
        <id>https://theNefelibata.github.io/post/leetcode-sen-lin-zhong-de-tu-zi/</id>
        <link href="https://theNefelibata.github.io/post/leetcode-sen-lin-zhong-de-tu-zi/">
        </link>
        <updated>2021-04-03T17:55:34.000Z</updated>
        <content type="html"><![CDATA[<h2 id="题目描述">题目描述</h2>
<p>森林中，每个兔子都有颜色。其中一些兔子（可能是全部）告诉你还有多少其他的兔子和自己有相同的颜色。我们将这些回答放在 answers 数组里。</p>
<p>返回森林中兔子的最少数量。</p>
<pre><code>示例:
输入: answers = [1, 1, 2]
输出: 5
解释:
两只回答了 &quot;1&quot; 的兔子可能有相同的颜色，设为红色。
之后回答了 &quot;2&quot; 的兔子不会是红色，否则他们的回答会相互矛盾。
设回答了 &quot;2&quot; 的兔子为蓝色。
此外，森林中还应有另外 2 只蓝色兔子的回答没有包含在数组中。
因此森林中兔子的最少数量是 5: 3 只回答的和 2 只没有回答的。

输入: answers = [10, 10, 10]
输出: 11

输入: answers = []
输出: 0
</code></pre>
<h2 id="题解">题解</h2>
<p>某种颜色的兔子数等于那种颜色兔子的回答数+1，颜色相同的兔子的回答一定相同，基于这两个特征，我们要求最少的兔子数量，我们可以认为回答相同的兔子属于一种颜色，此时我们只需统计出回答相同的兔子的数量，分配颜色即可，示意图如下：<br>
<img src="https://theNefelibata.github.io//post-images/1617472566346.jpg" alt="" loading="lazy"></p>
<h2 id="代码">代码</h2>
<pre><code class="language-python">class Solution:
	def numRabbits(self, answers: List[int]) -&gt; int:
	cnt = {}
	ans = 0
	for i in answers:
		if i not in cnt.keys():
			cnt[i] = 1
		else:
			cnt[i] += 1
	for k, v in cnt.items():
		ans += (v // (k+1)) * (k + 1)
		if (v % (k+1)) != 0 :
			ans += k + 1

	return ans
</code></pre>
]]></content>
    </entry>
    <entry>
        <title type="html"><![CDATA[LeetCode 最长公共子序列]]></title>
        <id>https://theNefelibata.github.io/post/leetcode-zui-chang-gong-gong-zi-xu-lie/</id>
        <link href="https://theNefelibata.github.io/post/leetcode-zui-chang-gong-gong-zi-xu-lie/">
        </link>
        <updated>2021-04-03T14:29:33.000Z</updated>
        <content type="html"><![CDATA[<!-- more -->
<h2 id="题目描述">题目描述</h2>
<p>给定两个字符串 text1   和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。<br>
一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。<br>
例如，&quot;ace&quot; 是 &quot;abcde&quot; 的子序列，但 &quot;aec&quot; 不是 &quot;abcde&quot; 的子序列。<br>
两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。</p>
<h2 id="题解">题解</h2>
<p>这是一道典型的线性规划，定义数组dp[i][j] 为text1[0:i]和text2[0:j]最长公共子序列的长度。</p>
<ul>
<li>如果text1[i] == text2[j]，那么dp[i][j]就是dp[i-1][j-1]+1</li>
<li>如果text1[i] != text2[j]，那么dp[i][j]就是text1[0:i]和text2[0:j-1]的最长公共子序列 和 text1[0:i-1]和text2[0:j]的最长公共子序列 中最大的那个。</li>
</ul>
<figure data-type="image" tabindex="1"><img src="https://theNefelibata.github.io//post-images/1617460209274.jpg" alt="" loading="lazy"></figure>
<h2 id="代码">代码</h2>
<pre><code class="language-python">class Solution:
    def longestCommonSubsequence(self, text1: str, text2: str) -&gt; int:
        m = len(text1)
        n = len(text2)
        dp = [[0]*(n + 1) for _ in range(m + 1)]

        for i in range(1, m + 1):
            for j in range(1, n + 1):
                if text1[i-1] == text2[j-1]:
                    dp[i][j] = dp[i-1][j-1] + 1
                else:
                    dp[i][j] = max(dp[i][j-1], dp[i-1][j])
            
        return dp[m][n]
</code></pre>
]]></content>
    </entry>
</feed>