剑指Offer——Python答案

最新推荐文章于 2023-02-15 11:56:34 发布
最新推荐文章于 2023-02-15 11:56:34 发布
阅读量1.1k 收藏 5
点赞数
分类专栏： 【 Python相关 】

说明

  • 《剑指Offer》书中所有题目的答案是C++语言编写的。本人在牛客网上做题时，用Python编写了一套答案，整理如下。
  • 《剑指Offer》在线刷题网址：牛客网-剑指Offer
  • 牛客网上的剑指Offer题目有一点需要说明：题目不是完全一样，具体要求有点小的改动。不知道是故意为之，还没认真输入题目。

题目

二维数组中的查找

  • 第一种方法：
<code class="language-python hljs  has-numbering"><span class="hljs-comment"># 借助于in</span>
<span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-comment"># array 二维列表</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">Find</span><span class="hljs-params">(self, array, target)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        flag = <span class="hljs-keyword">False</span>
        <span class="hljs-keyword">for</span> index <span class="hljs-keyword">in</span> range(len(array)):
            <span class="hljs-keyword">if</span> target <span class="hljs-keyword">in</span> array[index]:
                flag = <span class="hljs-keyword">True</span>
        <span class="hljs-keyword">return</span> flag</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li></ul>
  • 第二种方法：
<code class="language-python hljs  has-numbering"><span class="hljs-comment"># 线性复杂度</span>
<span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-comment"># array 二维列表</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">Find</span><span class="hljs-params">(self, array, target)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        <span class="hljs-comment"># 标识变量</span>
        found = <span class="hljs-keyword">False</span>
        <span class="hljs-comment"># 检查输入 None，空数组</span>
        <span class="hljs-keyword">if</span> array == <span class="hljs-keyword">None</span>:
            <span class="hljs-keyword">return</span> found
        nRow = len(array)
        nCol = len(array[<span class="hljs-number">0</span>])
        <span class="hljs-comment"># 右上角位置</span>
        row = <span class="hljs-number">0</span>
        col =  nCol-<span class="hljs-number">1</span>
        <span class="hljs-comment"># 从右上角遍历</span>
        <span class="hljs-keyword">while</span> (row<nRow) <span class="hljs-keyword">and</span> (col>=<span class="hljs-number">0</span>):
            <span class="hljs-keyword">if</span> array[row][col] ==  target:
                found = <span class="hljs-keyword">True</span>
                <span class="hljs-keyword">break</span>
            <span class="hljs-keyword">elif</span> array[row][col] >  target:
                col = col-<span class="hljs-number">1</span>
            <span class="hljs-keyword">else</span>:
                row = row+<span class="hljs-number">1</span>
        <span class="hljs-keyword">return</span> found</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li><li>25</li><li>26</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li><li>25</li><li>26</li></ul>

替换空格

  • 第一种方法：
<code class="language-python hljs  has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-comment"># 线性空间复杂度</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-comment"># s 源字符串</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">replaceSpace</span><span class="hljs-params">(self, s)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        <span class="hljs-keyword">if</span> s == <span class="hljs-keyword">None</span>:
            <span class="hljs-keyword">return</span> <span class="hljs-keyword">None</span>
        <span class="hljs-keyword">if</span> len(s) == <span class="hljs-number">0</span>:
            <span class="hljs-keyword">return</span> <span class="hljs-string">''</span>
        result = <span class="hljs-string">''</span>
        <span class="hljs-keyword">for</span> item <span class="hljs-keyword">in</span> s:
            <span class="hljs-keyword">if</span> item.isspace():
                result = result+<span class="hljs-string">'%20'</span>
            <span class="hljs-keyword">else</span>:
                result = result+item
        <span class="hljs-keyword">return</span> result</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li></ul>
  • 第二种方法：
<code class="language-python hljs  has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-comment"># s 源字符串</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">replaceSpace</span><span class="hljs-params">(self, s)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        <span class="hljs-keyword">return</span> s.replace(<span class="hljs-string">' '</span>, <span class="hljs-string">'%20'</span>)</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li></ul>

从头到尾打印链表

  • 第一种方法：使用insert()方法
<code class="language-python hljs  has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-comment"># 返回从尾部到头部的列表值序列，例如[1,2,3]</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">printListFromTailToHead</span><span class="hljs-params">(self, listNode)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        L = []
        head = listNode
        <span class="hljs-keyword">while</span> head:
            L.insert(<span class="hljs-number">0</span>, head.val)
            head = head.next
        <span class="hljs-keyword">return</span> L</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li></ul>
  • 第二种方法：使用append()和reverse()
<code class="language-python hljs  has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-comment"># 假定是个栈结构，append移动元素少</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-comment"># 返回从尾部到头部的列表值序列，例如[1,2,3]</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">printListFromTailToHead</span><span class="hljs-params">(self, listNode)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        L = []
        head = listNode
        <span class="hljs-keyword">while</span> head:
            L.append(head.val)
            head = head.next
        L.reverse()
        <span class="hljs-keyword">return</span> L</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li></ul>

重建二叉树

<code class="language-python hljs  has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-comment"># class TreeNode:</span>
<span class="hljs-comment">#     def __init__(self, x):</span>
<span class="hljs-comment">#         self.val = x</span>
<span class="hljs-comment">#         self.left = None</span>
<span class="hljs-comment">#         self.right = None</span>


<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-comment"># 返回构造的TreeNode根节点</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">reConstructBinaryTree</span><span class="hljs-params">(self, pre, tin)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        <span class="hljs-keyword">if</span> (len(pre) == <span class="hljs-number">0</span>) <span class="hljs-keyword">or</span> (len(tin) == <span class="hljs-number">0</span>):
            <span class="hljs-keyword">return</span> <span class="hljs-keyword">None</span>

        rootValue = pre[<span class="hljs-number">0</span>]
        root = TreeNode(rootValue)
        <span class="hljs-keyword">if</span> len(pre)==<span class="hljs-number">1</span>:
            <span class="hljs-keyword">return</span> root
        rootTinIndex = <span class="hljs-number">0</span>
        <span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(len(tin)):
            <span class="hljs-keyword">if</span> tin[i] == rootValue:
                rootTinIndex = i
        preStart = <span class="hljs-number">1</span>
        preEnd = rootTinIndex+<span class="hljs-number">1</span>
        tinStart = <span class="hljs-number">0</span>
        tinEnd = rootTinIndex
        <span class="hljs-keyword">if</span> rootTinIndex > <span class="hljs-number">0</span>:
            root.left = self.reConstructBinaryTree(pre[preStart:preEnd], tin[tinStart:tinEnd])
        <span class="hljs-keyword">if</span> rootTinIndex < len(pre):
            root.right = self.reConstructBinaryTree(pre[preEnd:], tin[tinEnd+<span class="hljs-number">1</span>:])
        <span class="hljs-keyword">return</span> root</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li><li>25</li><li>26</li><li>27</li><li>28</li><li>29</li><li>30</li><li>31</li><li>32</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li><li>25</li><li>26</li><li>27</li><li>28</li><li>29</li><li>30</li><li>31</li><li>32</li></ul>

用两个栈实现队列

<code class="language-python hljs  has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    stack1 = []
    stack2 = []
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">push</span><span class="hljs-params">(self, node)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        self.stack1.append(node)
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">pop</span><span class="hljs-params">(self)</span>:</span>
        <span class="hljs-comment"># return xx</span>
        <span class="hljs-keyword">if</span> len(self.stack2) !=  <span class="hljs-number">0</span>:
            <span class="hljs-keyword">return</span> self.stack2.pop()
        <span class="hljs-keyword">elif</span> len(self.stack1) != <span class="hljs-number">0</span>:
            <span class="hljs-keyword">while</span> len(self.stack1):
                self.stack2.append(self.stack1.pop())
            <span class="hljs-keyword">return</span> self.stack2.pop()          </code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li></ul>

旋转数组的最小数字

  • 第一种方法：
<code class="language-python hljs  has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">minNumberInRotateArray</span><span class="hljs-params">(self, rotateArray)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        <span class="hljs-keyword">if</span> len(rotateArray) == <span class="hljs-number">0</span>:
            <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>
        <span class="hljs-keyword">else</span>:
            <span class="hljs-keyword">return</span> min(rotateArray)
</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li></ul>
  • 第二种方法：
<code class="language-python hljs  has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">minNumberInRotateArray</span><span class="hljs-params">(self, rotateArray)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        <span class="hljs-keyword">if</span> len(rotateArray) == <span class="hljs-number">0</span>:
            <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>
        <span class="hljs-string">'''
        if len(rotateArray) == 1:
            return rotateArray[0];
        '''</span>
        index1 = <span class="hljs-number">0</span>
        index2 = len(rotateArray)-<span class="hljs-number">1</span>
        indexMid = index1
        <span class="hljs-keyword">while</span> rotateArray[index1] >= rotateArray[index2]:
            <span class="hljs-keyword">if</span> index2-index1 == <span class="hljs-number">1</span>:
                indexMid = index2
                <span class="hljs-keyword">break</span>
            indexMid = (index1+index2)//<span class="hljs-number">2</span>
            <span class="hljs-keyword">if</span> rotateArray[indexMid] >= rotateArray[index1]:
                index1 = indexMid
            <span class="hljs-keyword">elif</span> rotateArray[indexMid] <= rotateArray[index2]:
                index2 = indexMid 
        <span class="hljs-keyword">return</span> rotateArray[indexMid]
</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li></ul>

斐波那契数列

<code class="language-python hljs  has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">Fibonacci</span><span class="hljs-params">(self, n)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        N2 = <span class="hljs-number">0</span>
        N1 = <span class="hljs-number">1</span>
        <span class="hljs-keyword">if</span> n<=<span class="hljs-number">0</span>:
            <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>
        <span class="hljs-keyword">if</span> n==<span class="hljs-number">1</span>:
            <span class="hljs-keyword">return</span> <span class="hljs-number">1</span>
        <span class="hljs-keyword">while</span> n><span class="hljs-number">1</span>:
            N1 = N1+N2
            N2 = N1-N2
            n = n-<span class="hljs-number">1</span>
        <span class="hljs-keyword">return</span> N1</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li></ul>

跳台阶

<code class="language-python hljs  has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">jumpFloor</span><span class="hljs-params">(self, number)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        N1 = <span class="hljs-number">2</span>
        N2 = <span class="hljs-number">1</span>
        <span class="hljs-keyword">if</span> number==<span class="hljs-number">1</span>:
            <span class="hljs-keyword">return</span> <span class="hljs-number">1</span>
        <span class="hljs-keyword">if</span> number==<span class="hljs-number">2</span>:
            <span class="hljs-keyword">return</span> <span class="hljs-number">2</span>
        <span class="hljs-keyword">while</span> number><span class="hljs-number">2</span>:
            N1 = N1+N2
            N2 = N1-N2
            number = number-<span class="hljs-number">1</span>

        <span class="hljs-keyword">return</span> N1</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li></ul>

变态跳台阶

<code class="language-python hljs  has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">jumpFloorII</span><span class="hljs-params">(self, number)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        <span class="hljs-comment"># 规律：f(n) = 2^(n-1)</span>
        <span class="hljs-keyword">return</span> <span class="hljs-number">2</span>**(number-<span class="hljs-number">1</span>)
</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li></ul>

矩形覆盖

<code class="language-python hljs  has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">rectCover</span><span class="hljs-params">(self, number)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        <span class="hljs-comment"># 菲波那切数列</span>
        N1 = <span class="hljs-number">2</span>
        N2 = <span class="hljs-number">1</span>
        <span class="hljs-keyword">if</span> number <= <span class="hljs-number">0</span>:
            <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>
        <span class="hljs-keyword">if</span> number == <span class="hljs-number">1</span>:
            <span class="hljs-keyword">return</span> N2
        <span class="hljs-keyword">if</span> number == <span class="hljs-number">2</span>:
            <span class="hljs-keyword">return</span> N1
        <span class="hljs-keyword">while</span> number > <span class="hljs-number">2</span>:
            N1 = N1+N2
            N2 = N1-N2
            number -=<span class="hljs-number">1</span>

        <span class="hljs-keyword">return</span> N1</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li></ul>

二进制中1的个数

<code class="language-python hljs  has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">NumberOf1</span><span class="hljs-params">(self, n)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        flag = <span class="hljs-number">1</span>
        print(type(flag))
        count = <span class="hljs-number">0</span>
        <span class="hljs-comment"># int 4字节，4x8=32位</span>
        <span class="hljs-comment"># python能表示任意大的数字，所以手动限定</span>
        maxBit = <span class="hljs-number">32</span>
        <span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(maxBit):
            <span class="hljs-keyword">if</span> n & flag:
                count += <span class="hljs-number">1</span>
            flag = flag << <span class="hljs-number">1</span>
        <span class="hljs-keyword">return</span> count</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li></ul>

数值的整数次方

  • 第一种方法：
<code class="language-python hljs  has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">Power</span><span class="hljs-params">(self, base, exponent)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        <span class="hljs-keyword">return</span> base ** exponent</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li></ul>
  • 第二种方法：
<code class="language-python hljs  has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">Power</span><span class="hljs-params">(self, base, exponent)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        result = <span class="hljs-number">1.0</span>
        <span class="hljs-keyword">if</span> exponent >= <span class="hljs-number">0</span>:
            <span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(exponent):
                result *= base
        <span class="hljs-keyword">else</span>:
            <span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(abs(exponent)):
                result *= base
            result = <span class="hljs-number">1.0</span>/result
        <span class="hljs-keyword">return</span> result</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li></ul>

调整数组顺序使奇数位于偶数前面

  • 第一种方法：
<code class="language-python hljs  has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">reOrderArray</span><span class="hljs-params">(self, array)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        oddL = [item <span class="hljs-keyword">for</span> item <span class="hljs-keyword">in</span> array <span class="hljs-keyword">if</span> item % <span class="hljs-number">2</span>]
        evenL = [item <span class="hljs-keyword">for</span> item <span class="hljs-keyword">in</span> array <span class="hljs-keyword">if</span> <span class="hljs-keyword">not</span> (item % <span class="hljs-number">2</span>)]
        result = oddL + evenL
        <span class="hljs-keyword">return</span> result</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li></ul>
  • 第二种方法：
<code class="hljs python has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">reOrderArray</span><span class="hljs-params">(self, array)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        oddL = filter(<span class="hljs-keyword">lambda</span> x: x%<span class="hljs-number">2</span>, array)
        evenL = filter(<span class="hljs-keyword">lambda</span> x:<span class="hljs-keyword">not</span> (x%<span class="hljs-number">2</span>), array)
        result = oddL + evenL
        <span class="hljs-keyword">return</span> result</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li></ul>

链表中倒数第k个结点

  • 第一种方法：
<code class="language-python hljs  has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-comment"># class ListNode:</span>
<span class="hljs-comment">#     def __init__(self, x):</span>
<span class="hljs-comment">#         self.val = x</span>
<span class="hljs-comment">#         self.next = None</span>

<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">FindKthToTail</span><span class="hljs-params">(self, head, k)</span>:</span>
        <span class="hljs-comment"># 检查输入：空表</span>
        <span class="hljs-keyword">if</span>  <span class="hljs-keyword">not</span> head:
            <span class="hljs-keyword">return</span> head
        <span class="hljs-comment"># 检查输入：k<=0</span>
        <span class="hljs-keyword">if</span> k <= <span class="hljs-number">0</span>:
            <span class="hljs-keyword">return</span> ListNode(<span class="hljs-number">0</span>).next
        pNode = head
        p1 = head
        p2 = head
        <span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> range(k-<span class="hljs-number">1</span>):
            <span class="hljs-comment"># 检查k大于链表长度的情况</span>
            <span class="hljs-keyword">if</span> p1.next:
                p1 = p1.next
            <span class="hljs-keyword">else</span>:
                <span class="hljs-keyword">return</span> p1.next
        <span class="hljs-keyword">while</span> p1.next :
            p1 = p1.next
            p2 = p2.next
        <span class="hljs-keyword">return</span> p2</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li><li>25</li><li>26</li><li>27</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li><li>25</li><li>26</li><li>27</li></ul>
  • 第二种方法：
<code class="language-python hljs  has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-comment"># class ListNode:</span>
<span class="hljs-comment">#     def __init__(self, x):</span>
<span class="hljs-comment">#         self.val = x</span>
<span class="hljs-comment">#         self.next = None</span>

<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">FindKthToTail</span><span class="hljs-params">(self, head, k)</span>:</span>
        <span class="hljs-comment"># 检查输入：空表</span>
        <span class="hljs-keyword">if</span>  <span class="hljs-keyword">not</span> head:
            <span class="hljs-keyword">return</span> head
        <span class="hljs-comment"># 检查输入：k<=0</span>
        <span class="hljs-keyword">if</span> k <= <span class="hljs-number">0</span>:
            <span class="hljs-keyword">return</span> ListNode(<span class="hljs-number">0</span>).next
        <span class="hljs-comment"># 栈</span>
        stack1 = []
        pNode = head
        stack1.append(pNode)
        <span class="hljs-keyword">while</span> pNode.next:
            pNode = pNode.next
            stack1.append(pNode)
        <span class="hljs-keyword">if</span> k <= len(stack1):
            <span class="hljs-keyword">return</span> stack1[-k]
        <span class="hljs-keyword">else</span>:
            <span class="hljs-keyword">return</span> ListNode(<span class="hljs-number">0</span>).next</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li><li>25</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li><li>25</li></ul>

反转链表

<code class="language-python hljs  has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-comment"># class ListNode:</span>
<span class="hljs-comment">#     def __init__(self, x):</span>
<span class="hljs-comment">#         self.val = x</span>
<span class="hljs-comment">#         self.next = None</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-comment"># 返回ListNode</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">ReverseList</span><span class="hljs-params">(self, pHead)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        <span class="hljs-comment"># 检查输入:空链表</span>
        <span class="hljs-keyword">if</span> <span class="hljs-keyword">not</span> pHead:
            <span class="hljs-keyword">return</span> pHead
        pNode = pHead
        <span class="hljs-keyword">while</span> pNode:
            pAfter = pNode.next
            <span class="hljs-keyword">if</span> <span class="hljs-keyword">not</span> pAfter:
                pReversedHead = pNode
            <span class="hljs-keyword">if</span> pNode == pHead:
                pNode.next = <span class="hljs-keyword">None</span>
            <span class="hljs-keyword">else</span>:
                pNode.next = pBefore
            pBefore = pNode
            pNode = pAfter
        <span class="hljs-keyword">return</span> pReversedHead</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li></ul>

合并两个排序的链表

<code class="language-python hljs  has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-comment"># class ListNode:</span>
<span class="hljs-comment">#     def __init__(self, x):</span>
<span class="hljs-comment">#         self.val = x</span>
<span class="hljs-comment">#         self.next = None</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-comment"># 返回合并后列表</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">Merge</span><span class="hljs-params">(self, pHead1, pHead2)</span>:</span>
        <span class="hljs-comment"># 检查输入：空链表</span>
        <span class="hljs-keyword">if</span> <span class="hljs-keyword">not</span> pHead1:
            <span class="hljs-keyword">return</span> pHead2
        <span class="hljs-keyword">if</span> <span class="hljs-keyword">not</span> pHead2:
            <span class="hljs-keyword">return</span> pHead1
        <span class="hljs-comment"># 确定pHead</span>
        pNode1 = pHead1
        pNode2 = pHead2
        <span class="hljs-keyword">if</span> pNode1.val <= pNode2.val:
            pNode = pNode1
            pNode1 = pNode1.next
        <span class="hljs-keyword">else</span>:
            pNode = pNode2
            pNode2 = pNode2.next
        pHead = pNode
        <span class="hljs-keyword">while</span> pNode1 <span class="hljs-keyword">or</span> pNode2:
            <span class="hljs-keyword">if</span> <span class="hljs-keyword">not</span> pNode1:
                pNode.next = pNode2
                pNode2 = pNode2.next
            <span class="hljs-keyword">elif</span> <span class="hljs-keyword">not</span> pNode2:
                pNode.next = pNode1
                pNode1 = pNode1.next
            <span class="hljs-keyword">else</span>:
                <span class="hljs-keyword">if</span> pNode1.val <= pNode2.val:
                    pNode.next = pNode1
                    pNode1 = pNode1.next
                <span class="hljs-keyword">else</span>:
                    pNode.next = pNode2
                    pNode2 = pNode2.next
            pNode = pNode.next
        <span class="hljs-keyword">return</span> pHead</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li><li>25</li><li>26</li><li>27</li><li>28</li><li>29</li><li>30</li><li>31</li><li>32</li><li>33</li><li>34</li><li>35</li><li>36</li><li>37</li><li>38</li><li>39</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li><li>25</li><li>26</li><li>27</li><li>28</li><li>29</li><li>30</li><li>31</li><li>32</li><li>33</li><li>34</li><li>35</li><li>36</li><li>37</li><li>38</li><li>39</li></ul>

树的子结构

<code class="language-python hljs  has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-comment"># class TreeNode:</span>
<span class="hljs-comment">#     def __init__(self, x):</span>
<span class="hljs-comment">#         self.val = x</span>
<span class="hljs-comment">#         self.left = None</span>
<span class="hljs-comment">#         self.right = None</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">DoesTree1HaveTree2</span><span class="hljs-params">(self, pRoot1, pRoot2)</span>:</span>
        <span class="hljs-keyword">if</span> <span class="hljs-keyword">not</span> pRoot2:
            <span class="hljs-keyword">return</span> <span class="hljs-keyword">True</span>
        <span class="hljs-keyword">if</span> <span class="hljs-keyword">not</span> pRoot1:
            <span class="hljs-keyword">return</span> <span class="hljs-keyword">False</span>
        <span class="hljs-keyword">if</span> pRoot1.val != pRoot2.val:
            <span class="hljs-keyword">return</span> <span class="hljs-keyword">False</span>

        <span class="hljs-keyword">return</span> self.DoesTree1HaveTree2(pRoot1.left, pRoot2.left) <span class="hljs-keyword">and</span> self.DoesTree1HaveTree2(pRoot1.right, pRoot2.right)


    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">HasSubtree</span><span class="hljs-params">(self, pRoot1, pRoot2)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        result = <span class="hljs-keyword">False</span>
        <span class="hljs-keyword">if</span> pRoot1 <span class="hljs-keyword">and</span> pRoot2:
            <span class="hljs-keyword">if</span> pRoot1.val == pRoot2.val:
                result = self.DoesTree1HaveTree2(pRoot1, pRoot2)
            <span class="hljs-keyword">if</span> <span class="hljs-keyword">not</span> result:
                result = self.HasSubtree(pRoot1.left, pRoot2)
            <span class="hljs-keyword">if</span> <span class="hljs-keyword">not</span> result:
                result = self.HasSubtree(pRoot1.right, pRoot2)
        <span class="hljs-keyword">return</span> result</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li><li>25</li><li>26</li><li>27</li><li>28</li><li>29</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li><li>25</li><li>26</li><li>27</li><li>28</li><li>29</li></ul>

包含min函数的栈

  • 第一种方法：
<code class="language-python hljs  has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self)</span>:</span>
        self.data = []
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">push</span><span class="hljs-params">(self, node)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        self.data.append(node)
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">pop</span><span class="hljs-params">(self)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        <span class="hljs-keyword">return</span> self.data.pop()
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">top</span><span class="hljs-params">(self)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        <span class="hljs-keyword">return</span> self.data[-<span class="hljs-number">1</span>]
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">min</span><span class="hljs-params">(self)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        <span class="hljs-keyword">return</span> min(self.data)</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li></ul>
  • 第二种方法：
<code class="language-python hljs  has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-comment"># 借助于辅助栈，操作的时间复杂度都为O(1)</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self)</span>:</span>
        self.stackData = []
        self.stackMin = []
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">push</span><span class="hljs-params">(self, node)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        self.stackData.append(node)
        <span class="hljs-keyword">if</span> (len(self.stackMin)==<span class="hljs-number">0</span>) <span class="hljs-keyword">or</span> (node<self.stackMin[-<span class="hljs-number">1</span>]):
            self.stackMin.append(node)
        <span class="hljs-keyword">else</span>:
            self.stackMin.append(self.stackMin[-<span class="hljs-number">1</span>])
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">pop</span><span class="hljs-params">(self)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        <span class="hljs-keyword">if</span> len(self.stackData) <= <span class="hljs-number">0</span>:
            <span class="hljs-keyword">print</span> <span class="hljs-string">"Stack is empty, can't pop."</span>
            <span class="hljs-keyword">return</span>
        self.stackMin.pop()
        <span class="hljs-keyword">return</span> self.stackData.pop()


    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">top</span><span class="hljs-params">(self)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        <span class="hljs-keyword">return</span> self.stackData[-<span class="hljs-number">1</span>]

    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">min</span><span class="hljs-params">(self)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        <span class="hljs-keyword">if</span> len(self.stackMin) <= <span class="hljs-number">0</span>:
            <span class="hljs-keyword">print</span> <span class="hljs-string">"Stack is empty, can't pop."</span>
            <span class="hljs-keyword">return</span>
        <span class="hljs-keyword">return</span> self.stackMin[-<span class="hljs-number">1</span>]</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li><li>25</li><li>26</li><li>27</li><li>28</li><li>29</li><li>30</li><li>31</li><li>32</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li><li>25</li><li>26</li><li>27</li><li>28</li><li>29</li><li>30</li><li>31</li><li>32</li></ul>

栈的压入、弹出序列

<code class="language-python hljs  has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self)</span>:</span>
        self.stackT =[]
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">IsPopOrder</span><span class="hljs-params">(self, pushV, popV)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        flag = <span class="hljs-keyword">False</span>
        pushV.reverse()
        popV.reverse()
        <span class="hljs-keyword">while</span> len(pushV)><span class="hljs-number">0</span>:
            self.stackT.append(pushV.pop())
            <span class="hljs-keyword">while</span> (len(self.stackT)><span class="hljs-number">0</span>) <span class="hljs-keyword">and</span> (len(popV)><span class="hljs-number">0</span>) <span class="hljs-keyword">and</span> (self.stackT[-<span class="hljs-number">1</span>] == popV[-<span class="hljs-number">1</span>]):
                self.stackT.pop()
                popV.pop()
        <span class="hljs-keyword">if</span> len(self.stackT) == <span class="hljs-number">0</span>:
            flag = <span class="hljs-keyword">True</span>
        <span class="hljs-keyword">return</span> flag             </code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li></ul>

从上往下打印二叉树

<code class="language-python hljs  has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-comment"># class TreeNode:</span>
<span class="hljs-comment">#     def __init__(self, x):</span>
<span class="hljs-comment">#         self.val = x</span>
<span class="hljs-comment">#         self.left = None</span>
<span class="hljs-comment">#         self.right = None</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-comment"># 返回从上到下每个节点值列表，例：[1,2,3]</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params">(self)</span>:</span>
        self.queue = []
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">PrintFromTopToBottom</span><span class="hljs-params">(self, root)</span>:</span>
        <span class="hljs-comment"># write code here</span>
        result = []
        <span class="hljs-keyword">if</span> <span class="hljs-keyword">not</span> root:
            <span class="hljs-keyword">return</span> []
        self.queue.append(root)
        <span class="hljs-keyword">while</span> len(self.queue) > <span class="hljs-number">0</span>:
            <span class="hljs-comment">#print self.queue[0]</span>
            tmpNode = self.queue[<span class="hljs-number">0</span>]
            result.append(tmpNode.val)
            <span class="hljs-keyword">if</span> tmpNode.left:
                self.queue.append(tmpNode.left)
            <span class="hljs-keyword">if</span> tmpNode.right:
                self.queue.append(tmpNode.right)
            self.queue.remove(self.queue[<span class="hljs-number">0</span>])
        <span class="hljs-keyword">return</span> result</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li><li>25</li><li>26</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li><li>25</li><li>26</li></ul>

二叉搜索树的后序遍历序列

<code class="language-python hljs  has-numbering"><span class="hljs-comment"># -*- coding:utf-8 -*-</span>
<span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">Solution</span>:</span>
    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">VerifySquenceOfBST</span><span class="hljs-params">(self, sequence)</span>:</span>
        <span class="hljs-keyword">if</span> <span class="hljs-keyword">not</span> sequence:
            <span class="hljs-keyword">return</span> <span class="hljs-keyword">False</span>
        length = len(sequence)
        <span class="hljs-keyword">if</span> length<=<span class="hljs-number">0</span>:
            <span class="hljs-keyword">return</span> <span class="hljs-keyword">False</span>
        rootValue = sequence[length-<span class="hljs-number">1</span>]
        i = <span class="hljs-number">0</span>
        <span class="hljs-keyword">for</span> ii <span class="hljs-keyword">in</span> range(length-<span class="hljs-number">1</span>):
            <span class="hljs-keyword">if</span> sequence[i] > rootValue:
                <span class="hljs-keyword">break</span>
            i = i+<span class="hljs-number">1</span>
        <span class="hljs-keyword">for</span> j <span class="hljs-keyword">in</span> range(i, length-<span class="hljs-number">1</span>):
            <span class="hljs-keyword">if</span> sequence[j] < rootValue:
                <span class="hljs-keyword">return</span> <span class="hljs-keyword">False</span>
        leftFlag = <span class="hljs-keyword">True</span>
        <span class="hljs-keyword">if</span> i > <span class="hljs-number">0</span>:
            leftFlag = self.VerifySquenceOfBST(sequence[:i])
        rightFlag = <span class="hljs-keyword">True</span>
        <span class="hljs-keyword">if</span> i < length-<span class="hljs-number">1</span>:
            rightFlag = self.VerifySquenceOfBST(sequence[i:length-<span class="hljs-number">1</span>])
        <span class="hljs-keyword">return</span> leftFlag <span class="hljs-keyword">and</span> rightFlag</code><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li></ul><ul style="" class="pre-numbering"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li></ul>

<code class="language-python hljs  has-numbering"></code><ul style="" class="pre-numbering"><li>1</li></ul><ul style="" class="pre-numbering"><li>1</li></ul>

  • 第一种方法：
<code class="language-python hljs  has-numbering"></code><ul style="" class="pre-numbering"><li>1</li></ul><ul style="" class="pre-numbering"><li>1</li></ul>
  • 第二种方法：
<code class="language-python hljs  has-numbering"></code><ul style="" class="pre-numbering"><li>1</li></ul><ul style="" class="pre-numbering"><li>1</li></ul>

(持续更新中……)

haoji007
关注
专栏目录
剑指offer python
qq_37591364的博客
03-26 687
1、大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。 n&amp;lt;=39 class Solution: def Fibonacci(self, n): if n == 0: return 0 if n == 1: return 1 a = 0...
剑指offer——Python解
weixin_52728982的博客
04-28 1135
JZ4 二维数组中的查找 描述 在一个二维数组array中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 [[1,2,8,9], [2,4,9,12], [4,7,10,13], [6,8,11,15]] 给定 target = 7，返回 true。 给定 target = 3，返回 false。 数据范围：矩阵的长宽满足0 \le n,m \le 5000≤n,m.
剑指offer答案python_剑指 Offer - python 题解
weixin_40008339的博客
11-22 131
断断续续刷完了牛客网上的剑指 Offer 题目，也随着整理了所有题目的解答方案，python 写的。目录如下：第1篇| 数组 | 二维数组中的查找第2篇| 字符串 | 替换空格| 链表 | 从尾到头打印链表第3篇| 树 | 重建二叉树| 栈和队列 | 用两个栈实现队列| 查找和排序 | 旋转数组的最小数字第4篇| 递归和循环 | 斐波那契数列| 递归和循环 | 跳台阶| 递归和循环...
链表中倒数第k个节点
weixin_43790623的博客
05-26 179
输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有6个节点，从头节点开始，它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof 示例： 给定一个链表: 1->2->3->4->5, 和
《剑指offer》详解-Python
热门推荐
林夕
04-25 2万+
问题3：二维数组中的查找 Q: 在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 A1：遍历整个二维数组，O(n2)O(n^2)O(n2) A2: 从左上或者右下开始查找。从右上开始查找：如果数组中的数比这个整数大，向左移动一位，如果数组中的数比这个数小，...
剑指offer答案（python版）3~28题
不忘初心~
03-17 2121
3.二维数组中的查找 4.替换空格 5.从尾到头打印链表 6.重建二叉树 7.两个栈实现队列 8.旋转数组中最小数 9.斐波那契数列问题： 9.1 斐波那契数列 9.2 青蛙跳台阶： 9.3 变态青蛙跳台阶问题： 9.4 矩形覆盖： 10. 求二进制中1的个数 11.数值的整数次方 14.调整数组顺序使得奇数位与偶数前面 15 链表中倒数第k个结点： 16.反转链表 17.合并两个排序的链...
Leetcode、剑指Offer——名企面试官精讲典型编程题.zip
最新发布
02-04
《LeetCode与剑指Offer——名企面试官精讲典型编程题》是一个针对程序员面试准备的重要资源包。它包含了来自LeetCode平台以及《剑指Offer》书籍中的经典编程题目，这些题目广泛应用于各大知名企业的面试过程中，是...
剑指offer66道练习题汇总——python版（持续更新）
csdn950212的博客
11-26 1023
目录 1.二维数组的查找（数组） 2.替换空格（字符串） 3.从尾到头打印链表（链表） 4.重建二叉树（树） 5.二叉树镜像（树） 6.用两个栈实现队列（栈和队列） 7.斐波那契数列（递归和循环） 8.旋转数组的最小数字（查找和排序） 9.跳台阶（递归与循环） 10.变态跳台阶（递归和循环） 11.单、双链表反转 12.矩形覆盖（递归和循环） 13.链表中倒数第k个节点 ...
《剑指Offer》刷题笔记——面试题60. n给骰子的点数
01-20
1、剑指解析 2、代码实现 class Solution: def twoSum(self, n: int) -> List[float]: if n==1: s = 6**1 return [round(1/s,5) for i in range(6)] def func(n:int): if n==1: #递归终止条件 return {key:1...
剑指offer——链表
happy_Jianghui的博客
06-19 262
链表算法
剑指offer 66编程题Python
09-04
每个编程题包括：题目描述，解析，Python代码实现三部分。
牛客网剑指offer(Python版)
hitzijiyingcai的博客
06-03 5521
目录 第一题:二维数组中的查找 第二题:替换空格 第三题:从头到尾打印链表 第四题:重建二叉树 第五题：用两个栈来实现一个队列 第六题：旋转数组的最小数字 第七题：斐波那契数列 第一题:二维数组中的查找 解题思路:从左下角元素往上查找，右边元素是比这个元素大，上边是的元素比这个元素小。于是，target比这个元素小就往上找，比这个元素大就往右找。如果出了边界，则说明二...
剑指offer——python版
Xiao__Bei的博客
09-08 915
python刷题记录
剑指Offer Python版
qq_16531797的博客
03-18 793
第2章 面试需要的基础知识 面试题1：赋值运算符函数 面试题2：实现Singleton模式 面试题3：数组中重复的数字 面试题4：二维数组中的查找 面试题5：替换空格 面试题6：从尾到头打印链表 面试题7：重建二叉树 面试题8：二叉树的下一个节点 面试题9：用两个栈实现队列 面试题10：斐波那切数列 面试题11：旋转数组的最小数字 面试题12：矩阵中的路径 面试题13：机器人的运动范围 面试题14...
剑指offer Python①
Understand-image
02-23 773
在写代码的路上积少成多，现在都是最笨的方法实现要求，一点一点改进。 1. 替换空格 请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。 分析： ①使用replace() # -*- coding:utf-8 -*- class Solution: # s 源字符串 def r...
剑指offer2.0（python版）
weixin_45243826的博客
02-15 337
剑指offer2.0（python版）
剑指Offer_Python实现
Datawhale
08-27 1659
基于python的《剑指offer》 剑指Offer-Python答案 剑指Offer-面试题的Python实现 Python基础算法/剑指offer
剑指offer全书题解 (Python)【更新完毕】
Cowry
08-17 4019
文章目录2 实现 Singleton 模式3 找出数组中重复的数字3.2 不修改数组找出重复的数字4 二维数组中的查找5 替换空格6 从尾到头打印链表7 重建二叉树8 二叉树的下一个节点9 用两个栈实现队列9.1 用两个队列实现一个栈10 斐波那契数列另外一种解法：矩阵乘法+快速幂10.2 青蛙跳台阶10.3 青蛙变态跳台阶10.4 矩形覆盖问题11 旋转数组的最小数字二分法12 矩阵中的路径1...
剑指Offer-Python实现：数组问题精讲
这里我们将详细讨论几个在《剑指Offer》Python版数组篇中的问题。 1. **二维数组中的查找**： 这个问题要求在一个特定排列规则的二维数组中寻找一个目标整数。数组的每一行都是从左到右递增排序，每一列是从上到下...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值