2.28

DmrfCoder · DmrfCoder · commit 7b6d61273e1c · 2019-02-28T00:02:45.000+08:00
diff --git a/README.md b/README.md
@@ -52,7 +52,12 @@
 
 - [字符串的排列](./SwordToOffer/Doc/字符串的排列.md)
 
-  
+- [***数组中出现次数超过一半的数字***](./SwordToOffer/Doc/数组中出现次数超过一半的数字.md)
+
+- [最小的K个数](./SwordToOffer/Doc/最小的K个数.md)
 
+- [连续子数组的最大和](./SwordToOffer/Doc/连续子数组的最大和.md)
 
+- [把数组排成最小的数](./SwordToOffer/Doc/把数组排成最小的数.md)
 
+  
diff --git a/SwordToOffer/Code/27.py b/SwordToOffer/Code/27.py
@@ -0,0 +1,40 @@
+# -*- coding:utf-8 -*-
+class Solution:
+    def MoreThanHalfNum_Solution(self, numbers):
+        # write code here
+        if numbers is None:
+            return 0
+
+        size = len(numbers)
+
+        if size == 0:
+            return 0
+        if size == 1:
+            return numbers
+
+        soldier = numbers[0]
+        soldierCount = 1
+        soldierIndex = 0
+        flag = False
+        for i in range(1, size):
+            if numbers[i] != soldier:
+                soldierCount -= 1
+                if soldierCount == 0:
+                    soldierIndex += 1
+                    soldier = numbers[soldierIndex]
+                    soldierCount = 1
+                    flag = False
+            else:
+                flag = True
+                soldierCount += 1
+
+        if soldierCount > 1:
+            return soldier
+        elif soldierCount == 1 and flag:
+            return soldier
+        else:
+            return 0
+
+
+s = Solution()
+print s.MoreThanHalfNum_Solution([1])
diff --git a/SwordToOffer/Code/28.py b/SwordToOffer/Code/28.py
@@ -0,0 +1,62 @@
+# -*- coding:utf-8 -*-
+class Solution:
+
+    def siftUp(self, a, index):
+
+        while (True):
+            if index == 1:
+                return a
+            parentIndex = int(index / 2)
+            if a[parentIndex] < a[index]:
+                t = a[parentIndex]
+                a[parentIndex] = a[index]
+                a[index] = t
+                index = parentIndex
+            else:
+                return a
+
+    def siftDown(self, a, index):
+        size = len(a) - 1
+        while (True):
+            index = 2 * index
+            if index > size:
+                return a
+
+            if index + 1 <= size:
+                if a[index + 1] > a[index]:
+                    index += 1
+
+            if a[index] > a[int(index / 2)]:
+                t = a[index]
+                a[index] = a[int(index / 2)]
+                a[int(index / 2)] = t
+
+    def makeHeap(self, a, k):
+        for i in range(int(k / 2), 0, -1):
+            a = self.siftDown(a, i)
+        return a
+
+    def GetLeastNumbers_Solution(self, tinput, k):
+        # write code here
+        if tinput is None:
+            return []
+
+        size = len(tinput)
+        if size < k or k==0:
+            return []
+
+        a = [0]
+        a = a + tinput[0:k]
+        a = self.makeHeap(a, k)
+        for i in range(k, len(tinput)):
+            if tinput[i] < a[1]:
+                a[1] = tinput[i]
+                a = self.siftDown(a, 1)
+
+        a = sorted(a[1:])
+
+        return a
+
+
+s = Solution()
+s.GetLeastNumbers_Solution([4, 5, 1, 6, 2, 7, 3, 8], 4)
diff --git a/SwordToOffer/Code/29.py b/SwordToOffer/Code/29.py
@@ -0,0 +1,18 @@
+# -*- coding:utf-8 -*-
+class Solution:
+    def FindGreatestSumOfSubArray(self, array):
+        # write code here
+        res = array[0]
+        f = array[0]
+
+        size = len(array)
+
+        for i in range(1, size):
+            f = max(array[i], array[i] + f)
+            res = max(res, f)
+
+        return res
+
+
+s = Solution()
+print s.FindGreatestSumOfSubArray([1, -2, 3, 10, -4, 7, 2, -5])
diff --git a/SwordToOffer/Code/30.py b/SwordToOffer/Code/30.py
@@ -0,0 +1,36 @@
+# -*- coding:utf-8 -*-
+class Solution:
+
+    def PrintMinNumber(self, numbers):
+        # write code here
+        if numbers is None:
+            return ""
+        if len(numbers)==0:
+            return ""
+        strs = []
+        for item in numbers:
+            strs.append(str(item))
+
+        z = sorted(strs, cmp)
+
+        r=''
+
+        for item in z:
+            r=r+item
+
+
+        return int(r)
+
+
+def cmp(str1, str2):
+    s1 = str1 + str2
+    s2 = str2 + str1
+
+    if int(s1) < int(s2):
+        return -1
+    else:
+        return 0
+
+
+s = Solution()
+print s.PrintMinNumber([3,32,321])
diff --git a/SwordToOffer/Doc/把数组排成最小的数.md b/SwordToOffer/Doc/把数组排成最小的数.md
@@ -0,0 +1,14 @@
+# 把数组排成最小的数
+
+<center>知识点：</center>
+
+
+## 题目描述
+输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
+## 解题思路
+
+
+
+## 代码
+
+[这里](../Code/n.py)
diff --git a/SwordToOffer/Doc/数组中出现次数超过一半的数字.md b/SwordToOffer/Doc/数组中出现次数超过一半的数字.md
@@ -0,0 +1,52 @@
+# 数组中出现次数超过一半的数字
+
+<center>知识点：</center>
+
+
+## 题目描述
+数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
+## 解题思路
+
+
+采用阵地攻守的思想：
+设置士兵soldier（初始时为第一个元素）,士兵当前生命值soldierCount（每次的初始值为0），当前士兵对应的数组下标soldierIndex（起始值为0），对数组进行遍历，如果soldier与当前元素相等，则soldierCount加一，否则soldierCount减一，如果soldierCount为0，则soldierIndex增一即更新soldier的值，到最后如果soldierCount为1，则此时soldier可能为出现次数超过一半的元素，之所以可能是因为存在一种情况比如：[1,2,3]，这样遍历到最后一个元素时soldier为3对应的soldierCount最后的值也是1而非0因为其初始值为1，没增也没减，解决方法是增加一个flag用来标记当前soldierCount是否增加过，如果当前soldierCount增加过但是后来由于减1减到了1则当前soldier就是出现次数超过一半的元素，否则不是。
+
+## 代码
+```python
+    def MoreThanHalfNum_Solution(self, numbers):
+        # write code here
+        if numbers is None:
+            return 0
+
+        size = len(numbers)
+
+        if size == 0:
+            return 0
+        if size == 1:
+            return numbers
+
+        soldier = numbers[0]
+        soldierCount = 1
+        soldierIndex = 0
+        flag = False
+        for i in range(1, size):
+            if numbers[i] != soldier:
+                soldierCount -= 1
+                if soldierCount == 0:
+                    soldierIndex += 1
+                    soldier = numbers[soldierIndex]
+                    soldierCount = 1
+                    flag = False
+            else:
+                flag = True
+                soldierCount += 1
+
+        if soldierCount > 1:
+            return soldier
+        elif soldierCount == 1 and flag:
+            return soldier
+        else:
+            return 0
+```
+
+[这里](../Code/27.py)
diff --git a/SwordToOffer/Doc/整数中1出现的次数.md b/SwordToOffer/Doc/整数中1出现的次数.md
@@ -0,0 +1,14 @@
+# 整数中1出现的次数(从1到n整数中出现1的次数)
+
+<center>知识点：</center>
+
+
+## 题目描述
+求出1~13的整数中1出现的次数,并算出100~1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。
+## 解题思路
+对每个数求出其每一位的数，与1比较并计数。
+
+
+## 代码
+
+[这里](../Code/n.py)
diff --git a/SwordToOffer/Doc/最小的K个数.md b/SwordToOffer/Doc/最小的K个数.md
@@ -0,0 +1,121 @@
+# 最小的K个数
+
+<center>知识点：</center>
+
+
+## 题目描述
+输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。
+## 解题思路
+
+类似堆排序的思路，维护一个具有k个元素的大顶堆，然后将剩余n-k个数依次与堆顶比较，如果大于堆顶则跳过，否则删除堆顶，将其替换为比起小的当前数，然后调整堆为大顶堆，最后大顶堆中的k个数即为所求数。
+
+大顶堆的特点：
+
+父节点大于等于子节点（但是两个子节点之间的大小关系没有要求），这样可以做到沿着每条从根节点到叶子节点的路径，元素的键值都是以非升序排列的。
+堆是一个几乎完全的二叉树，所以具有和完全二叉树一样的特点，即一般是存储在一个数组A[n]中，A[i]的左子节点在A[2i]中，右子节点在A[2i+1]中（当他们存在的时候）,A[i]的父亲节点在A[i/2]中（如果存在，i/2向下取整）。
+
+
+
+### 两个辅助运算
+
+#### SIFT-UP
+
+##### 功能
+
+当某个节点（H[i]）的值大于他的父亲节点的值时，需要通过SITF-UP将这个节点 **沿着从H[i]到H[1]这条唯一的路径**
+上移到合适的位置以形成一个合格的堆。
+
+##### 实现思路
+
+将H[i]与其父亲节点H[i/2]比较，如果H[i]大于H[i/2]，则将H[i]与H[i/2]互换，直到H[i]没有父节点或者H[i]不大于H[i/2]。
+
+##### 代码
+
+```
+ int SiftUp(int *H, int i) {
+
+    while (true) {
+        if (i == 1) {
+            break;//说明当前i是根节点
+        }
+        if (H[i] > H[(int) i / 2]) {//如果当前节点比父亲节点大
+            int t;
+            t = H[i];
+            H[i] = H[(int) i / 2];
+            H[(int) i / 2] = t;
+            i = i / 2;
+        } else {
+            break;
+        }
+    }
+    return 0;
+}
+```
+
+
+
+#### SIFT-DOWN
+
+##### 功能
+
+当某个节点（H[i]，i<=(int)n/2即 **非叶子节点**
+）的值小于它的两个子节点H[2i]和H[2i+1]（如果存在的话）的最大值时，需要将SIFT-DOWN将渗到合适的位置。
+
+##### 实现思路
+
+将H[i]与其两个子节点中值最大的元素比较，如果小于最大的那个节点，则将H[i]与其最大的那个子节点互换。
+
+##### 代码：
+
+```
+ int SiftDown(int *H, int i, int n) {
+    while (true) {
+        i = 2 * i;
+        if (i > n) {
+            break;
+        }
+
+        if (i + 1 <= n) {
+            if (H[i + 1] > H[i]) {//比较两个子节点哪个最大
+                i++;
+            }
+        }
+
+        if (H[i] > H[(int) i / 2]) {
+            int t;
+            t = H[i];
+            H[i] = H[(int) i / 2];
+            H[(int) i / 2] = t;
+        }
+    }
+}
+```
+
+### 创建堆（makeheap）
+
+##### 功能
+
+给出一个有n个元素的数组H[1….n]，创建一个包含这些元素的堆。
+
+##### 实现思路
+
+类似于分治，首先，H的叶子节点（即最下面的一层单个元素）可以认为是若干个小堆，然后我们从倒数第二层开始，将倒数第二层和倒数第一层的元素进行适当调整，使得调整之后整个二叉完全数的最后两层是若干个子堆，按照这个思路，依次向上走，最终走到第1层的时候就可以保证整个完全二叉树是一个符合要求的堆。
+
+需要注意的是对于一个完全二叉树， **倒数第二层的最后一个元素的下标为int(n/2)** ，（因为倒数第二层的最后一个节点的下标x应该满足x*2=n）.
+
+##### 算法时间复杂度分析
+
+senta(n)
+
+##### 代码
+
+```
+ void makeheap(int *H,int n){
+    for (int i = n/2; i >=1 ; --i) {//从倒数第二层到第一层
+        SiftDown(H,i,n);
+    }
+}
+```
+
+
+[这里](../Code/28.py)
diff --git a/SwordToOffer/Doc/连续子数组的最大和.md b/SwordToOffer/Doc/连续子数组的最大和.md
