更新

Archer/addTwoNumbers/20181207-addTwoNumbers-Archer.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python
+# -*- coding:utf-8 -*-
+
+class Node(object):
+     """创建节点"""
+     def __init__(self, elem):
+         self.elem = elem
+         self.next = None  # 初始设置下一节点为空
+
+class Linklist(object):
+    """节点的一系列操作"""
+    def __init__(self,node):
+        self.head = node
+
+    def is_empty(self):   #判断节点是否为空
+        return self.head == None
+
+    def append(self,item):   #在尾部添加节点
+        node = Node(item)
+        if self.is_empty():
+            self.head = node
+        else:
+            cur = self.head
+            while cur.next != None:
+                cur = cur.next
+            cur.next = node
+
+    def delete(self,item):  #删除值为item的节点
+        if self.is_empty():
+            print "Null"
+        else:
+            curNow = self.head
+            cur = None
+            while curNow != None:
+                if curNow.elem == item:
+                    if curNow == self.head:
+                        self.head = curNow.next
+                    else:
+                        cur.next = curNow.next
+                    break
+                else:
+                    cur = curNow
+                    curNow = curNow.next
+
+    def travel(self):   # 遍历节点
+        if self.is_empty():
+            print "Null"
+        else:
+            cur = self.head
+            while cur != None:
+                print cur.elem
+                cur = cur.next
+
+if __name__ == "__main__":
+
+    a = 619    #加数1
+    b = 10     #加数2
+    al = Linklist(None)
+    bl = Linklist(None)
+    add = Linklist(Node(0))
+
+    # 将加数1变成逆序链表
+    c = a
+    if c != 0 :
+        while c != 0:
+            al.append(c%10)
+            c /= 10
+    else:
+        al.append(0)
+
+    # 将加数2变成逆序链表
+    d = b
+    if d != 0:
+        while d != 0:
+            bl.append(d%10)
+            d /= 10
+    else:
+        bl.append(0)
+
+    l1 = al.head
+    l2 = bl.head
+    la = add.head
+
+    c_l1= l1
+    c_l2 = l2
+    c_la = la
+
+    ext = 0   #加法中的进位
+
+    while c_l1 != None or c_l2 != None:
+        if c_l1 == None:   # 如果到了加数1的尾端，则执行以下操作
+            while c_l2 != None:
+                temp = c_l2.elem + ext
+                if temp/10:
+                    c_la.elem = temp %10
+                    ext = 1
+                else:
+                    c_la.elem = temp
+                    ext = 0
+                c_l2 = c_l2.next
+                c_la.next = Node(0)
+                c_la = c_la.next
+        if  c_l2 == None : # 如果到了加数2的尾端，则执行以下操作
+            while c_l1 != None:
+                temp = c_l1.elem + ext
+                if temp/10:
+                    c_la.elem = temp%10
+                    ext = 1
+                else:
+                    c_la.elem = temp
+                    ext = 0
+                c_l1 = c_l1.next
+                c_la.next = Node(0)
+                c_la = c_la.next
+        if c_l1 != None and c_l2 != None : # 如果两个加数的链表都还没到尾端，则执行以下操作
+            temp = c_l1.elem + c_l2.elem +ext
+            if temp / 10:
+                c_la.elem = temp % 10
+                ext = 1
+            else:
+                c_la.elem = temp
+                ext = 0
+            c_l1 = c_l1.next
+            c_l2 = c_l2.next
+            c_la.next = Node(0)
+            c_la = c_la.next
+
+
+
+    if ext == 1: #如果进位为1，则最后应该加上1
+        c_la.elem = 1
+
+    #上面循环加法后，会多出来一个结点，下面删除
+    c_la = la
+    pre_c_la = c_la
+    while c_la != None:
+        if c_la.next == None:
+            if c_la == la:
+                c_la = None
+            elif c_la.elem == 0:  # 该结点为0才是冗余的，如果不为0，则是为进位的1，不能删除
+                pre_c_la.next = None
+                break
+        pre_c_la = c_la
+        c_la = c_la.next
+
+    add.travel()  # 遍历加法得到的结果链表
+

Archer/addTwoNumbers/addTwoNumbers说明及复盘.md

@@ -0,0 +1,13 @@
+# 算法实现：(详细见代码文档) #
+
+# 给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。您可以假设除了数字 0 之外，这两个数都不会以 0 开头。 #
+
+#思路#
+1.循环从两个逆序列表l1、l2中取出整数相加得到temp（还需要加上进位值ext）
+2、判断temp/10，看是否需要进位，如果需要进位，则进位值ext=1，若否，则ext=0，并将temp%10赋值给和值列表la。
+3、当循环到其中一个列表的末尾时，继续循环另一个列表执行第二步，直至完成
+
+
+# 复盘 #
+
+应该还可以改进另一种算法，更简洁

Archer/readme.md

@@ -1,5 +1,5 @@
-# Archer贡献内容
+##1203-1205打卡 ##
+**双数之和的一个查找，只实现了最简单的方式，但是，哈希表的解决方案还未完善，没有解决哈希冲突。** 
 
-
-
-双数之和的一个查找，只实现了最简单的方式，但是，哈希表的解决方案还未完善，没有解决哈希冲突。
+##1206-1208 打卡##
+**给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。您可以假设除了数字 0 之外，这两个数都不会以 0 开头。** 

Archer/twoSum/twoSum.py

@@ -27,9 +27,7 @@ def twoSum(nums, target):
             if temp == nums[j]:
                 return [i, j]
     '''
-
     # 解法3，用哈希表，空间换时间，第一次循环将数组的值放入哈希表中，第二次循环从哈希表中取出值(待完善)
-
     map_a = dict()
 
     k = len(nums)
@@ -41,18 +39,24 @@ def twoSum(nums, target):
     for i in range(0, k):
         temp = target - nums[i]
         if temp in map_a and map_a[temp][0]!=i:
-            return [map_a[temp][0], i]
+            return [i, map_a[temp][0]]
     print "No two sum solution"
 
-    # 解法4，用哈希表，一边把数组元素放到哈希表中，一边判断哈希表中是否有满足和的两个整数（待完善）
+
     '''
+    # 解法4，用哈希表，一边把数组元素放到哈希表中，一边判断哈希表中是否有满足和的两个整数（待完善）
     map_a = dict()
     k = len(nums)
-
     for i in range(0, k):
-        map_a[nums[i]] = (i, nums[i])
-        print map_a.items()
         temp = target - nums[i]
-        if temp in map_a and map_a[temp][0]!=i:
-            return [map_a[temp][0], i]
+        if temp in map_a :
+            print map_a.items()
+            return [map_a[temp], i]
+        map_a[nums[i]] =  i
     '''
+
+a = [3, 3, 4, 5]
+
+b = twoSum(a,8)
+
+print b

Archer/twoSum/twoSum说明及复盘.md

@@ -0,0 +1,16 @@
+# 算法实现：(详细见代码文档) #
+
+# 双数之和的一个查找，只实现了最简单的方式，但是，哈希表的解决方案还未完善，没有解决哈希冲突。 #
+
+# 复盘 #
+
+1. 如果两个循环，先循环保存到字典，再循环查找字典里面的键-值
+ 困局：哈希冲突，不能把相同的值保存为两个不同的键
+
+2. 一个循环
+	-   把列表的元素按(元素：索引)存储到字典里时，用目标值target去减下一个要存储的列表元素得到寻找值temp，再找字典里有没有与temp值相同的键，有的话，输出这个键对应的值和下一个要存储的列表的索引。
+	(用下一个列表元素产生的差值找字典中存储的列表)
+	- 把target与列表元素的差值按(差值：该元素索引)存储到字典里，再用下一个要存储的列表元素查找字典，如果有，说明存在另一个列表元素和这个要存储的列表元素相加得到目标值，输出查找到的字典差值中的索引和下一个要存储的列表元素的索引
+	(用下一个列表元素找字典中存储的列表元素产生的差值)
+
+以上两种方法的重点在于，先判断后存储，避免了字典中同时存在要拿来比较的元素，自己比较自己的情况，也避免了哈希冲突，因为即便是由列表中两个相同元素相加得到目标值，也在将列表存储到字典之前，也即产生哈希冲突之前已经判断完成输出了。

codingling/LeetCode-01-twosum/01.TwoSum两数之和.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+# @Author: LiLing
+# @Date:   2018-10-02 19:07:51
+# @Last Modified by:   Liling
+# @Last Modified time: 2018-10-02 19:16:24
+"""
+给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。
+
+你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。
+
+示例:
+
+给定 nums = [2, 7, 11, 15], target = 9
+
+因为 nums[0] + nums[1] = 2 + 7 = 9
+所以返回 [0, 1]
+"""
+class Solution:
+    def twoSum(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: List[int]
+        """
+        for i in range(len(nums)):
+        	res = nums[i+1:]
+        	resnum = target-nums[i]
+        	if resnum in res:
+        		j = res.index(resnum)
+        		return [i,i+j+1]
+
+class Solution():
+    def twoSum(self, nums, target):
+        hashdict = {}
+        for i, item in enumerate(nums):
+            if (target - item) in hashdict:
+                return (hashdict[target - item], i)
+            hashdict[item] = i
+        return (-1, -1)
+s = Solution()
+print(s.twoSum([2, 7, 11, 15], 9))

codingling/LeetCode-01-twosum/readme.md

@@ -0,0 +1,54 @@
+## 01.TwoSum两数之和
+
+### 题目描述
+
+给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。
+
+你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。
+
+示例:
+
+给定 nums = [2, 7, 11, 15], target = 9
+
+因为 nums[0] + nums[1] = 2 + 7 = 9
+所以返回 [0, 1]
+
+### 思路
+
+第一种思路是比较直观也是复杂度比较高的解法，遍历列表中的每个元素，在剩下的元素中找有没有使得两个数之和为目标值的数。
+
+```python
+class Solution:
+    def twoSum(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: List[int]
+        """
+        for i in range(len(nums)):
+        	res = nums[i+1:]
+        	resnum = target-nums[i]
+        	if resnum in res:
+        		j = res.index(resnum)
+        		return [i,i+j+1]
+```
+
+这种解法的时间复杂度是$O(n^2)$，因为需要遍历，遍历的同时还要在剩下的元素中查找。空间复杂度是O(1)。
+
+
+
+第二种思路是用哈希，也是要遍历列表，但是遍历的同时将当前值及其index存入哈希字典，并且在哈希字典中查找有没有想要的值。
+
+```python
+class Solution():
+    def twoSum(self, nums, target):
+        hashdict = {}
+        for i, item in enumerate(nums):
+            if (target - item) in hashdict:
+                return (hashdict[target - item], i)
+            hashdict[item] = i
+        return (-1, -1)
+```
+
+这种解法的时间复杂度是O(n)，空间复杂度是O(n)。
+