diff --git a/ahead_one_step.py b/ahead_one_step.py
index 99aac57..bb880e3 100644
--- a/ahead_one_step.py
+++ b/ahead_one_step.py
@@ -10,7 +10,7 @@
 """
 
 def ahead_one():
-    a = [i for i in range(10)]
+    a = [i for i in range(1, 11)]
     b = a.pop(0)
     a.append(b)
     return a
diff --git a/average_score.py b/average_score.py
index 081dec1..cb8c05a 100644
--- a/average_score.py
+++ b/average_score.py
@@ -8,7 +8,7 @@
 (2)将这40个成绩按照从高到低的顺序输出出来。
 """
 
-from __future__ import division     #实现精确的除法，例如4/3=1.333333
+#no need to import division from future just change num to float(num) 
 import random
 
 def make_score(num):
@@ -18,7 +18,7 @@ def make_score(num):
 def less_average(score):
     num = len(score)
     sum_score = sum(score)
-    ave_num = sum_score/num
+    ave_num = sum_score/float(num)
     less_ave = [i for i in score if i<ave_num]
     return (ave_num,len(less_ave))
 
@@ -27,4 +27,4 @@ def less_average(score):
     average_num,less_num = less_average(score)
     print 'the score of average is:',average_num
     print "the number of less average is:",less_num
-    print "the every socre is[from big to small]:",sorted(score,reverse=True)
+    print "the every score is[from big to small]:",sorted(score,reverse=True)
diff --git a/binary_tree_python.md b/binary_tree_python.md
index 0dbcfb8..fb695db 100644
--- a/binary_tree_python.md
+++ b/binary_tree_python.md
@@ -416,4 +416,4 @@ bintrees提供了丰富的API,涵盖了通常的多种应用。下面逐条说
     >>> ctree
     BinaryTree({8: 'eight', 9: 'scree'})
      
-###以上只是入门的基本方法啦，还有更多内容，请移不到到文章开头的官方网站。
+###以上只是入门的基本方法啦，还有更多内容，请移到文章开头的官方网站。
diff --git a/longest_increasing_sequence.md b/longest_increasing_sequence.md
new file mode 100644
index 0000000..ee72016
--- /dev/null
+++ b/longest_increasing_sequence.md
@@ -0,0 +1,10 @@
+# 问题简介
+最长公共上升子序列，longest increasing sequence，简称LCIS
+# 思路
+这个问题要由动态规划来解决，时间复杂度是O(n<sup>2</sup>)，空间复杂度是O(n)，建立dp[n]和track[n]    
+意义：
+----
+* dp[i]：以数据a[i]结尾的最长上升序列长度
+* track[i]：数据a[i]作为最长上升序列末项的前一项索引
+
+
diff --git a/longest_increasing_sequence.py b/longest_increasing_sequence.py
new file mode 100644
index 0000000..a1d3938
--- /dev/null
+++ b/longest_increasing_sequence.py
@@ -0,0 +1,31 @@
+#!/usr/bin/python
+#coding: utf-8
+
+def isBiggerCompare(a, b):
+	return a > b
+
+def findLIS(sequence, compare = isBiggerCompare):
+	n = len(sequence)
+	dp = [0 for i in range(n)]
+	track = [-1 for i in range(n)]
+	ans = 1
+	for i in range(1, n):
+		MAX = 0
+		for j in range(i):
+			if compare(sequence[i], sequence[j]) and MAX < dp[j]:
+				MAX = dp[j]
+				track[i] = j
+				# track[i] sequence[i]作为最长上升序列末项的前一项
+		dp[i] = MAX + 1
+		# dp[i] 以sequence[i]结尾的最长上升序列长度
+		if dp[i] > dp[ans]:
+			ans = i
+	ansList = [sequence[ans]]
+	while track[ans] != -1:
+		ans = track[ans]
+		ansList.insert(0, sequence[ans])
+	return ansList
+
+if __name__ == '__main__':
+	s = [3, 1, 2, 1, 4, 3, 5]
+	print findLIS(s)
diff --git a/quick_sort.md b/quick_sort.md
index 362a14a..1d7c542 100644
--- a/quick_sort.md
+++ b/quick_sort.md
@@ -1,10 +1,10 @@
-#问题
+# 问题
 
 快速排序，这是一个经典的算法，本文给出几种python的写法，供参考。
 
 特别是python能用一句话实现快速排序。
 
-#思路说明
+# 思路说明
 
 快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。
 
@@ -16,7 +16,7 @@
 
 设当前待排序的无序区为R[low..high]，利用分治法可将快速排序的基本思想描述为：
 
-###分解：
+### 分解：
 
 在R[low..high]中任选一个记录作为基准(Pivot)，以此基准将当前无序区划分为左、右两个较小的子区间R[low..pivotpos-1)和R[pivotpos+1..high]，并使左边子区间中所有记录的关键字均小于等于基准记录(不妨记为pivot)的关键字pivot.key，右边的子区间中所有记录的关键字均大于等于pivot.key，而基准记录pivot则位于正确的位置(pivotpos)上，它无须参加后续的排序。
 
@@ -28,16 +28,17 @@ R[low..pivotpos-1].keys≤R[pivotpos].key≤R[pivotpos+1..high].keys
 
 其中low≤pivotpos≤high。
 
-###求解：
+### 求解：
 
 通过递归调用快速排序对左、右子区间R[low..pivotpos-1]和R[pivotpos+1..high]快速排序。
 
-###组合：
+### 组合：
 
 因为当"求解"步骤中的两个递归调用结束时，其左、右两个子区间已有序。对快速排序而言，"组合"步骤无须做什么，可看作是空操作。
 
-#解决(Python)
+### 解决(Python)
 	
+```python
 	#!/usr/bin/env python
 	#coding:utf-8
 	
@@ -64,11 +65,11 @@ R[low..pivotpos-1].keys≤R[pivotpos].key≤R[pivotpos+1..high].keys
 	
 	        return less + pivotList + more
 	
-	#方法2
-	#将方法1写的更紧凑，彰显python特点
-	
+	# 方法2
+	# 分为<, >, = 三种情况，如果分为两种情况的话函数调用次数会增加许多，以后几个好像都有相似的问题
+	# 如果测试1000个100以内的整数，如果分为<, >=两种情况共调用函数1801次，分为<, >, = 三种情况，共调用函数201次
 	def qsort(L):
-	    return (qsort([y for y in L[1:] if y <  L[0]]) + L[:1] + qsort([y for y in L[1:] if y >= L[0]])) if len(L) > 1 else L
+	    return (qsort([y for y in L[1:] if y <  L[0]]) + L[:1] + [y for y in L[1:] if y == L[0] + qsort([y for y in L[1:] if y > L[0]])) if len(L) > 1 else L
 	
 	#方法3
 	#基本思想同上，只是写法上又有所变化
@@ -106,3 +107,4 @@ R[low..pivotpos-1].keys≤R[pivotpos].key≤R[pivotpos+1..high].keys
 	    print qSort(a)
 	
 	    print qs(a)
+```
diff --git a/quick_sort.py b/quick_sort.py
index 7d35746..83f3b68 100644
--- a/quick_sort.py
+++ b/quick_sort.py
@@ -74,7 +74,7 @@ def qsort(list):
         return []
     else:
         pivot = list[0]
-        less = [x for x in list     if x <  pivot]
+        less = [x for x in list[1:] if x <  pivot]
         more = [x for x in list[1:] if x >= pivot]
         return qsort(less) + [pivot] + qsort(more)
 """