From 002c2e20e0bcf16ff5416a28aadab0237f5a6a19 Mon Sep 17 00:00:00 2001 From: Einstellung Date: Sat, 4 May 2019 13:32:22 +0800 Subject: [PATCH 01/18] =?UTF-8?q?=E6=9B=B4=E6=94=B9=E9=9D=A2=E8=AF=95?= =?UTF-8?q?=E9=A2=985=20=E6=9B=BF=E6=8D=A2=E7=A9=BA=E6=A0=BC=E7=AE=97?= =?UTF-8?q?=E6=B3=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...77\346\215\242\347\251\272\346\240\274.py" | 36 +++++++++++-------- 1 file changed, 21 insertions(+), 15 deletions(-) diff --git "a/Target Offer/\346\233\277\346\215\242\347\251\272\346\240\274.py" "b/Target Offer/\346\233\277\346\215\242\347\251\272\346\240\274.py" index bd15a41..e7429ae 100644 --- "a/Target Offer/\346\233\277\346\215\242\347\251\272\346\240\274.py" +++ "b/Target Offer/\346\233\277\346\215\242\347\251\272\346\240\274.py" @@ -40,29 +40,35 @@ def replaceSpace2(self, s): return return s.replace(' ', '%20') - # 书中给的思路 + # 书中给的思路，在原有字符串中替换，不许增加新的字符串 # 判断输入类型的时候，isinstance必须首先判断，因为如果输入为integer的话，没有len，就会直接报错 def replaceSpace3(self, s): - if not isinstance(s,str) or len(s) <= 0 or s == None: - return "" + if not isinstance(s, str) or len(s) <= 0 or s == 0: + return "出错了" + spaceNum = 0 for i in s: if i == " ": spaceNum += 1 + + IndexOfOriginal = len(s) - 1 + print(IndexOfOriginal) - newStrLen = len(s) + spaceNum * 2 - newStr = newStrLen * [None] - indexOfOriginal, indexOfNew = len(s) - 1, newStrLen - 1 - while indexOfNew >= 0 and indexOfNew >= indexOfOriginal: - if s[indexOfOriginal] == ' ': - newStr[indexOfNew-2:indexOfNew+1] = ['%', '2', '0'] - indexOfNew -= 3 - indexOfOriginal -= 1 + s = list(s) + spaceNum*2*[None] #替换空格增加三个元素，减少一个元素，实际上增加的是2个元素 + IndexOfNew = len(s) - 1 + + while IndexOfOriginal >=0 and IndexOfNew > IndexOfOriginal: + if s[IndexOfOriginal] == " ": + s[IndexOfNew - 2:IndexOfNew + 1] = ["%", "2", "0"] #因为是左闭右开，所以这里要有一个加1 + + IndexOfNew -=3 + else: - newStr[indexOfNew] = s[indexOfOriginal] - indexOfNew -= 1 - indexOfOriginal -= 1 - return "".join(newStr) + s[IndexOfNew] = s[IndexOfOriginal] + IndexOfNew -= 1 + IndexOfOriginal -= 1 + s = str(s) + return "".join(s) s = 'we are happy' From 34c193c1fe03eccfa51888b2c5f356468b3b9a1d Mon Sep 17 00:00:00 2001 From: Xin YuanHuang Date: Sat, 4 May 2019 21:41:02 +0800 Subject: [PATCH 02/18] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E9=9D=A2=E8=AF=95?= =?UTF-8?q?=E9=A2=984=E6=8C=87=E5=90=91=E7=9A=84URL?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index f0cafe6..1ca1ec8 100644 --- a/README.md +++ b/README.md @@ -69,7 +69,7 @@ [面试题3：二维数组中的查找](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E4%BA%8C%E7%BB%B4%E6%95%B0%E7%BB%84%E6%9F%A5%E6%89%BE.py)：对于在一个每一行从左到右依次递增，每一列从上到下依次递增的二维数组查找一个元素，可以选择从数组左上角开始查找array[i]\[j]，如果目标元素大于array[i]\[j]，i+=1，如果元素小于array[i]\[j]，j-=1，依次循环直至找到这个数。 -[面试题4：替换空格](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E6%9B%BF%E6%8D%A2%E7%A9%BA%E6%A0%BC.py)：如果直接每次遇到空格添加'%20'，那么空格后面的数字就需要频繁向后移动。遇到这种移动问题，我们可以尝试先给出最终需要的长度，然后从后向前扫描，同时给定两个指针来保证定位。**逆向思维** +[面试题4：替换空格](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target Offer/替换空格.py)：如果直接每次遇到空格添加'%20'，那么空格后面的数字就需要频繁向后移动。遇到这种移动问题，我们可以尝试先给出最终需要的长度，然后从后向前扫描，同时给定两个指针来保证定位。**逆向思维** [面试题5：从头到尾打印链表](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E5%8F%8D%E5%90%91%E6%89%93%E5%8D%B0%E9%93%BE%E8%A1%A8.py)：从头到尾遍历链表，并用一个栈存储每个结点的值，之后出栈输出值即可。 From a72bd74834973942855410bd702d8c42d0b0177a Mon Sep 17 00:00:00 2001 From: Xin YuanHuang Date: Sat, 4 May 2019 21:44:19 +0800 Subject: [PATCH 03/18] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 1ca1ec8..b973325 100644 --- a/README.md +++ b/README.md @@ -69,7 +69,7 @@ [面试题3：二维数组中的查找](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E4%BA%8C%E7%BB%B4%E6%95%B0%E7%BB%84%E6%9F%A5%E6%89%BE.py)：对于在一个每一行从左到右依次递增，每一列从上到下依次递增的二维数组查找一个元素，可以选择从数组左上角开始查找array[i]\[j]，如果目标元素大于array[i]\[j]，i+=1，如果元素小于array[i]\[j]，j-=1，依次循环直至找到这个数。 -[面试题4：替换空格](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target Offer/替换空格.py)：如果直接每次遇到空格添加'%20'，那么空格后面的数字就需要频繁向后移动。遇到这种移动问题，我们可以尝试先给出最终需要的长度，然后从后向前扫描，同时给定两个指针来保证定位。**逆向思维** +[面试题4：替换空格](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target%20Offer/%E6%9B%BF%E6%8D%A2%E7%A9%BA%E6%A0%BC.py)：如果直接每次遇到空格添加'%20'，那么空格后面的数字就需要频繁向后移动。遇到这种移动问题，我们可以尝试先给出最终需要的长度，然后从后向前扫描，同时给定两个指针来保证定位。**逆向思维** [面试题5：从头到尾打印链表](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E5%8F%8D%E5%90%91%E6%89%93%E5%8D%B0%E9%93%BE%E8%A1%A8.py)：从头到尾遍历链表，并用一个栈存储每个结点的值，之后出栈输出值即可。 From 2743c345d42f80affccf21e6d260150306c8df69 Mon Sep 17 00:00:00 2001 From: Einstellung Date: Sun, 5 May 2019 08:36:37 +0800 Subject: [PATCH 04/18] =?UTF-8?q?=E5=A2=9E=E5=8A=A0=E9=80=92=E5=BD=92?= =?UTF-8?q?=E8=B0=83=E7=94=A8=E5=AE=9E=E7=8E=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...1\346\211\223\345\215\260\351\223\276\350\241\250.py" | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git "a/Target Offer/\345\217\215\345\220\221\346\211\223\345\215\260\351\223\276\350\241\250.py" "b/Target Offer/\345\217\215\345\220\221\346\211\223\345\215\260\351\223\276\350\241\250.py" index ad0a21d..8b10b7a 100644 --- "a/Target Offer/\345\217\215\345\220\221\346\211\223\345\215\260\351\223\276\350\241\250.py" +++ "b/Target Offer/\345\217\215\345\220\221\346\211\223\345\215\260\351\223\276\350\241\250.py" @@ -17,6 +17,15 @@ def printListFromTailToHead(self, listNode): head = head.next return l +# 添加使用递归调用的方法，堆栈和递归是一样的 + def recursive(self, listNode): + if listNode.val != None: + if listNode.next != None: + self.recursive(listNode.next) + + print(listNode.val) + + node1 = ListNode(10) node2 = ListNode(11) node3 = ListNode(13) From a65850e8b7d0d1a9d13435ac05ae28c6d2a45f8c Mon Sep 17 00:00:00 2001 From: Xin YuanHuang Date: Sun, 5 May 2019 16:41:25 +0800 Subject: [PATCH 05/18] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E9=9D=A2=E8=AF=95?= =?UTF-8?q?=E9=A2=985=E6=8C=87=E5=90=91=E9=93=BE=E6=8E=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index b973325..e58727f 100644 --- a/README.md +++ b/README.md @@ -71,7 +71,7 @@ [面试题4：替换空格](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target%20Offer/%E6%9B%BF%E6%8D%A2%E7%A9%BA%E6%A0%BC.py)：如果直接每次遇到空格添加'%20'，那么空格后面的数字就需要频繁向后移动。遇到这种移动问题，我们可以尝试先给出最终需要的长度，然后从后向前扫描，同时给定两个指针来保证定位。**逆向思维** -[面试题5：从头到尾打印链表](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E5%8F%8D%E5%90%91%E6%89%93%E5%8D%B0%E9%93%BE%E8%A1%A8.py)：从头到尾遍历链表，并用一个栈存储每个结点的值，之后出栈输出值即可。 +[面试题5：从头到尾打印链表](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target%20Offer/%E5%8F%8D%E5%90%91%E6%89%93%E5%8D%B0%E9%93%BE%E8%A1%A8.py)：从头到尾遍历链表，并用一个栈存储每个结点的值，之后出栈输出值即可。 [面试题6：重建二叉树](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E9%87%8D%E5%BB%BA%E4%BA%8C%E5%8F%89%E6%A0%91.py)：利用二叉树前序遍历和中序遍历的特性。前序遍历的第一个值一定为根节点，对应于中序遍历中间的一个点。在中序遍历序列中，这个点左侧的均为根的左子树，这个点右侧的均为根的右子树。这时可以利用递归，分别取前序遍历[1:i+1]和中序遍历的[:i]对应与左子树继续上一个过程，取前序遍历[i+1:]和中序遍历[i+1]对应于右子树继续上一个过程，最终得以重建二叉树。 From 7df60c9b1e01ea96d02dbe4978baf06189442ad1 Mon Sep 17 00:00:00 2001 From: Xin YuanHuang Date: Mon, 6 May 2019 11:42:05 +0800 Subject: [PATCH 06/18] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E6=96=B0=E9=A2=98?= =?UTF-8?q?=E6=9B=B4=E6=94=B9=E4=B8=80=E4=B8=8B=E6=8E=92=E5=BA=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index e58727f..b32cdd2 100644 --- a/README.md +++ b/README.md @@ -67,15 +67,15 @@ [面试题2：实现Singleton模式](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/Singleton.py) -[面试题3：二维数组中的查找](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E4%BA%8C%E7%BB%B4%E6%95%B0%E7%BB%84%E6%9F%A5%E6%89%BE.py)：对于在一个每一行从左到右依次递增，每一列从上到下依次递增的二维数组查找一个元素，可以选择从数组左上角开始查找array[i]\[j]，如果目标元素大于array[i]\[j]，i+=1，如果元素小于array[i]\[j]，j-=1，依次循环直至找到这个数。 +[面试题4：二维数组中的查找](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E4%BA%8C%E7%BB%B4%E6%95%B0%E7%BB%84%E6%9F%A5%E6%89%BE.py)：对于在一个每一行从左到右依次递增，每一列从上到下依次递增的二维数组查找一个元素，可以选择从数组左上角开始查找array[i]\[j]，如果目标元素大于array[i]\[j]，i+=1，如果元素小于array[i]\[j]，j-=1，依次循环直至找到这个数。 -[面试题4：替换空格](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target%20Offer/%E6%9B%BF%E6%8D%A2%E7%A9%BA%E6%A0%BC.py)：如果直接每次遇到空格添加'%20'，那么空格后面的数字就需要频繁向后移动。遇到这种移动问题，我们可以尝试先给出最终需要的长度，然后从后向前扫描，同时给定两个指针来保证定位。**逆向思维** +[面试题5：替换空格](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target%20Offer/%E6%9B%BF%E6%8D%A2%E7%A9%BA%E6%A0%BC.py)：如果直接每次遇到空格添加'%20'，那么空格后面的数字就需要频繁向后移动。遇到这种移动问题，我们可以尝试先给出最终需要的长度，然后从后向前扫描，同时给定两个指针来保证定位。**逆向思维** -[面试题5：从头到尾打印链表](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target%20Offer/%E5%8F%8D%E5%90%91%E6%89%93%E5%8D%B0%E9%93%BE%E8%A1%A8.py)：从头到尾遍历链表，并用一个栈存储每个结点的值，之后出栈输出值即可。 +[面试题6：从头到尾打印链表](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target%20Offer/%E5%8F%8D%E5%90%91%E6%89%93%E5%8D%B0%E9%93%BE%E8%A1%A8.py)：从头到尾遍历链表，并用一个栈存储每个结点的值，之后出栈输出值即可。 -[面试题6：重建二叉树](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E9%87%8D%E5%BB%BA%E4%BA%8C%E5%8F%89%E6%A0%91.py)：利用二叉树前序遍历和中序遍历的特性。前序遍历的第一个值一定为根节点，对应于中序遍历中间的一个点。在中序遍历序列中，这个点左侧的均为根的左子树，这个点右侧的均为根的右子树。这时可以利用递归，分别取前序遍历[1:i+1]和中序遍历的[:i]对应与左子树继续上一个过程，取前序遍历[i+1:]和中序遍历[i+1]对应于右子树继续上一个过程，最终得以重建二叉树。 +[面试题7：重建二叉树](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E9%87%8D%E5%BB%BA%E4%BA%8C%E5%8F%89%E6%A0%91.py)：利用二叉树前序遍历和中序遍历的特性。前序遍历的第一个值一定为根节点，对应于中序遍历中间的一个点。在中序遍历序列中，这个点左侧的均为根的左子树，这个点右侧的均为根的右子树。这时可以利用递归，分别取前序遍历[1:i+1]和中序遍历的[:i]对应与左子树继续上一个过程，取前序遍历[i+1:]和中序遍历[i+1]对应于右子树继续上一个过程，最终得以重建二叉树。 -[面试题7：用两个栈实现队列](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E7%94%A8%E4%B8%A4%E4%B8%AA%E6%A0%88%E5%AE%9E%E7%8E%B0%E9%98%9F%E5%88%97.py)：需要两个栈Stack1和Stack2，push的时候直接push进Stack1。pop需要判断Stack1和Stack2中元素的情况，Stack1空的话，直接从Stack2 pop，Stack1不空的话，把Stack1的元素push进入Stack2，然后pop Stack2的值。[推广：用两个队列实现栈](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E7%94%A8%E4%B8%A4%E4%B8%AA%E9%98%9F%E5%88%97%E5%AE%9E%E7%8E%B0%E6%A0%88.py) +[面试题9：用两个栈实现队列](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E7%94%A8%E4%B8%A4%E4%B8%AA%E6%A0%88%E5%AE%9E%E7%8E%B0%E9%98%9F%E5%88%97.py)：需要两个栈Stack1和Stack2，push的时候直接push进Stack1。pop需要判断Stack1和Stack2中元素的情况，Stack1空的话，直接从Stack2 pop，Stack1不空的话，把Stack1的元素push进入Stack2，然后pop Stack2的值。[推广：用两个队列实现栈](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E7%94%A8%E4%B8%A4%E4%B8%AA%E9%98%9F%E5%88%97%E5%AE%9E%E7%8E%B0%E6%A0%88.py) [面试题8：旋转数组的最小数字](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E6%97%8B%E8%BD%AC%E6%95%B0%E7%BB%84%E7%9A%84%E6%9C%80%E5%B0%8F%E6%95%B0%E5%AD%97.py)：二分查找的变形，注意到旋转数组的首元素肯定不小于旋转数组的尾元素，设置中间点。如果中间点大于首元素，说明最小数字在后面一半，如果中间点小于尾元素，说明最小数字在前一半。依次循环。同时，当一次循环中首元素小于尾元素，说明最小值就是首元素。但是当首元素等于尾元素等于中间值，只能在这个区域顺序查找。 From 7a518a983d2113916158cee0dee06ab679b9dea6 Mon Sep 17 00:00:00 2001 From: Einstellung Date: Mon, 6 May 2019 11:07:35 +0800 Subject: [PATCH 07/18] =?UTF-8?q?=E6=9B=B4=E6=94=B9=E4=BA=8C=E5=8F=89?= =?UTF-8?q?=E6=A0=91=E4=B8=8B=E4=B8=80=E4=B8=AA=E8=8A=82=E7=82=B9=E4=BB=A3?= =?UTF-8?q?=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...00\344\270\252\347\273\223\347\202\271.py" | 35 +++++++++---------- 1 file changed, 17 insertions(+), 18 deletions(-) diff --git "a/Target Offer/\344\272\214\345\217\211\346\240\221\347\232\204\344\270\213\344\270\200\344\270\252\347\273\223\347\202\271.py" "b/Target Offer/\344\272\214\345\217\211\346\240\221\347\232\204\344\270\213\344\270\200\344\270\252\347\273\223\347\202\271.py" index 83c58c4..2d80777 100644 --- "a/Target Offer/\344\272\214\345\217\211\346\240\221\347\232\204\344\270\213\344\270\200\344\270\252\347\273\223\347\202\271.py" +++ "b/Target Offer/\344\272\214\345\217\211\346\240\221\347\232\204\344\270\213\344\270\200\344\270\252\347\273\223\347\202\271.py" @@ -8,25 +8,24 @@ def __init__(self, x): self.val = x self.left = None self.right = None - self.next = None + self.father = None #指向父节点的指针 class Solution: - def GetNext(self, pNode): - if pNode == None: - return - pNext = None - if pNode.right != None: - pRight = pNode.right - while pRight.left != None: - pRight = pRight.left - pNext= pRight - elif pNode.next != None: - pCurrent = pNode - pParent = pCurrent.next - while pParent != None and pCurrent == pParent.right: - pCurrent = pParent - pParent = pCurrent.next - pNext = pParent - return pNext + def GetNext(self, nNode): + if not nNode: + return None + + if nNode.right: #如果有右子树 + while nNode.left: + nNode = nNode.left + return nNode + + else: # 如果没有右子树 + while nNode.father: # 不停地去找父节点的左子节点是该节点的情况 + if nNode == nNode.father.left: + return nNode.father + nNode = nNode.father + + return None #都不满足情况，最后返回为空，是中序遍历的结尾 class Solution2: def GetNext(self, pNode): From 4c8aef514ceaa9de44669de4693797db5b3b589f Mon Sep 17 00:00:00 2001 From: Xin YuanHuang Date: Mon, 6 May 2019 19:11:29 +0800 Subject: [PATCH 08/18] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E7=AC=AC=E5=85=AB?= =?UTF-8?q?=E9=A2=98=E4=BB=A3=E7=A0=81=E7=B4=A2=E5=BC=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index b32cdd2..e2cc19b 100644 --- a/README.md +++ b/README.md @@ -75,6 +75,8 @@ [面试题7：重建二叉树](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E9%87%8D%E5%BB%BA%E4%BA%8C%E5%8F%89%E6%A0%91.py)：利用二叉树前序遍历和中序遍历的特性。前序遍历的第一个值一定为根节点，对应于中序遍历中间的一个点。在中序遍历序列中，这个点左侧的均为根的左子树，这个点右侧的均为根的右子树。这时可以利用递归，分别取前序遍历[1:i+1]和中序遍历的[:i]对应与左子树继续上一个过程，取前序遍历[i+1:]和中序遍历[i+1]对应于右子树继续上一个过程，最终得以重建二叉树。 +[面试题8：二叉树的下一个结点](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target%20Offer/%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E4%B8%8B%E4%B8%80%E4%B8%AA%E7%BB%93%E7%82%B9.py)：三种情况：当前节点有右子树的话，当前节点的下一个结点是右子树中的最左子节点；当前节点无右子树但是是父节点的左子节点，下一个节点是当前结点的父节点；当前节点无右子树而且是父节点的右子节点，则一直向上遍历，直到找到最靠近的一个祖先节点pNode，pNode是其父节点的左子节点，那么输入节点的下一个结点就是pNode的父节点。 + [面试题9：用两个栈实现队列](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E7%94%A8%E4%B8%A4%E4%B8%AA%E6%A0%88%E5%AE%9E%E7%8E%B0%E9%98%9F%E5%88%97.py)：需要两个栈Stack1和Stack2，push的时候直接push进Stack1。pop需要判断Stack1和Stack2中元素的情况，Stack1空的话，直接从Stack2 pop，Stack1不空的话，把Stack1的元素push进入Stack2，然后pop Stack2的值。[推广：用两个队列实现栈](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E7%94%A8%E4%B8%A4%E4%B8%AA%E9%98%9F%E5%88%97%E5%AE%9E%E7%8E%B0%E6%A0%88.py) [面试题8：旋转数组的最小数字](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E6%97%8B%E8%BD%AC%E6%95%B0%E7%BB%84%E7%9A%84%E6%9C%80%E5%B0%8F%E6%95%B0%E5%AD%97.py)：二分查找的变形，注意到旋转数组的首元素肯定不小于旋转数组的尾元素，设置中间点。如果中间点大于首元素，说明最小数字在后面一半，如果中间点小于尾元素，说明最小数字在前一半。依次循环。同时，当一次循环中首元素小于尾元素，说明最小值就是首元素。但是当首元素等于尾元素等于中间值，只能在这个区域顺序查找。 @@ -183,8 +185,6 @@ [面试题57：删除链表中重复的结点](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E5%88%A0%E9%99%A4%E9%93%BE%E8%A1%A8%E4%B8%AD%E9%87%8D%E5%A4%8D%E7%9A%84%E7%BB%93%E7%82%B9.py)：我们需要设置一个指针preNode，preNode最开始为None，然后设置两个指针，pNode指向当前节点，pNext指向pNode下一个结点，⓵如果pNext不为空而且pNext的值等于pNode的值，那么就说明出现了重复数字的结点，就需要删除，然后从pNode开始遍历，如果结点值等于前面那个重复值，继续遍历。当遍历到None或者不同值结点的时候，这时候需要判断preNode结点，如果preNode结点为None，就说明我们刚才的重复结点是从整个链表的头结点开始重复的，就直接把pHead设置为当前结点，pNode也设置为当前结点。反之，如果preNode不为None，直接把preNode的下一个指针指向当前节点，pNode指向preNode即可；⓶如果pNext为空或者pNext的值不等于pNode的值，说明当前的这个pNode和后面的值不重复，直接令preNode = pNode，pNode指向下一个结点即可。 -[面试题58：二叉树的下一个结点](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E4%B8%8B%E4%B8%80%E4%B8%AA%E7%BB%93%E7%82%B9.py)：三种情况：当前节点有右子树的话，当前节点的下一个结点是右子树中的最左子节点；当前节点无右子树但是是父节点的左子节点，下一个节点是当前结点的父节点；当前节点无右子树而且是父节点的右子节点，则一直向上遍历，直到找到最靠近的一个祖先节点pNode，pNode是其父节点的左子节点，那么输入节点的下一个结点就是pNode的父节点。 - [面试题59：对称的二叉树](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E5%AF%B9%E7%A7%B0%E7%9A%84%E4%BA%8C%E5%8F%89%E6%A0%91.py)：分为递归和非递归的两种方式，思想是一样的。主要就是把叶子节点的None节点也加入到遍历当中。按照前序遍历二叉树，存入一个序列中。然后按照和前序遍历对应的先父节点，然后右子节点，最后左子节点遍历二叉树，存入一个序列。如果前后两个序列相等，那么说明二叉树是对称的。 [面试题60：把二叉树打印成多行](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E6%8A%8A%E4%BA%8C%E5%8F%89%E6%A0%91%E6%89%93%E5%8D%B0%E6%88%90%E5%A4%9A%E8%A1%8C.py)：引入两个队列。首先把当前层的节点存入到一个队列queue1中，然后遍历当前队列queue1，在遍历的过程中，如果节点有左子树或右子树，依次存入另一个队列queue2。然后遍历队列queue2，如此往复。 From 5ef63c69aa79ed8a4ec9f0969f9c456f27131869 Mon Sep 17 00:00:00 2001 From: Einstellung Date: Tue, 7 May 2019 03:10:31 +0800 Subject: [PATCH 09/18] =?UTF-8?q?=E6=9B=B4=E6=94=B9=E4=B8=A4=E4=B8=AA?= =?UTF-8?q?=E9=98=9F=E5=88=97=E5=AE=9E=E7=8E=B0=E6=A0=88=EF=BC=8C=E4=BB=A3?= =?UTF-8?q?=E7=A0=81=E6=9B=B4=E7=AE=80=E6=B4=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...27\345\256\236\347\216\260\346\240\210.py" | 32 +++++++++++-------- 1 file changed, 18 insertions(+), 14 deletions(-) diff --git "a/Target Offer/\347\224\250\344\270\244\344\270\252\351\230\237\345\210\227\345\256\236\347\216\260\346\240\210.py" "b/Target Offer/\347\224\250\344\270\244\344\270\252\351\230\237\345\210\227\345\256\236\347\216\260\346\240\210.py" index a46d001..843ca91 100644 --- "a/Target Offer/\347\224\250\344\270\244\344\270\252\351\230\237\345\210\227\345\256\236\347\216\260\346\240\210.py" +++ "b/Target Offer/\347\224\250\344\270\244\344\270\252\351\230\237\345\210\227\345\256\236\347\216\260\346\240\210.py" @@ -6,24 +6,28 @@ class Solution: def __init__(self): self.queue1 = [] self.queue2 = [] - def push(self, x): + + def push(self, nNode): if self.queue2 == []: - self.queue1.append(x) + self.queue1.append(nNode) else: - self.queue2.append(x) + self.queue2.append(nNode) + + # 如果队列1中有值，那么就把队列1中的值除最后一个外全部清空，只留下最后一个弹出 + # 同样的道理，队列1清空，队列2有值，那么弹出的时候，就把队列2中除最后一个元素外全部加入队列1，队列2最后一个元素弹出 def pop(self): - if not self.queue1 and not self.queue2: - return - if self.queue1 != []: - length = len(self.queue1) - for i in range(length-1): - self.queue2.append(self.queue1.pop(0)) - return self.queue1.pop() + if len(self.queue1) == 0 and len(self.queue2) == 0: + return else: - length = len(self.queue2) - for i in range(length-1): - self.queue1.append(self.queue2.pop(0)) - return self.queue2.pop() + if self.queue1 != []: + while len(self.queue1) > 1: + self.queue2.append(self.queue1.pop(0)) + return self.queue1.pop() + + else: + while(self.queue2) > 1: + self.queue1.append(self.queue2.pop(0)) + return self.queue2 P = Solution() P.push(10) From d3eeb41a03ee5f00717be4cbad8df83a2f606574 Mon Sep 17 00:00:00 2001 From: Xin YuanHuang Date: Tue, 7 May 2019 11:15:36 +0800 Subject: [PATCH 10/18] =?UTF-8?q?=E6=9B=B4=E6=94=B9=E4=B8=A4=E4=B8=AA?= =?UTF-8?q?=E9=98=9F=E5=88=97=E5=AE=9E=E7=8E=B0=E6=A0=88=E6=8C=87=E5=90=91?= =?UTF-8?q?=E9=93=BE=E6=8E=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index e2cc19b..b9b6db5 100644 --- a/README.md +++ b/README.md @@ -77,7 +77,7 @@ [面试题8：二叉树的下一个结点](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target%20Offer/%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E4%B8%8B%E4%B8%80%E4%B8%AA%E7%BB%93%E7%82%B9.py)：三种情况：当前节点有右子树的话，当前节点的下一个结点是右子树中的最左子节点；当前节点无右子树但是是父节点的左子节点，下一个节点是当前结点的父节点；当前节点无右子树而且是父节点的右子节点，则一直向上遍历，直到找到最靠近的一个祖先节点pNode，pNode是其父节点的左子节点，那么输入节点的下一个结点就是pNode的父节点。 -[面试题9：用两个栈实现队列](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E7%94%A8%E4%B8%A4%E4%B8%AA%E6%A0%88%E5%AE%9E%E7%8E%B0%E9%98%9F%E5%88%97.py)：需要两个栈Stack1和Stack2，push的时候直接push进Stack1。pop需要判断Stack1和Stack2中元素的情况，Stack1空的话，直接从Stack2 pop，Stack1不空的话，把Stack1的元素push进入Stack2，然后pop Stack2的值。[推广：用两个队列实现栈](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E7%94%A8%E4%B8%A4%E4%B8%AA%E9%98%9F%E5%88%97%E5%AE%9E%E7%8E%B0%E6%A0%88.py) +[面试题9：用两个栈实现队列](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E7%94%A8%E4%B8%A4%E4%B8%AA%E6%A0%88%E5%AE%9E%E7%8E%B0%E9%98%9F%E5%88%97.py)：需要两个栈Stack1和Stack2，push的时候直接push进Stack1。pop需要判断Stack1和Stack2中元素的情况，Stack1空的话，直接从Stack2 pop，Stack1不空的话，把Stack1的元素push进入Stack2，然后pop Stack2的值。[推广：用两个队列实现栈](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target%20Offer/%E7%94%A8%E4%B8%A4%E4%B8%AA%E9%98%9F%E5%88%97%E5%AE%9E%E7%8E%B0%E6%A0%88.py) [面试题8：旋转数组的最小数字](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E6%97%8B%E8%BD%AC%E6%95%B0%E7%BB%84%E7%9A%84%E6%9C%80%E5%B0%8F%E6%95%B0%E5%AD%97.py)：二分查找的变形，注意到旋转数组的首元素肯定不小于旋转数组的尾元素，设置中间点。如果中间点大于首元素，说明最小数字在后面一半，如果中间点小于尾元素，说明最小数字在前一半。依次循环。同时，当一次循环中首元素小于尾元素，说明最小值就是首元素。但是当首元素等于尾元素等于中间值，只能在这个区域顺序查找。 From 7f6ac1bc73b31305047bfb75028c4d3aa3bc60ec Mon Sep 17 00:00:00 2001 From: Einstellung Date: Tue, 7 May 2019 12:21:03 +0800 Subject: [PATCH 11/18] =?UTF-8?q?=E8=8F=B2=E6=B3=A2=E9=82=A3=E5=88=87?= =?UTF-8?q?=E6=95=B0=E5=88=97=E4=BB=A3=E7=A0=81=E8=B0=83=E6=95=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...31\350\267\263\345\217\260\351\230\266.py" | 20 +++++++++++++++++ ...43\345\245\221\346\225\260\345\210\227.py" | 22 +++---------------- ...31\350\267\263\345\217\260\351\230\266.py" | 22 +++++++++++++++++++ 3 files changed, 45 insertions(+), 19 deletions(-) create mode 100644 "Target Offer/\345\217\230\346\200\201\351\235\222\350\233\231\350\267\263\345\217\260\351\230\266.py" create mode 100644 "Target Offer/\351\235\222\350\233\231\350\267\263\345\217\260\351\230\266.py" diff --git "a/Target Offer/\345\217\230\346\200\201\351\235\222\350\233\231\350\267\263\345\217\260\351\230\266.py" "b/Target Offer/\345\217\230\346\200\201\351\235\222\350\233\231\350\267\263\345\217\260\351\230\266.py" new file mode 100644 index 0000000..ec9aa8c --- /dev/null +++ "b/Target Offer/\345\217\230\346\200\201\351\235\222\350\233\231\350\267\263\345\217\260\351\230\266.py" @@ -0,0 +1,20 @@ +''' +和青蛙跳台阶问题类似，再做出一定程度扩展。 + +一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。 + +这个问题写起来就很简单了，由数学归纳我们可以知道，一共有2^(n-1)种方案，所以就可以直接写代码 +''' + +class Solution: + def jumpFloor2(self, number): + if number == 0: + return 0 + + ans = 1 + if number == 1: + return 1 + else: + for i in range(1, number): + ans = 2*ans + return ans \ No newline at end of file diff --git "a/Target Offer/\346\226\220\346\263\242\351\202\243\345\245\221\346\225\260\345\210\227.py" "b/Target Offer/\346\226\220\346\263\242\351\202\243\345\245\221\346\225\260\345\210\227.py" index 1641cc1..c99c924 100644 --- "a/Target Offer/\346\226\220\346\263\242\351\202\243\345\245\221\346\225\260\345\210\227.py" +++ "b/Target Offer/\346\226\220\346\263\242\351\202\243\345\245\221\346\225\260\345\210\227.py" @@ -5,29 +5,13 @@ # -*- coding:utf-8 -*- class Solution: - def Fibonacci(self, n): + def fibonacci(self, n): tempArray = [0, 1] + if n >= 2: for i in range(2, n+1): tempArray[i%2] = tempArray[0] + tempArray[1] return tempArray[n%2] - # 青蛙跳台阶, 每次可以跳1级或2级 - def jumpFloor(self, number): - # write code here - tempArray = [1, 2] - if number >= 3: - for i in range(3, number + 1): - tempArray[(i + 1) % 2] = tempArray[0] + tempArray[1] - return tempArray[(number + 1) % 2] - - def jumpFloorII(self, number): - ans = 1 - if number >= 2: - for i in range(number-1): - ans = ans * 2 - return ans test = Solution() -print(test.Fibonacci(100)) -print(test.jumpFloor(3)) -print(test.jumpFloorII(2)) \ No newline at end of file +print(test.fibonacci(100)) diff --git "a/Target Offer/\351\235\222\350\233\231\350\267\263\345\217\260\351\230\266.py" "b/Target Offer/\351\235\222\350\233\231\350\267\263\345\217\260\351\230\266.py" new file mode 100644 index 0000000..68b31c6 --- /dev/null +++ "b/Target Offer/\351\235\222\350\233\231\350\267\263\345\217\260\351\230\266.py" @@ -0,0 +1,22 @@ +''' +一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。 +求该青蛙跳上一个n级的台阶总共有多少种跳法。 +''' + + +''' +这是一个斐波那契数列的变种，f(1) = 1; f(2) = 2; +f(n) = f(n-1) + f(n-2) +''' +class Solution: + def jumpFloor(self, number): + tempArray = [1, 2] + + if number >= 3: # number是从3开始迭代的 + for i in range(3, number + 1): + tempArray[(i + 1)% 2] = tempArray[0] + tempArray[1] # 3应当时更正tempArray的第一个位置，所以i+1 + return tempArray[(number + 1) %2] + + +test = Solution() +test.jumpFloor(100) \ No newline at end of file From 4128e5f3ec0adf3c9f265532ac753ba16ccab4f1 Mon Sep 17 00:00:00 2001 From: Xin YuanHuang Date: Tue, 7 May 2019 15:10:46 +0800 Subject: [PATCH 12/18] Update README.md --- README.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index b9b6db5..fdf9b47 100644 --- a/README.md +++ b/README.md @@ -79,9 +79,11 @@ [面试题9：用两个栈实现队列](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E7%94%A8%E4%B8%A4%E4%B8%AA%E6%A0%88%E5%AE%9E%E7%8E%B0%E9%98%9F%E5%88%97.py)：需要两个栈Stack1和Stack2，push的时候直接push进Stack1。pop需要判断Stack1和Stack2中元素的情况，Stack1空的话，直接从Stack2 pop，Stack1不空的话，把Stack1的元素push进入Stack2，然后pop Stack2的值。[推广：用两个队列实现栈](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target%20Offer/%E7%94%A8%E4%B8%A4%E4%B8%AA%E9%98%9F%E5%88%97%E5%AE%9E%E7%8E%B0%E6%A0%88.py) +[面试题10：斐波那契数列](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E6%96%90%E6%B3%A2%E9%82%A3%E5%A5%91%E6%95%B0%E5%88%97.py)：如何不使用递归实现斐波那契数列，需要把前面两个数字存入在一个数组中。斐波那契数列的变形有很多，如青蛙跳台阶，一次跳一个或者两个；铺瓷砖问题。**变态青蛙跳**，每次至少跳一个，至多跳n个，一共有f(n)=2n-1种跳法。考察数学建模的能力。 + [面试题8：旋转数组的最小数字](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E6%97%8B%E8%BD%AC%E6%95%B0%E7%BB%84%E7%9A%84%E6%9C%80%E5%B0%8F%E6%95%B0%E5%AD%97.py)：二分查找的变形，注意到旋转数组的首元素肯定不小于旋转数组的尾元素，设置中间点。如果中间点大于首元素，说明最小数字在后面一半，如果中间点小于尾元素，说明最小数字在前一半。依次循环。同时，当一次循环中首元素小于尾元素，说明最小值就是首元素。但是当首元素等于尾元素等于中间值，只能在这个区域顺序查找。 -[面试题9：斐波那契数列](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E6%96%90%E6%B3%A2%E9%82%A3%E5%A5%91%E6%95%B0%E5%88%97.py)：如何不使用递归实现斐波那契数列，需要把前面两个数字存入在一个数组中。斐波那契数列的变形有很多，如青蛙跳台阶，一次跳一个或者两个；铺瓷砖问题。**变态青蛙跳**，每次至少跳一个，至多跳n个，一共有f(n)=2n-1种跳法。考察数学建模的能力。 + [面试题10：二进制中1的个数](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E4%BA%8C%E8%BF%9B%E5%88%B6%E4%B8%AD1%E7%9A%84%E4%B8%AA%E6%95%B0.py)：注意到每个**非零**整数n和n-1进行按位与运算，整数n的二进制数中最右边的1就会变成0，那么二进制数中的1的个数就会减少一个，因此可以利用一个循环，使得 n = n&(n-1) ，计算经过几次运算减少到0，就是有几个1。注意：书中给了另外两种方法，分别是原始n左移一位和右移一位的方法，因为Python不会出现整数溢出的情况，这里就不再考虑着两种方法。扩展：判断一个数值是不是2得整数次方，如果是的话，这个数的二进制数中有且只有一个1，那么这个数n会有 n&(n-1) == 0。或者求两个整数m和n需要改变m二进制中的多少位才能得到n，可以先做 m^n 的异或运算，然后求这个数中有多少个1。 From 734b0d1171b8eaff1cad3a5e600c0da8811b48da Mon Sep 17 00:00:00 2001 From: Xin YuanHuang Date: Tue, 7 May 2019 20:25:27 +0800 Subject: [PATCH 13/18] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index fdf9b47..7b2ca29 100644 --- a/README.md +++ b/README.md @@ -79,7 +79,7 @@ [面试题9：用两个栈实现队列](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E7%94%A8%E4%B8%A4%E4%B8%AA%E6%A0%88%E5%AE%9E%E7%8E%B0%E9%98%9F%E5%88%97.py)：需要两个栈Stack1和Stack2，push的时候直接push进Stack1。pop需要判断Stack1和Stack2中元素的情况，Stack1空的话，直接从Stack2 pop，Stack1不空的话，把Stack1的元素push进入Stack2，然后pop Stack2的值。[推广：用两个队列实现栈](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target%20Offer/%E7%94%A8%E4%B8%A4%E4%B8%AA%E9%98%9F%E5%88%97%E5%AE%9E%E7%8E%B0%E6%A0%88.py) -[面试题10：斐波那契数列](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E6%96%90%E6%B3%A2%E9%82%A3%E5%A5%91%E6%95%B0%E5%88%97.py)：如何不使用递归实现斐波那契数列，需要把前面两个数字存入在一个数组中。斐波那契数列的变形有很多，如青蛙跳台阶，一次跳一个或者两个；铺瓷砖问题。**变态青蛙跳**，每次至少跳一个，至多跳n个，一共有f(n)=2n-1种跳法。考察数学建模的能力。 +[面试题10：斐波那契数列](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target%20Offer/%E6%96%90%E6%B3%A2%E9%82%A3%E5%A5%91%E6%95%B0%E5%88%97.py)：如何不使用递归实现斐波那契数列，需要把前面两个数字存入在一个数组中。斐波那契数列的变形有很多，如[青蛙跳台阶](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target%20Offer/%E9%9D%92%E8%9B%99%E8%B7%B3%E5%8F%B0%E9%98%B6.py)，一次跳一个或者两个；铺瓷砖问题。[**变态青蛙跳**](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target%20Offer/%E5%8F%98%E6%80%81%E9%9D%92%E8%9B%99%E8%B7%B3%E5%8F%B0%E9%98%B6.py)，每次至少跳一个，至多跳n个，一共有f(n)=2n-1种跳法。考察数学建模的能力。 [面试题8：旋转数组的最小数字](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E6%97%8B%E8%BD%AC%E6%95%B0%E7%BB%84%E7%9A%84%E6%9C%80%E5%B0%8F%E6%95%B0%E5%AD%97.py)：二分查找的变形，注意到旋转数组的首元素肯定不小于旋转数组的尾元素，设置中间点。如果中间点大于首元素，说明最小数字在后面一半，如果中间点小于尾元素，说明最小数字在前一半。依次循环。同时，当一次循环中首元素小于尾元素，说明最小值就是首元素。但是当首元素等于尾元素等于中间值，只能在这个区域顺序查找。 From 50edaf6a61dd0acfd5b4b27a94eaa3cbe4b489cb Mon Sep 17 00:00:00 2001 From: Xin YuanHuang Date: Thu, 9 May 2019 09:53:35 +0800 Subject: [PATCH 14/18] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E7=9F=A9=E5=BD=A2?= =?UTF-8?q?=E8=A6=86=E7=9B=96=E9=97=AE=E9=A2=98=E6=8C=87=E5=90=91=E9=93=BE?= =?UTF-8?q?=E6=8E=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 7b2ca29..f67e64c 100644 --- a/README.md +++ b/README.md @@ -79,7 +79,7 @@ [面试题9：用两个栈实现队列](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E7%94%A8%E4%B8%A4%E4%B8%AA%E6%A0%88%E5%AE%9E%E7%8E%B0%E9%98%9F%E5%88%97.py)：需要两个栈Stack1和Stack2，push的时候直接push进Stack1。pop需要判断Stack1和Stack2中元素的情况，Stack1空的话，直接从Stack2 pop，Stack1不空的话，把Stack1的元素push进入Stack2，然后pop Stack2的值。[推广：用两个队列实现栈](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target%20Offer/%E7%94%A8%E4%B8%A4%E4%B8%AA%E9%98%9F%E5%88%97%E5%AE%9E%E7%8E%B0%E6%A0%88.py) -[面试题10：斐波那契数列](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target%20Offer/%E6%96%90%E6%B3%A2%E9%82%A3%E5%A5%91%E6%95%B0%E5%88%97.py)：如何不使用递归实现斐波那契数列，需要把前面两个数字存入在一个数组中。斐波那契数列的变形有很多，如[青蛙跳台阶](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target%20Offer/%E9%9D%92%E8%9B%99%E8%B7%B3%E5%8F%B0%E9%98%B6.py)，一次跳一个或者两个；铺瓷砖问题。[**变态青蛙跳**](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target%20Offer/%E5%8F%98%E6%80%81%E9%9D%92%E8%9B%99%E8%B7%B3%E5%8F%B0%E9%98%B6.py)，每次至少跳一个，至多跳n个，一共有f(n)=2n-1种跳法。考察数学建模的能力。 +[面试题10：斐波那契数列](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target%20Offer/%E6%96%90%E6%B3%A2%E9%82%A3%E5%A5%91%E6%95%B0%E5%88%97.py)：如何不使用递归实现斐波那契数列，需要把前面两个数字存入在一个数组中。斐波那契数列的变形有很多，如[青蛙跳台阶](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target%20Offer/%E9%9D%92%E8%9B%99%E8%B7%B3%E5%8F%B0%E9%98%B6.py)，一次跳一个或者两个；铺瓷砖问题。[**变态青蛙跳**](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target%20Offer/%E5%8F%98%E6%80%81%E9%9D%92%E8%9B%99%E8%B7%B3%E5%8F%B0%E9%98%B6.py)，每次至少跳一个，至多跳n个，一共有f(n)=2n-1种跳法。考察数学建模的能力。以及[矩形覆盖问题](https://blog.csdn.net/Einstellung/article/details/90020345) [面试题8：旋转数组的最小数字](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E6%97%8B%E8%BD%AC%E6%95%B0%E7%BB%84%E7%9A%84%E6%9C%80%E5%B0%8F%E6%95%B0%E5%AD%97.py)：二分查找的变形，注意到旋转数组的首元素肯定不小于旋转数组的尾元素，设置中间点。如果中间点大于首元素，说明最小数字在后面一半，如果中间点小于尾元素，说明最小数字在前一半。依次循环。同时，当一次循环中首元素小于尾元素，说明最小值就是首元素。但是当首元素等于尾元素等于中间值，只能在这个区域顺序查找。 From 101fdd28306a362c68b79e6ac83072d9b5091d4c Mon Sep 17 00:00:00 2001 From: Einstellung Date: Sun, 12 May 2019 13:33:19 +0800 Subject: [PATCH 15/18] =?UTF-8?q?=E6=9B=B4=E6=94=B9=E4=BB=A3=E7=A0=81?= =?UTF-8?q?=EF=BC=8C=E5=BF=AB=E6=8E=92=E7=AE=97=E6=B3=95=E5=8F=98=E5=BE=97?= =?UTF-8?q?=E6=9B=B4=E7=AE=80=E6=B4=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- QuickSort.py | 58 ++++++++++++++++++++++------------------------------ 1 file changed, 25 insertions(+), 33 deletions(-) diff --git a/QuickSort.py b/QuickSort.py index 59b0972..de9eb3a 100644 --- a/QuickSort.py +++ b/QuickSort.py @@ -1,46 +1,38 @@ -# coding: utf-8 - def quickSort(alist): - quickSortHelper(alist, 0, len(alist)-1) - + quickSortHelper(alist, 0, len(alist) - 1) + def quickSortHelper(alist, first, last): if first < last: splitPoint = partition(alist, first, last) - + quickSortHelper(alist, first, splitPoint-1) quickSortHelper(alist, splitPoint+1, last) - + + def partition(alist, first, last): - pivotvlue = alist[first] - - leftmark = first+1 + base = alist[first] + + + + leftmark = first rightmark = last - done = False - - while not done: - while leftmark <= rightmark and alist[leftmark] <= pivotvlue: # bugfix: 先比较index, 不然数组会越界 + + while leftmark < rightmark: # 要求左指针必须小于等于右指针，之所以没有等号是因为，在最后一次指针移动的时候就会取等， + # 不满足小于条件的时候其实已经取等了 + if alist[leftmark] <= base: leftmark += 1 - while rightmark >= leftmark and alist[rightmark] >= pivotvlue: + if alist[rightmark] >= base: rightmark -= 1 - - if leftmark > rightmark: - done = True - else: + + else: # 当左右指针都停止的时候，交换左右指针所对应的值 alist[leftmark], alist[rightmark] = alist[rightmark], alist[leftmark] + + # 当左指针和右指针重合的时候，交换右指针对应的值和base对应的值 alist[rightmark], alist[first] = alist[first], alist[rightmark] - return rightmark - + + return rightmark # rightmark是作为递归排序的标记，所以返回。最后输出alist就是直接排序排好的 + + alist = [54,26,93,17,77,31,44,55,20] -alist2 = [1] -quickSort(alist2) -print(alist2) - - -if __name__ == "__main__": - test_data = [3,2,111,3,-1,0,0,1,0,2,4] - - res_stable = sorted(test_data) - quickSort(test_data) - print(test_data) - print(res_stable) - assert all(map(lambda x: x[0] == x[1], zip(res_stable, test_data))) \ No newline at end of file +quickSort(alist) +print(alist) \ No newline at end of file From caa155e7942dade720b1d727404808fd21af5222 Mon Sep 17 00:00:00 2001 From: Xin YuanHuang Date: Sun, 12 May 2019 21:37:08 +0800 Subject: [PATCH 16/18] =?UTF-8?q?=E6=9B=B4=E6=94=B9=E5=BF=AB=E6=8E=92?= =?UTF-8?q?=E6=8C=87=E5=90=91=E9=93=BE=E6=8E=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index f67e64c..3ea7a00 100644 --- a/README.md +++ b/README.md @@ -45,7 +45,7 @@ [队列](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Queue.py) -[快排](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/QuickSort.py) +[快速排序](https://github.com/Einstellung/AlgorithmsByPython/blob/master/QuickSort.py) [基数排序](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/RadixSort.py) From 4d25c56bddd85d74f43232b61371f60b72535ab7 Mon Sep 17 00:00:00 2001 From: Einstellung Date: Wed, 15 May 2019 03:40:47 +0800 Subject: [PATCH 17/18] =?UTF-8?q?=E6=9B=B4=E6=94=B9=E6=97=8B=E8=BD=AC?= =?UTF-8?q?=E6=95=B0=E7=BB=84=E6=9C=80=E5=B0=8F=E6=95=B0=E5=AD=97=EF=BC=8C?= =?UTF-8?q?=E4=BB=A3=E7=A0=81=E6=9B=B4=E7=AE=80=E6=B4=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...00\345\260\217\346\225\260\345\255\227.py" | 56 ++++++++++++------- 1 file changed, 36 insertions(+), 20 deletions(-) diff --git "a/Target Offer/\346\227\213\350\275\254\346\225\260\347\273\204\347\232\204\346\234\200\345\260\217\346\225\260\345\255\227.py" "b/Target Offer/\346\227\213\350\275\254\346\225\260\347\273\204\347\232\204\346\234\200\345\260\217\346\225\260\345\255\227.py" index a33dbe0..37947e8 100644 --- "a/Target Offer/\346\227\213\350\275\254\346\225\260\347\273\204\347\232\204\346\234\200\345\260\217\346\225\260\345\255\227.py" +++ "b/Target Offer/\346\227\213\350\275\254\346\225\260\347\273\204\347\232\204\346\234\200\345\260\217\346\225\260\345\255\227.py" @@ -7,28 +7,44 @@ # -*- coding:utf-8 -*- class Solution: - def minNumberInRotateArray(self, rotateArray): - if len(rotateArray) == 0: + def minNumber(self, Array): + if len(Array) == 0: # 如果数组为空，返回0 return 0 front = 0 - rear = len(rotateArray) - 1 - minVal = rotateArray[0] - if rotateArray[front] < rotateArray[rear]: - return rotateArray[front] - else: - while (rear - front) > 1: - mid = (rear + front)//2 - if rotateArray[mid] > rotateArray[rear]: - front = mid - elif rotateArray[mid] < rotateArray[front]: - rear = mid - elif rotateArray[mid] == rotateArray[front] and rotateArray[front] == rotateArray[rear]: - for i in range(1, len(rotateArray)): - if rotateArray[i] < minVal: - minVal = rotateArray[i] - rear = i - minVal = rotateArray[rear] - return minVal + rear = len(Array) - 1 + + if Array[rear] > Array[front]: # 如果数组最后一个元素大于第一个元素，证明这个数组是不翻转的数组，直接返回第一个元素 + return Array[front] + + while (rear - front) > 1: + mid = (front + rear) // 2 # 二分法比较数组中间元素，之所以想到二分法是因为数组是有序的 + if Array[mid] < Array[rear]: + rear = mid + if Array[front] < Array[mid]: + front = mid + + if Array[front] == Array[mid] == Array[rear]: # 对数特殊情况数组的判断，即当首中尾元素都相同的时候，二分法失效，只能顺序查找 + mid = 0 + for i in range(1, len(Array)): + if Array[mid] < Array[i]: + continue + else: + mid = i + + return Array[mid] + + return Array[mid] + + +a = Solution() +Array = [3, 4, 5, 1, 2] +Array2 = [1, 2, 3, 4, 5] +Array3 = [1, 0, 1, 1, 1] +print(a.minNumber(Array)) +print(a.minNumber(Array2)) +print(a.minNumber(Array3)) + + # 书上方法 def minNumberInRotateArray2(self, rotateArray): if len(rotateArray) == 0: From 954f541a55cc23f71241eb9431b299a14108a31e Mon Sep 17 00:00:00 2001 From: Xin YuanHuang Date: Wed, 15 May 2019 11:43:53 +0800 Subject: [PATCH 18/18] =?UTF-8?q?=E6=9B=B4=E6=94=B9=E7=AC=AC11=E9=A2=98?= =?UTF-8?q?=E6=8C=87=E5=90=91=E9=93=BE=E6=8E=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 3ea7a00..0edb458 100644 --- a/README.md +++ b/README.md @@ -81,7 +81,7 @@ [面试题10：斐波那契数列](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target%20Offer/%E6%96%90%E6%B3%A2%E9%82%A3%E5%A5%91%E6%95%B0%E5%88%97.py)：如何不使用递归实现斐波那契数列，需要把前面两个数字存入在一个数组中。斐波那契数列的变形有很多，如[青蛙跳台阶](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target%20Offer/%E9%9D%92%E8%9B%99%E8%B7%B3%E5%8F%B0%E9%98%B6.py)，一次跳一个或者两个；铺瓷砖问题。[**变态青蛙跳**](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target%20Offer/%E5%8F%98%E6%80%81%E9%9D%92%E8%9B%99%E8%B7%B3%E5%8F%B0%E9%98%B6.py)，每次至少跳一个，至多跳n个，一共有f(n)=2n-1种跳法。考察数学建模的能力。以及[矩形覆盖问题](https://blog.csdn.net/Einstellung/article/details/90020345) -[面试题8：旋转数组的最小数字](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython/blob/master/Target%20Offer/%E6%97%8B%E8%BD%AC%E6%95%B0%E7%BB%84%E7%9A%84%E6%9C%80%E5%B0%8F%E6%95%B0%E5%AD%97.py)：二分查找的变形，注意到旋转数组的首元素肯定不小于旋转数组的尾元素，设置中间点。如果中间点大于首元素，说明最小数字在后面一半，如果中间点小于尾元素，说明最小数字在前一半。依次循环。同时，当一次循环中首元素小于尾元素，说明最小值就是首元素。但是当首元素等于尾元素等于中间值，只能在这个区域顺序查找。 +[面试题11：旋转数组的最小数字](https://github.com/Einstellung/AlgorithmsByPython/blob/master/Target%20Offer/%E6%97%8B%E8%BD%AC%E6%95%B0%E7%BB%84%E7%9A%84%E6%9C%80%E5%B0%8F%E6%95%B0%E5%AD%97.py)：二分查找的变形，注意到旋转数组的首元素肯定不小于旋转数组的尾元素，设置中间点。如果中间点大于首元素，说明最小数字在后面一半，如果中间点小于尾元素，说明最小数字在前一半。依次循环。同时，当一次循环中首元素小于尾元素，说明最小值就是首元素。但是当首元素等于尾元素等于中间值，只能在这个区域顺序查找。