20190731暂存

Author: Richard-coder

readme.md

@@ -7,7 +7,9 @@ tags： 目录
 这篇博客是我平时刷Leetcode，剑指offer题目和牛客网上的招聘题目等的代码、思路。代码和思路都保存在[我的github](https://github.com/Richard-coder/Programming-Practice/tree/master)上,我对于每一道题都尽量做到c++和python都进行实现。在解题的过程中会参考一些资料，难以面面俱到的写出参考信息，如若侵权，请联系删除。
 
 代码思路的github连接：https://github.com/Richard-coder/Programming-Practice/tree/master
+
 ## Leetcode
+
 | 题号 | 题目&&题解 | c++ | python | 难度|
 | ---- | ---- | ---- | ---- | ---- |
 | 26 | [Remove Duplicates from Sorted Array](./Leetcode/array/RemoveDuplicatesFromSortedArray/readme.md) | [c++](./Leetcode/array/RemoveDuplicatesFromSortedArray/src/cpp/RemoveDuplicatesFromSortedArray.cpp) |  | easy |
@@ -45,7 +47,49 @@ tags： 目录
 | 动态规划 贪心算法 | [014-剪绳子](./剑指offer/014-剪绳子/readme.md) | [c++](./剑指offer/014-剪绳子/src/cpp/014-剪绳子.cpp) | [python](./剑指offer/014-剪绳子/src/python/014-剪绳子.py) |
 | 位运算 | [015-二进制中1的个数](./剑指offer/015-二进制中1的个数/readme.md) | [c++](./剑指offer/015-二进制中1的个数/src/cpp/015-二进制中1的个数.cpp) | [python](./剑指offer/015-二进制中1的个数/src/python/015-二进制中1的个数.py) |
 | 快速求幂算法 | [016-数值的整数次方](./剑指offer/016-数值的整数次方/readme.md) | [c++](./剑指offer/016-数值的整数次方/src/cpp/016-数值的整数次方.cpp) | [python](./剑指offer/016-数值的整数次方/src/python/016-数值的整数次方.py) |
-| 大数 全排列 | [017-打印1到最大的n位数](./剑指offer/017-打印1到最大的n位数/readme.md) | [c++](./剑指offer/017-打印1到最大的n位数/src/cpp/017-打印1到最大的n位数.cpp) | [python](./剑指offer/017-打印1到最大的n位数/src/python/017-打印1到最大的n位数.py) |
+| 链表 | [018_01-在O(1)时间删除链表结点](./剑指offer/018_01-在O(1)时间删除链表结点/readme.md) | [c++](./剑指offer/018_01-在O(1)时间删除链表结点/src/cpp/018_01-在O(1)时间删除链表结点.cpp) | [python](./剑指offer/018_01-在O(1)时间删除链表结点/src/python/018_01-在O(1)时间删除链表结点.py) |
+| 链表 | [018_02-在O(1)时间删除链表结点](./剑指offer/018_02-在O(1)时间删除链表结点/readme.md) | [c++](./剑指offer/018_02-在O(1)时间删除链表结点/src/cpp/018_02-在O(1)时间删除链表结点.cpp) | [python](./剑指offer/018_02-在O(1)时间删除链表结点/src/python/018_02-在O(1)时间删除链表结点.py) |
+| 递归 | [019-正则表达式匹配](./剑指offer/019-正则表达式匹配/readme.md) | [c++](./剑指offer/019-正则表达式匹配/src/cpp/019-正则表达式匹配.cpp) | [python](./剑指offer/019-正则表达式匹配/src/python/019-正则表达式匹配.py) |
+| 字符串 | [020-表示数值的字符串](./剑指offer/020-表示数值的字符串/readme.md) | [c++](./剑指offer/020-表示数值的字符串/src/cpp/020-表示数值的字符串.cpp) | [python](./剑指offer/020-表示数值的字符串/src/python/020-表示数值的字符串.py) |
+| 两指针 稳定排序 | [021-调整数组顺序使奇数位于偶数前面](./剑指offer/021-调整数组顺序使奇数位于偶数前面/readme.md) | [c++](./剑指offer/021-调整数组顺序使奇数位于偶数前面/src/cpp/021-调整数组顺序使奇数位于偶数前面.cpp) | [python](./剑指offer/021-调整数组顺序使奇数位于偶数前面/src/python/021-调整数组顺序使奇数位于偶数前面.py) |
+| 两指针 | [022-链表中倒数第k个结点](./剑指offer/022-链表中倒数第k个结点/readme.md) | [c++](./剑指offer/022-链表中倒数第k个结点/src/cpp/022-链表中倒数第k个结点.cpp) | [python](./剑指offer/022-链表中倒数第k个结点/src/python/022-链表中倒数第k个结点.py) |
+| 两指针 | [023-链表中环的入口结点](./剑指offer/023-链表中环的入口结点/readme.md) | [c++](./剑指offer/023-链表中环的入口结点/src/cpp/023-链表中环的入口结点.cpp) | [python](./剑指offer/023-链表中环的入口结点/src/python/023-链表中环的入口结点.py) |
+| 链表 | [024-反转链表](./剑指offer/024-反转链表/readme.md) | [c++](./剑指offer/024-反转链表/src/cpp/024-反转链表.cpp) | [python](./剑指offer/024-反转链表/src/python/024-反转链表.py) |
+| 链表 递归 | [025-合并两个排序的链表](./剑指offer/025-合并两个排序的链表/readme.md) | [c++](./剑指offer/025-合并两个排序的链表/src/cpp/025-合并两个排序的链表.cpp) | [python](./剑指offer/025-合并两个排序的链表/src/python/025-合并两个排序的链表.py) |
+| 二叉树 递归 | [026-树的子结构](./剑指offer/026-树的子结构/readme.md) | [c++](./剑指offer/026-树的子结构/src/cpp/026-树的子结构.cpp) | [python](./剑指offer/026-树的子结构/src/python/026-树的子结构.py) |
+| 二叉树 递归 遍历 | [027-二叉树的镜像](./剑指offer/027-二叉树的镜像/readme.md) | [c++](./剑指offer/027-二叉树的镜像/src/cpp/027-二叉树的镜像.cpp) | [python](./剑指offer/027-二叉树的镜像/src/python/027-二叉树的镜像.py) |
+| 二叉树 递归 遍历 | [028-对称的二叉树](./剑指offer/028-对称的二叉树/readme.md) | [c++](./剑指offer/028-对称的二叉树/src/cpp/028-对称的二叉树.cpp) | [python](./剑指offer/028-对称的二叉树/src/python/028-对称的二叉树.py) |
+| 边界条件 | [029-顺时针打印矩阵](./剑指offer/029-顺时针打印矩阵/readme.md) | [c++](./剑指offer/029-顺时针打印矩阵/src/cpp/029-顺时针打印矩阵.cpp) | [python](./剑指offer/029-顺时针打印矩阵/src/python/029-顺时针打印矩阵.py) |
+| 栈 | [030-包含min函数的栈](./剑指offer/030-包含min函数的栈/readme.md) | [c++](./剑指offer/030-包含min函数的栈/src/cpp/030-包含min函数的栈.cpp) | [python](./剑指offer/030-包含min函数的栈/src/python/030-包含min函数的栈.py) |
+| 栈 | [ 031-栈的压入弹出序列](./剑指offer/ 031-栈的压入弹出序列/readme.md) | [c++](./剑指offer/ 031-栈的压入弹出序列/src/cpp/ 031-栈的压入弹出序列.cpp) | [python](./剑指offer/ 031-栈的压入弹出序列/src/python/ 031-栈的压入弹出序列.py) |
+| 层次遍历 二叉树 | [032_01-从上往下打印二叉树](./剑指offer/032_01-从上往下打印二叉树/readme.md) | [c++](./剑指offer/032_01-从上往下打印二叉树/src/cpp/032_01-从上往下打印二叉树.cpp) | [python](./剑指offer/032_01-从上往下打印二叉树/src/python/032_01-从上往下打印二叉树.py) |
+| 层次遍历 二叉树 | [032_02-把二叉树打印成多行](./剑指offer/032_02-把二叉树打印成多行/readme.md) | [c++](./剑指offer/032_02-把二叉树打印成多行/src/cpp/032_02-把二叉树打印成多行.cpp) | [python](./剑指offer/032_02-把二叉树打印成多行/src/python/032_02-把二叉树打印成多行.py) |
+| 层次遍历 二叉树 | [032_03-按之字形顺序打印二叉树](./剑指offer/032_03-按之字形顺序打印二叉树/readme.md) | [c++](./剑指offer/032_03-按之字形顺序打印二叉树/src/cpp/032_03-按之字形顺序打印二叉树.cpp) | [python](./剑指offer/032_03-按之字形顺序打印二叉树/src/python/032_03-按之字形顺序打印二叉树.py) |
+| 递归 二叉搜索树 | [033-二叉搜索树的后序遍历序列](./剑指offer/033-二叉搜索树的后序遍历序列/readme.md) | [c++](./剑指offer/033-二叉搜索树的后序遍历序列/src/cpp/033-二叉搜索树的后序遍历序列.cpp) | [python](./剑指offer/033-二叉搜索树的后序遍历序列/src/python/033-二叉搜索树的后序遍历序列.py) |
+| 二叉树 前序遍历 | [034-二叉树中和为某一值的路径](./剑指offer/034-二叉树中和为某一值的路径/readme.md) | [c++](./剑指offer/034-二叉树中和为某一值的路径/src/cpp/034-二叉树中和为某一值的路径.cpp) | [python](./剑指offer/034-二叉树中和为某一值的路径/src/python/034-二叉树中和为某一值的路径.py) |
+| 链表 | [035-复杂链表的复制](./剑指offer/035-复杂链表的复制/readme.md) | [c++](./剑指offer/035-复杂链表的复制/src/cpp/035-复杂链表的复制.cpp) | [python](./剑指offer/035-复杂链表的复制/src/python/035-复杂链表的复制.py) |
+| 二叉搜索树 中序遍历 | [036-二叉搜索树与双向链表](./剑指offer/036-二叉搜索树与双向链表/readme.md) | [c++](./剑指offer/036-二叉搜索树与双向链表/src/cpp/036-二叉搜索树与双向链表.cpp) | [python](./剑指offer/036-二叉搜索树与双向链表/src/python/036-二叉搜索树与双向链表.py) |
+| 二叉搜索树 前序遍历 | [037-序列化二叉树](./剑指offer/037-序列化二叉树/readme.md) | [c++](./剑指offer/037-序列化二叉树/src/cpp/037-序列化二叉树.cpp) | [python](./剑指offer/037-序列化二叉树/src/python/037-序列化二叉树.py) |
+| 全排列 | [038_01-字符串的排列](./剑指offer/038_01-字符串的排列/readme.md) | [c++](./剑指offer/038_01-字符串的排列/src/cpp/038_01-字符串的排列.cpp) | [python](./剑指offer/038_01-字符串的排列/src/python/038_01-字符串的排列.py) |
+| 全组合 | [038_02-全组合-不含重复元素](./剑指offer/038_02-全组合-不含重复元素/readme.md) | [c++](./剑指offer/038_02-全组合-不含重复元素/src/cpp/038_02-全组合-不含重复元素.cpp) | [python](./剑指offer/038_02-全组合-不含重复元素/src/python/038_02-全组合-不含重复元素.py) |
+| 全组合 | [038_03-全组合-含重复元素](./剑指offer/038_03-全组合-含重复元素/readme.md) | [c++](./剑指offer/038_03-全组合-含重复元素/src/cpp/038_03-全组合-含重复元素.cpp) | [python](./剑指offer/0038_03-全组合-含重复元素/src/python/038_03-全组合-含重复元素.py) |
+| 全排列 | [038_04-对面和相等的正方体](./剑指offer/038_04-对面和相等的正方体/readme.md) | [c++](./剑指offer/038_04-对面和相等的正方体/src/cpp/038_04-对面和相等的正方体.cpp) | [python](./剑指offer/038_04-对面和相等的正方体/src/python/038_04-对面和相等的正方体.py) |
+| 全排列 | [038_05-N皇后](./剑指offer/038_05-N皇后/readme.md) | [c++](./剑指offer/038_05-N皇后/src/cpp/038_05-N皇后.cpp) | [python](./剑指offer/038_05-N皇后/src/python/038_05-N皇后.py) |
+| 数组 | [039-数组中出现次数超过一半的数字](./剑指offer/039-数组中出现次数超过一半的数字/readme.md) | [c++](./剑指offer/039-数组中出现次数超过一半的数字/src/cpp/039-数组中出现次数超过一半的数字.cpp) | [python](./剑指offer/039-数组中出现次数超过一半的数字/src/python/039-数组中出现次数超过一半的数字.py) |
+| 数组 | [040-最小的K个数](./剑指offer/040-最小的K个数/readme.md) | [c++](./剑指offer/040-最小的K个数/src/cpp/040-最小的K个数.cpp) | [python](./剑指offer/040-最小的K个数/src/python/040-最小的K个数.py) |
+| 最大堆 最小堆 | [041-数据流中的中位数](./剑指offer/041-数据流中的中位数/readme.md) | [c++](./剑指offer/041-数据流中的中位数/src/cpp/041-数据流中的中位数.cpp) | [python](./剑指offer/041-数据流中的中位数/src/python/041-数据流中的中位数.py) |
+| 动态规划 | [042-连续子数组的最大和](./剑指offer/042-连续子数组的最大和/readme.md) | [c++](./剑指offer/042-连续子数组的最大和/src/cpp/042-连续子数组的最大和.cpp) | [python](./剑指offer/042-连续子数组的最大和/src/python/042-连续子数组的最大和.py) |
+| 递归 | [043-从1到n整数中1出现的次数](./剑指offer/043-从1到n整数中1出现的次数/readme.md) | [c++](./剑指offer/043-从1到n整数中1出现的次数/src/cpp/043-从1到n整数中1出现的次数.cpp) | [python](./剑指offer/043-从1到n整数中1出现的次数/src/python/043-从1到n整数中1出现的次数.py) |
+| 找规律 | [044-数字序列中某一位的数字](./剑指offer/044-数字序列中某一位的数字/readme.md) | [c++](./剑指offer/044-数字序列中某一位的数字/src/cpp/044-数字序列中某一位的数字.cpp) | [python](./剑指offer/044-数字序列中某一位的数字/src/python/044-数字序列中某一位的数字.py) |
+| 排序 | [045-把数组排成最小的数](./剑指offer/045-把数组排成最小的数/readme.md) | [c++](./剑指offer/045-把数组排成最小的数/src/cpp/045-把数组排成最小的数.cpp) | [python](./剑指offer/045-把数组排成最小的数/src/python/045-把数组排成最小的数.py) |
+| 递归 | [046-把数字翻译成字符串](./剑指offer/046-把数字翻译成字符串/readme.md) | [c++](./剑指offer/046-把数字翻译成字符串/src/cpp/046-把数字翻译成字符串.cpp) | [python](./剑指offer/046-把数字翻译成字符串/src/python/046-把数字翻译成字符串.py) |
+| 动态规划 | [047-礼物的最大价值](./剑指offer/047-礼物的最大价值/readme.md) | [c++](./剑指offer/047-礼物的最大价值/src/cpp/047-礼物的最大价值.cpp) | [python](./剑指offer/047-礼物的最大价值/src/python/047-礼物的最大价值.py) |
+| 动态规划 | [048-最长不含重复字符的子字符串](./剑指offer/048-最长不含重复字符的子字符串/readme.md) | [c++](./剑指offer/048-最长不含重复字符的子字符串/src/cpp/048-最长不含重复字符的子字符串.cpp) | [python](./剑指offer/048-最长不含重复字符的子字符串/src/python/048-最长不含重复字符的子字符串.py) |
+| 空间换时间 | [049-丑数](./剑指offer/049-丑数/readme.md) | [c++](./剑指offer/049-丑数/src/cpp/049-丑数.cpp) | [python](./剑指offer/049-丑数/src/python/049-丑数.py) |
+| 哈希表 | [050_01-第一个只出现一次的字符](./剑指offer/050_01-第一个只出现一次的字符/readme.md) | [c++](./剑指offer/050_01-第一个只出现一次的字符/src/cpp/050_01-第一个只出现一次的字符.cpp) | [python](./剑指offer/050_01-第一个只出现一次的字符/src/python/050_01-第一个只出现一次的字符.py) |
+| 哈希表 | [050_02-字符流中第一个只出现一次的字符](./剑指offer/050_02-字符流中第一个只出现一次的字符/readme.md) | [c++](./剑指offer/050_02-字符流中第一个只出现一次的字符/src/cpp/050_02-字符流中第一个只出现一次的字符.cpp) | [python](./剑指offer/050_02-字符流中第一个只出现一次的字符/src/python/050_02-字符流中第一个只出现一次的字符.py) |
+| 归并排序 | [051-数组中的逆序对](./剑指offer/051-数组中的逆序对/readme.md) | [c++](./剑指offer/051-数组中的逆序对/src/cpp/051-数组中的逆序对.cpp) | [python](./剑指offer/051-数组中的逆序对/src/python/051-数组中的逆序对.py) |
+| 链表 两指针 | [051-数组中的逆序对](./剑指offer/051-数组中的逆序对/readme.md) | [c++](./剑指offer/052-两个链表的第一个公共结点/src/cpp/052-两个链表的第一个公共结点.cpp) | [python](./剑指offer/052-两个链表的第一个公共结点/src/python/052-两个链表的第一个公共结点.py) |
 
 ## 经典算法&&数据结构
 
@@ -61,4 +105,5 @@ tags： 目录
  2. [LeetCode题解](https://github.com/soulmachine/leetcode) 
  3. [剑指Offer——名企面试官精讲典型编程题](https://github.com/gatieme/CodingInterviews)
  4. [牛客网](https://www.nowcoder.com/9087476)
- 5. [AlgorithmsByPython](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython)
+ 5. [AlgorithmsByPython](https://github.com/Jack-Lee-Hiter/AlgorithmsByPython)
+

剑指offer/001-/readme.md

@@ -0,0 +1,29 @@
+# 003-数组中重复的数字
+
+tags： 数组
+
+---
+
+## 题目原文
+
+[牛客网链接]()
+
+
+
+## 解题思路
+
+
+
+## 代码
+
+### [c++代码](./src/cpp/003-数组中重复的数字.cpp)
+
+```c++
+
+```
+
+### [python代码](./src/python/003-数组中重复的数字.py)
+
+```python
+
+```

剑指offer/001-/src/cpp/003-数组中重复的数字.cpp

@@ -0,0 +1 @@
+# -*- coding:utf-8 -*-

剑指offer/001-/src/python/003-数组中重复的数字.py

@@ -0,0 +1,115 @@
+# 018_01-在O(1)时间删除链表结点
+
+tags： 链表
+
+---
+
+## 题目原文
+
+[牛客网链接_暂无]()
+题目：给定单向链表的头指针和一个结点指针，定义一个函数在O(1)时间删除该结点。
+
+
+
+## 解题思路
+
+[参考](https://www.cnblogs.com/edisonchou/p/4765163.html)
+
+### 常规思路
+
+　在单向链表中删除一个结点，最常规的做法无疑是从链表的头结点开始，顺序遍历查找要删除的结点，并在链表中删除该结点。这种思路由于需要顺序查找，时间复杂度自然就是**O(n)**。
+
+![img](img/readme.assets/272317431874277.jpg)
+
+### 正确思路
+
+是不是一定需要得到被删除的结点的前一个结点呢？答案是否定的。
+
+　　我们可以很方便地得到要删除的结点的一下结点。因此，我们**可以把下一个结点的内容复制到需要删除的结点上覆盖原有的内容，再把下一个结点删除，就相当于把当前需要删除的结点删除了**。
+
+![img](img/readme.assets/272359583447249.jpg)
+
+　　但是，还有两个特殊情况需要进行考虑：
+
+　　（1）如果要删除的结点位于链表的尾部，那么它就没有下一个结点：
+
+　　此时我们仍然从链表的头结点开始，顺序遍历得到该结点的前序结点，并完成删除操作，这仍然属于O(n)时间的操作。
+
+　　（2）如果链表中只有一个结点，而我们又要删除链表的头结点（也是尾结点）：
+
+　　此时我们在删除结点之后，还需要把链表的头结点设置为NULL。
+
+　　最后，通过综合最坏情况（尾节点需要顺序查找，1次）和最好情况（n-1次），因此平均时间复杂度为：
+
+![img](img/readme.assets/280011268903804.png)
+
+　　需要注意的是：**受到O(1)时间的限制，我们不得不把确保结点在链表中的责任推给了函数DeleteNode的调用者**。
+
+## 编程知识
+
+[C++ 里 delete 指针两次会怎么样？](https://www.zhihu.com/question/38998078#answer-41205877)
+
+## 代码
+
+### [c++代码](./src/cpp/018_01-在O(1)时间删除链表结点.cpp)
+
+大体思路
+
+```
+待删指针不是尾指针：
+      待删指针的值用待删指针的下一个指针的值覆盖
+      删掉待删指针的下一个指针
+待删指针是尾指针：
+      待删指针同时是头指针：
+            删掉头指针
+     待删指针不是头指针
+            找到待删指针的前一个指针
+            删掉待删指针，前一个指针的next赋值为空
+```
+
+
+
+```c++
+void DeleteNode(ListNode** pListHead, ListNode* pToBeDeleted)
+{
+    if(!pListHead || !pToBeDeleted)
+        return;
+
+    // 要删除的结点不是尾结点
+    if(pToBeDeleted->m_pNext != nullptr)
+    {
+        ListNode* pNext = pToBeDeleted->m_pNext;
+        pToBeDeleted->m_nValue = pNext->m_nValue;
+        pToBeDeleted->m_pNext = pNext->m_pNext;
+ 
+        delete pNext;
+        pNext = nullptr;
+    }
+    // 链表只有一个结点，删除头结点（也是尾结点）
+    else if(*pListHead == pToBeDeleted)
+    {
+        delete pToBeDeleted;
+        pToBeDeleted = nullptr;
+        *pListHead = nullptr;
+    }
+    // 链表中有多个结点，删除尾结点
+    else
+    {
+        ListNode* pNode = *pListHead;
+        while(pNode->m_pNext != pToBeDeleted)
+        {
+            pNode = pNode->m_pNext;            
+        }
+ 
+        pNode->m_pNext = nullptr;
+        delete pToBeDeleted;
+        pToBeDeleted = nullptr;
+    }
+}
+```
+
+### [python代码](./src/python/018_01-在O(1)时间删除链表结点.py)
+
+```python
+
+```