<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Hello-Algo阅读笔记 on qytlix no blogs</title><link>https://blog.qyt.li/x/categories/hello-algo%E9%98%85%E8%AF%BB%E7%AC%94%E8%AE%B0/</link><description>Recent content from qytlix no blogs</description><generator>Hugo</generator><language>en-us</language><managingEditor>qytlix@gmail.com (qytlix)</managingEditor><webMaster>qytlix@gmail.com (qytlix)</webMaster><copyright>All articles on this blog are licensed under the BY-NC-SA license agreement unless otherwise stated. Please indicate the source when reprinting!</copyright><lastBuildDate>Wed, 08 Apr 2026 11:08:03 +0800</lastBuildDate><atom:link href="https://blog.qyt.li/x/categories/hello-algo%E9%98%85%E8%AF%BB%E7%AC%94%E8%AE%B0/index.xml" rel="self" type="application/rss+xml"/><item><title>数据结构</title><link>https://blog.qyt.li/x/post/tech/hello-algo%E9%98%85%E8%AF%BB%E7%AC%94%E8%AE%B0/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/</link><pubDate>Wed, 08 Apr 2026 11:08:03 +0800</pubDate><author>qytlix@gmail.com (qytlix)</author><guid>https://blog.qyt.li/x/post/tech/hello-algo%E9%98%85%E8%AF%BB%E7%AC%94%E8%AE%B0/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/</guid><description>
<![CDATA[<h1>数据结构</h1><p>Author: qytlix(qytlix@gmail.com)</p>
        
          <p><a href="https://www.hello-algo.com/chapter_data_structure/classification_of_data_structure/#312">3.1</a>
值得说明的是，<strong>所有数据结构都是基于数组、链表或二者的组合实现的</strong>。例如，栈和队列既可以使用数组实现，也可以使用链表实现；而哈希表的实现可能同时包含数组和链表。</p>
<ul>
<li><strong>基于数组可实现</strong>：栈、队列、哈希表、树、堆、图、矩阵、张量（$\ge 3$维的数组）等。</li>
<li><strong>基于链表可实现</strong>：栈、队列、哈希表、树、堆、图等。
<a href="https://www.hello-algo.com/chapter_data_structure/basic_data_types/">3.2</a>
即使表示布尔量仅需 1 位（$0$或$1$），它在内存中通常也存储为 1 字节。这是因为现代计算机 CPU 通常将 1 字节作为最小寻址内存单元。</li>
</ul>
<p><strong>基本数据类型提供了数据的“内容类型”，而数据结构提供了数据的“组织方式”</strong>。
<a href="https://www.hello-algo.com/chapter_data_structure/number_encoding/#332">精妙的小数记录</a></p>
        
        <hr><p>Published on 2026-04-08 at <a href='https://blog.qyt.li/x/'>qytlix no blogs</a>, last modified on 2026-04-08</p>]]></description><category>Hello-algo阅读笔记</category><category>content</category><category>tech</category></item><item><title>尾递归</title><link>https://blog.qyt.li/x/post/tech/hello-algo%E9%98%85%E8%AF%BB%E7%AC%94%E8%AE%B0/%E5%B0%BE%E9%80%92%E5%BD%92/</link><pubDate>Wed, 08 Apr 2026 11:08:03 +0800</pubDate><author>qytlix@gmail.com (qytlix)</author><guid>https://blog.qyt.li/x/post/tech/hello-algo%E9%98%85%E8%AF%BB%E7%AC%94%E8%AE%B0/%E5%B0%BE%E9%80%92%E5%BD%92/</guid><description>
<![CDATA[<h1>尾递归</h1><p>Author: qytlix(qytlix@gmail.com)</p>
        
          <p><a href="https://www.hello-algo.com/chapter_computational_complexity/iteration_and_recursion/#2">Link</a>
<strong>如果函数在返回前的最后一步才进行递归调用</strong>，则该函数可以被编译器或解释器优化，使其在空间效率上与迭代相当。这种情况被称为尾递归（tail recursion）。</p>
<ul>
<li><strong>普通递归</strong>：当函数返回到上一层级的函数后，需要继续执行代码，因此系统需要保存上一层调用的上下文。</li>
<li><strong>尾递归</strong>：递归调用是函数返回前的最后一个操作，这意味着函数返回到上一层级后，无须继续执行其他操作，因此系统无须保存上一层函数的上下文。</li>
</ul>

  <blockquote class="alert-blockquote tip">
    <p class="alert-heading">
      Tip
    </p>
    <p><p>请注意，许多编译器或解释器并不支持尾递归优化。例如，Python 默认不支持尾递归优化，因此即使函数是尾递归形式，仍然可能会遇到栈溢出问题。</p></p>
  </blockquote>
        
        <hr><p>Published on 2026-04-08 at <a href='https://blog.qyt.li/x/'>qytlix no blogs</a>, last modified on 2026-04-08</p>]]></description><category>Hello-algo阅读笔记</category><category>content</category><category>tech</category></item><item><title>函数渐进上界</title><link>https://blog.qyt.li/x/post/tech/hello-algo%E9%98%85%E8%AF%BB%E7%AC%94%E8%AE%B0/%E5%87%BD%E6%95%B0%E6%B8%90%E8%BF%9B%E4%B8%8A%E7%95%8C/</link><pubDate>Wed, 08 Apr 2026 11:08:03 +0800</pubDate><author>qytlix@gmail.com (qytlix)</author><guid>https://blog.qyt.li/x/post/tech/hello-algo%E9%98%85%E8%AF%BB%E7%AC%94%E8%AE%B0/%E5%87%BD%E6%95%B0%E6%B8%90%E8%BF%9B%E4%B8%8A%E7%95%8C/</guid><description>
<![CDATA[<h1>函数渐进上界</h1><p>Author: qytlix(qytlix@gmail.com)</p>
        
          <p><a href="https://www.hello-algo.com/chapter_computational_complexity/time_complexity/#232">Link</a>
设算法的操作数量是一个关于输入数据大小$n$的函数，记为$T(n)$，则以上函数的操作数量为：
$$T(n)=3+2n$$
$T(n)$是一次函数，说明其运行时间的增长趋势是线性的，因此它的时间复杂度是线性阶。
我们将线性阶的时间复杂度记为$O(n)$，这个数学符号称为大$O$记号（big-$O$notation），表示函数$T(n)$的渐近上界（asymptotic upper bound）。
$$(-.-|||)$$
$$(o.O)$$</p>
        
        <hr><p>Published on 2026-04-08 at <a href='https://blog.qyt.li/x/'>qytlix no blogs</a>, last modified on 2026-04-08</p>]]></description><category>Hello-algo阅读笔记</category><category>content</category><category>tech</category></item><item><title>O(log n)的底数</title><link>https://blog.qyt.li/x/post/tech/hello-algo%E9%98%85%E8%AF%BB%E7%AC%94%E8%AE%B0/olog-n%E7%9A%84%E5%BA%95%E6%95%B0/</link><pubDate>Wed, 08 Apr 2026 11:08:03 +0800</pubDate><author>qytlix@gmail.com (qytlix)</author><guid>https://blog.qyt.li/x/post/tech/hello-algo%E9%98%85%E8%AF%BB%E7%AC%94%E8%AE%B0/olog-n%E7%9A%84%E5%BA%95%E6%95%B0/</guid><description>
<![CDATA[<h1>O(log n)的底数</h1><p>Author: qytlix(qytlix@gmail.com)</p>
        
          <p>由换底公式可得$O(log_m<del>n)=O(\frac{log_k</del>n}{log_k<del>m})=O(log_k</del>n)$所以可以直接省略底数。</p>
        
        <hr><p>Published on 2026-04-08 at <a href='https://blog.qyt.li/x/'>qytlix no blogs</a>, last modified on 2026-04-08</p>]]></description><category>Hello-algo阅读笔记</category><category>content</category><category>tech</category></item></channel></rss>