update stack & add row

Author: imoyao

Recursion/readme.md

@@ -27,7 +27,7 @@
 - 在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成`栈溢出`等，所以一般不提倡用递归算法设计程序。
 
 表现在 `Python` 语言中，即为报错信息`RecursionError: maximum recursion depth exceeded in comparison.`
-默认递归深度为 1000 ，我们可以通过修改下面的代码设置调节，但是通常不建议这样操作。（效率太低）
+默认递归深度为 1000 ，我们可以通过修改下面的代码设置调节，但是**通常不建议这样操作**。（效率太低）
 ```python
 import sys
 sys.setrecursionlimit(100000)
@@ -62,7 +62,7 @@ def look_for_key_with_recursion(big_box):
 
 # **尾递归**
 
-在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。
+在函数返回的时候，调用自身本身，并且，`return`语句不能包含表达式。
 
 ```python
 def bar():
@@ -73,7 +73,8 @@ def foo():
 ```
 上面代码中，函数`foo()`的最后一步是调用函数`bar()`，这就叫尾调用。
 具体实现见[代码](./recursion.py)中的`tail_recursion_fact()`函数。
-`Python`解释器也没有做优化，所以，即使把上面的`factorial(n)`函数改成尾递归方式的`tail_recursion_fact()`，也会导致栈溢出。
+
+`Python`解释器没有做优化，所以，即使把上面的`factorial(n)`函数改成尾递归方式的`tail_recursion_fact()`，也会导致栈溢出。
 
 通过特殊的装饰器，我们也可以实现[Python开启尾递归优化](https://segmentfault.com/a/1190000007641519),详见代码中的`tail_call_optimized()`函数。
 

Stack/linked_stack.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Created by imoyao at 2019/9/17 15:58
+
+"""
+基于链表实现的栈
+"""
+
+
+class Node:
+
+    def __init__(self, data, next=None):
+        self.data = data
+        self._next = next
+
+
+class LinkedStack:
+    """A stack based upon singly-linked list.
+    """
+
+    def __init__(self):
+        self._top = None
+        self._size = 0
+
+    def __repr__(self):
+        current = self._top
+        nums = []
+        while current:
+            nums.append(current.data)
+            current = current._next
+        ret = ','.join([str(num) for num in nums])
+        return f'[{ret}]'
+
+    def is_empty(self):
+        return self._size == 0
+
+    def size(self):
+        return self._size
+
+    def push(self, item):
+        new_top = Node(item)
+        new_top._next = self._top
+        self._top = new_top
+        self._size += 1
+
+    def pop(self):
+        if not self._size:
+            print('Stack Overflow')
+        else:
+            item = self._top.data
+            self._top = self._top._next
+            return item
+
+    def top(self):
+        if not self._size:
+            print('Stack Overflow.')
+        else:
+            return self._top.data
+
+
+s = LinkedStack()
+print(s.is_empty())
+s.push(4)
+print(s)
+s.push('dog')
+print(s)
+# print(s.peek())
+s.push(True)
+print(s)
+print(s.size())
+print(s.is_empty())
+print(s)
+
+# class LinkedStack:
+#     """
+#     基于单链表的栈实现
+#     """
+#
+#     def __init__(self):
+#         self._top = None
+#         self._num = 0
+#
+#     def is_empty(self):
+#         return self._num == 0
+#
+#     def size(self):
+#         return self._num
+#
+#     # def __repr__(self):
+#     #     current = self._top
+#     #     nums = []
+#     #     while current:
+#     #         nums.append(current._data)
+#     #         current = current._next
+#     #     return ' '.join(f'{num}' for num in nums)
+#
+#     def push(self, value):
+#         new_top = Node(value)
+#         new_top._next = self._top
+#         self._top = new_top
+#         self._num += 1
+#
+#     def pop(self):
+#         if not self._num:
+#             print('The length of stack is 0.')
+#         else:
+#             item = self._top._data
+#             self._top = self._top.next
+#             return item
+#
+#
+# if __name__ == '__main__':
+#     s = LinkedStack()
+#     print(s.is_empty())
+#     s.push(4)
+#     print(s)
+#     s.push('dog')
+#     print(s)
+#     # print(s.peek())
+#     s.push(True)
+#     print(s)
+#     print(s.size())
+#     print(s.is_empty())
+#     print(s)

Stack/stack.py renamed to Stack/list_stack.py

@@ -7,7 +7,8 @@
 - 弹夹（先压入的最后射出）
 - 摞在一起的餐碟
 
-![羽毛球杯](./img/stack-example.jpg)
+![羽毛球杯](./img/stack-example.jpg)    
+
 （我们假设杯子只有顶端可以放入和取出）
 
 ## 操作
@@ -31,7 +32,7 @@
 | s.size()      | [4,'dog']          | 2      |                    |
 
 ## 代码实现
-[stack](stack.py)
+[基于list实现stack](list_stack.py)
 
 ## 其他
 常与另一种有序的线性数据`队列`相提并论。

Stack/readme.md

@@ -0,0 +1,58 @@
+class Bag(object):
+    def __init__(self,n,capacity,weights,values):
+        self.capacity = capacity
+        self.weights = weights
+        self.values = values
+        self.n = n
+
+
+
+    def get_max_value(self):
+        sum_v = [[0 for i in range(self.capacity+1)] for j in range(self.n+1)]
+
+        for i in range(1,self.n+1):
+            for j in range(1,self.capacity+1):
+                # sum_v[i][0]=0
+                #  sum_v[0][j]=0
+                sum_v[i][j] = sum_v[i - 1][j]
+                if j-self.weights[i-1]>=0 :  ##这里是i-1，因为weights数组是从0开始的
+                    # 这个判断是背包总容量够放当前物体
+                    sum_v[i][j] = max(sum_v[i-1][j-self.weights[i-1]]+self.values[i-1], sum_v[i-1][j])
+        self.print_matrix(sum_v)
+        return sum_v[self.n-1][self.n-1]
+
+    def print_matrix(self,matrix):
+        for i in range(len(matrix)):
+            for j in range(len(matrix[0])):
+                print(matrix[i][j],end=" ")
+            print()
+
+def bag(n, c, w, v):
+    """
+    测试数据：
+    n = 6  物品的数量，
+    c = 10 书包能承受的重量，
+    w = [2, 2, 3, 1, 5, 2] 每个物品的重量，
+    v = [2, 3, 1, 5, 4, 3] 每个物品的价值
+    """
+    # 置零，表示初始状态
+    value = [[0 for j in range(c + 1)] for i in range(n + 1)]
+    for i in range(1, n + 1):
+        for j in range(1, c + 1):
+            value[i][j] = value[i - 1][j]
+            # 背包总容量够放当前物体，遍历前一个状态考虑是否置换
+            if j >= w[i - 1] and value[i][j] < value[i - 1][j - w[i - 1]] + v[i - 1]:
+                value[i][j] = value[i - 1][j - w[i - 1]] + v[i - 1]
+    for x in value:
+        print(x)
+    return value
+
+
+if __name__ == '__main__':
+    num = 5
+    capacity = 10
+    weight_list = [2, 2, 6, 5, 4]
+    value_list = [6, 3, 5, 4, 6]
+    q = Bag(num, capacity, weight_list, value_list)
+    q.get_max_value()
+    bag(num,capacity,weight_list,value_list)

raw/datastructre/__init__.py

@@ -0,0 +1,42 @@
+bestV = 0
+ans = []
+wi = []
+vi = []
+w = 0
+n = 0
+
+
+def bag(n_, w_, vi_, wi_):
+    global bestV, wi, vi, w, n
+    wi = wi_
+    vi = vi_
+    w = w_
+    n = n_
+    backtrace(0, 0, 0,[])
+
+
+
+def backtrace(i, sum_v, sum_w, result):
+    global bestV,ans
+    if i >= n:
+        if bestV<sum_v:
+            bestV = sum_v
+            print(result)
+            ans = result
+        return
+    if wi[i] + sum_w > w:
+        backtrace(i+1,sum_v,sum_w,result)
+    else:
+        result.append(i)
+        backtrace(i + 1, sum_v+vi[i], sum_w+wi[i], result.copy())
+        result.pop()
+        backtrace(i+1,sum_v,sum_w,result)
+
+if __name__ == '__main__':
+    num = 5
+    capacity = 10
+    weight_list = [2, 2, 6, 5, 4]
+    value_list = [6, 3, 5, 4, 6]
+    bag(num, capacity, value_list,weight_list)
+    print(ans)
+    print(bestV)

raw/datastructre/algorithm_method/01bag.py

@@ -0,0 +1,32 @@
+def gen_power_set(L):
+    power_set = []
+    for i in range(2**len(L)):
+        bin_str = get_binary_rep(i, len(L))
+
+        sub_set = []
+        for j in range(len(L)):
+            if bin_str[j] == '1':
+                sub_set.append(L[j])
+        power_set.append(sub_set)
+
+    return power_set
+
+# 物品转化为二进制表示
+
+## 我们可以把输入集合当做一个元素的列表，任意一个子集合看成是一个只包含了0,1的字符串，0表示不包含指定元素，1表示包含指定元素，那么全0就表示空集，全1就表示包括所有元素的集合（输入集合）。因此0–2727所有的数的2进制就代表了输入集合的所有子集，也就是找到了问题的全部子空间。
+def get_binary_rep(n, num_digital):
+    result = ''
+    while n > 0:
+        result = str(n % 2) + result
+        n = n // 2
+
+    if len(result) > num_digital:
+        raise ValueError("not enough digits")
+
+    for i in range(num_digital - len(result)):
+        result = '0' + result
+
+    return result
+
+if __name__ == '__main__':
+   print( gen_power_set(['a','b','c']))

raw/datastructre/algorithm_method/01bagbacktrace.py

@@ -0,0 +1,17 @@
+#
+# void backtrack(int t)          //t表示递归深度，即当前扩展节点在解空间树的深度
+# {
+#     if ( t > n ) output(x);    //n控制递归深度，如果算法已经搜索到叶节点，记录输出可行解X
+#     else
+#     {
+#         for(int i = f(n,t) ; i <= g(n,t) ; i++)  //在深度t，i从未搜索过得起始编号到终止编号
+#         {
+#             x[t] = h(i);       //查看i这个点的值是否满足题目的要求
+#             if( constraint(t) && bound(t))
+#                 backtrack(t+1)
+#        //constraint（t）为true表示在当前扩展节点处x[1:t]的取值满足问题的约束条件；
+#        //bound(t)为true表示当前扩展节点取值没有使目标函数越界；
+#        //为true表示还需要进一步的搜索子树，否则减去子树。
+#          }
+#     }
+# }

raw/datastructre/algorithm_method/01bagbaoli.py

@@ -0,0 +1,56 @@
+
+
+#
+# count = 1
+#
+# def queen(A, cur=0):
+#     global count
+#     if cur == len(A):
+#         print("-----------",count,"---------")
+#
+#         print(A)
+#         print()
+#         count +=1
+#         return
+#     for col in range(len(A)):
+#         A[cur], flag = col, True
+#         for row in range(cur):
+#             if A[row] == col or abs(col - A[row]) == cur - row:
+#                 flag = False
+#                 break
+#         if flag:
+#             queen(A, cur+1)
+
+def check(board,row,col):
+    i = 0
+    while i < row:
+        if abs(col-board[i]) in (0,abs(row-i)):
+            return False
+        i += 1
+    return True
+
+def EightQueen(board,row):
+    blen = len(board)
+    if row == blen:    # 来到不存在的第九行了
+        printBoard(board)
+        return True
+    col = 0
+    while col < blen:
+        if check(board,row,col):
+            board[row] = col
+            if EightQueen(board,row+1):
+                return True
+        col += 1
+    return False
+
+def printBoard(board):
+    '''为了更友好地展示结果 方便观察'''
+    import sys
+    for i,col in enumerate(board):
+        sys.stdout.write('□ ' * col + '■ ' + '□ ' * (len(board) - 1 - col))
+        print()
+
+if __name__ == '__main__':
+
+    # queen([None]*8)
+    EightQueen([-1]*8,8)