diff --git "a/022-\346\240\210\347\232\204\345\216\213\345\205\245\345\274\271\345\207\272\345\272\217\345\210\227/README.md" "b/022-\346\240\210\347\232\204\345\216\213\345\205\245\345\274\271\345\207\272\345\272\217\345\210\227/README.md"
index 36490de..3ed0dd8 100644
--- "a/022-\346\240\210\347\232\204\345\216\213\345\205\245\345\274\271\345\207\272\345\272\217\345\210\227/README.md"
+++ "b/022-\346\240\210\347\232\204\345\216\213\345\205\245\345\274\271\345\207\272\345\272\217\345\210\227/README.md"
@@ -90,50 +90,21 @@ using namespace std;
 class Solution
 {
 public:
-    bool IsPopOrder(vector<int> pushV,vector<int> popV)
-    {
-
-        if(pushV.size( ) == 0 || popV.size( ) == 0)
-        {
+   bool IsPopOrder(vector<int> pushV,vector<int> popV) {
+        if(pushV.empty() || popV.empty() || pushV.size()!=popV.size())
             return false;
-        }
         stack<int> s;
-        int push, pop;
-
-        s.push(pushV[0]);
-        debug <<"push" <<pushV[0] <<endl;
-
-        for(push = 0, pop = 0;
-            push < pushV.size() && pop < popV.size( );)
-        {
-            if(s.empty( ) != true && s.top( ) == popV[pop])        //  当前栈顶元素正好是出栈序列中的元素
-            {
-                debug <<"pop"<<popV[pop] <<endl;
-                // 模拟出栈的过程
-                s.pop( );
-                pop++;
-            }
-            else
-            {
-
-                //  模拟入栈的过程
-                s.push(pushV[++push]);
-                debug <<"push" <<pushV[push] <<endl;
-
+        int j=0;
+        for(int i=0;i<pushV.size();++i){
+            s.push(pushV[i]);
+            while(!s.empty()&&s.top()==popV[j]){
+                s.pop();
+                ++j;
             }
         }
-        if(s.empty( ) == true)
-        {
+        if(s.empty())
             return true;
-        }
-        else
-        {
-            return false;
-        }
-
-
-
-
+        return false;
     }
 };
 
diff --git "a/028-\345\255\227\347\254\246\344\270\262\347\232\204\346\216\222\345\210\227/README.md" "b/028-\345\255\227\347\254\246\344\270\262\347\232\204\346\216\222\345\210\227/README.md"
index 3f3e2c7..a6da055 100644
--- "a/028-\345\255\227\347\254\246\344\270\262\347\232\204\346\216\222\345\210\227/README.md"
+++ "b/028-\345\255\227\347\254\246\344\270\262\347\232\204\346\216\222\345\210\227/README.md"
@@ -143,92 +143,30 @@ public:
 3.    接着，固定第一个字符，求后面所有字符的排列。这个时候我们仍把后面的所有字符分成两部分：后面字符的第一个字符，以及这个字符之后的所有字符。然后把第一个字符逐一和它后面的字符交换
 
 ```cpp
-#include <iostream>
-#include <algorithm>
-#include <vector>
-#include <string>
-
-using namespace std;
-
-//  调试开关
-#define __tmain main
-
-#ifdef __tmain
-
-#define debug cout
-
-#else
-
-#define debug 0 && cout
-
-#endif // __tmain
-
-
-class Solution
-{
-protected:
-    vector<string> m_res;
-
-public:
-
-    vector<string> Permutation(string str)
-    {
-        m_res.clear( );
-
-        if(str.empty( ) == true)
-        {
-            return m_res;
-        }
-        PermutationRecursion(str, 0);
-
-        sort(m_res.begin( ), m_res.end( ));
-        return m_res;
+vector<string> Permutation(string str) {
+        vector<string> v1;
+        if(str.size()<= 0 || str.size()>9 )//排除异常情况
+            return v1;
+        PermutationHelp(v1, 0, str);
+        return v1;
     }
-
-
-    void PermutationRecursion(string str, int begin)
-    {
-        if(str[begin] == '\0')
-        {
-            debug <<str <<endl;
-            m_res.push_back(str);
-        }
-        else
-        {
-            for(int i = begin;
-                str[i] != '\0';
-                i++)
-            {
-                //debug <<str[i] <<str[begin] <<endl;
-                if(!HasDuplicate(str, begin, i))
-                {
-                    swap(str[i], str[begin]);
-                    debug <<"swap " <<str[i] <<"(" <<i <<")" <<" and " <<str[begin] <<"(" <<begin <<")" <<endl;
-                    PermutationRecursion(str, begin + 1);
-                    //copy(str.begin( ), str.degin( ) + i, ostream_iterator<char>(cout," "));
-                    swap(str[i], str[begin]);
-                }
-            }
-        }
-    }
-    
-private:
-    //find duplicate of str[i] in str[k,i)
-    bool HasDuplicate(string& str, int k, int i) const {
-		for (int p = k; p < i; p++)
-			if (str[p] == str[i]) return true;
-
-		return false;
-	}
-};
-
-int __tmain( )
-{
-    Solution solu;
-    solu.Permutation("abc");
-
-    return 0;
-}
+    void PermutationHelp(vector<string> &ans, int k, string str) //遍历第k位的所有可能
+   {
+      if(k == (str.size() - 1))//单次递归终止条件
+          ans.push_back(str);
+      unordered_set<char> us;//保存字符串中字符的无序集合
+      sort(str.begin() + k, str.end());
+      for(int i = k; i < str.size(); i++)
+      {
+         if(us.find(str[i]) == us.end())
+         {
+            us.insert(str[i]);
+            swap(str[i], str[k]);
+            PermutationHelp(ans, k + 1, str);
+            swap(str[i], str[k]);
+         }
+      }
+   }
 ```
 
 #STL的next_permutation求全排列
@@ -263,4 +201,51 @@ public:
     }
 };
 ```
+# 字符串的全组合
+```cpp
+#include<iostream>
+#include<vector>
+#include<cstring>
+#include<assert.h>
+using namespace std;
+
+void Combination(char *string ,int number,vector<char> &result);
+
+void Combination(char *string)
+{
+    assert(string != NULL);
+    vector<char> result;
+    int i , length = strlen(string);
+    for(i = 1 ; i <= length ; ++i)
+        Combination(string , i ,result);
+}
 
+void Combination(char *string ,int number , vector<char> &result)
+{
+    assert(string != NULL);
+    if(number == 0)
+    {
+        static int num = 1;
+        printf("第%d个组合\t",num++);
+        vector<char>::iterator iter = result.begin();
+        for( ; iter != result.end() ; ++iter)
+            printf("%c",*iter);
+        printf("\n");
+        return ;
+    }
+    if(*string == '\0')
+        return ;
+    result.push_back(*string);
+    Combination(string + 1 , number - 1 , result);
+    result.pop_back();
+    Combination(string + 1 , number , result);
+}
+
+int main(void)
+{
+    char str[] = "abc";
+    Combination(str);
+    return 0;
+}
+
+```
diff --git "a/028-\345\255\227\347\254\246\344\270\262\347\232\204\346\216\222\345\210\227/\345\255\227\347\254\246\344\270\262\347\232\204\345\205\250\347\273\204\345\220\210.cpp" "b/028-\345\255\227\347\254\246\344\270\262\347\232\204\346\216\222\345\210\227/\345\255\227\347\254\246\344\270\262\347\232\204\345\205\250\347\273\204\345\220\210.cpp"
new file mode 100644
index 0000000..df8752c
--- /dev/null
+++ "b/028-\345\255\227\347\254\246\344\270\262\347\232\204\346\216\222\345\210\227/\345\255\227\347\254\246\344\270\262\347\232\204\345\205\250\347\273\204\345\220\210.cpp"
@@ -0,0 +1,38 @@
+void Combination(char *string ,int number,vector<char> &result);
+
+void Combination(char *string)
+{
+    assert(string != NULL);
+    vector<char> result;
+    int i , length = strlen(string);
+    for(i = 1 ; i <= length ; ++i)
+        Combination(string , i ,result);
+}
+
+void Combination(char *string ,int number , vector<char> &result)
+{
+    assert(string != NULL);
+    if(number == 0)
+    {
+        static int num = 1;
+        printf("第%d个组合\t",num++);
+
+        vector<char>::iterator iter = result.begin();
+        for( ; iter != result.end() ; ++iter)
+            printf("%c",*iter);
+        printf("\n");
+        return ;
+    }
+    if(*string == '\0')
+        return ;
+    result.push_back(*string);
+    Combination(string + 1 , number - 1 , result);
+    result.pop_back();
+    Combination(string + 1 , number , result);
+}
+int main(void)
+{
+    char str[] = "abc";
+    Combination(str);
+    return 0;
+}
diff --git "a/031-\350\277\236\347\273\255\345\255\220\346\225\260\347\273\204\347\232\204\346\234\200\345\244\247\345\222\214/README.md" "b/031-\350\277\236\347\273\255\345\255\220\346\225\260\347\273\204\347\232\204\346\234\200\345\244\247\345\222\214/README.md"
index 3287ba5..785d77a 100644
--- "a/031-\350\277\236\347\273\255\345\255\220\346\225\260\347\273\204\347\232\204\346\234\200\345\244\247\345\222\214/README.md"
+++ "b/031-\350\277\236\347\273\255\345\255\220\346\225\260\347\273\204\347\232\204\346\234\200\345\244\247\345\222\214/README.md"
@@ -147,64 +147,22 @@ class Solution
 public:
 
     int FindGreatestSumOfSubArray(vector<int> array)
-    {
-
-        if(array.size( ) == 0)
-        {
-            return 0;
-        }
-
-
-
-#ifdef __tmain
-
-        int temp, start, end;
-
-#endif  // __tmain
-
-        int maxSum = INT_MIN;
-        dp[0] = array[0];
-
-        for(unsigned int i = 1; i < array.size( ); i++)
+    { 
+        if(array.size()<=0)
+           return -1;
+        int nsum_value = array[0];   //初始化f(i-1)
+        int max_sum = -1;
+        for(int i = 1; i < array.size(); i++)
         {
-
-            if(dp[i - 1] <= 0)
-            {
-                dp[i] = array[i];
-
-#ifdef __tmain
-
-                temp = i;
-
-#endif  // __tmain
-
-            }
+            if(nsum_value <= 0)     
+                nsum_value = array[i];
             else
-            {
-                dp[i] = array[i] + dp[i - 1];
-            }
-
-
-            if(dp[i] > maxSum)
-            {
-                maxSum = dp[i];
-
-#ifdef __tmain
-
-                start = temp;
-                end = i;
-
-#endif  // __tmain
-            }
-
+                nsum_value += array[i];
+            
+            if(nsum_value > max_sum)
+                max_sum = nsum_value;
         }
-
-        debug <<"[" <<start <<", " <<end <<"] = " <<maxSum <<endl;
-
-        return maxSum;
-
-
-
+        return max_sum;
     }
 
 };
diff --git "a/032-\344\273\2161\345\210\260n\346\225\264\346\225\260\344\270\2551\345\207\272\347\216\260\347\232\204\346\254\241\346\225\260/README.md" "b/032-\344\273\2161\345\210\260n\346\225\264\346\225\260\344\270\2551\345\207\272\347\216\260\347\232\204\346\254\241\346\225\260/README.md"
index f8a3531..971eccc 100644
--- "a/032-\344\273\2161\345\210\260n\346\225\264\346\225\260\344\270\2551\345\207\272\347\216\260\347\232\204\346\254\241\346\225\260/README.md"
+++ "b/032-\344\273\2161\345\210\260n\346\225\264\346\225\260\344\270\2551\345\207\272\347\216\260\347\232\204\346\254\241\346\225\260/README.md"
@@ -367,6 +367,18 @@ N=123，个位出现1的个数为13:1,11,21，…，91,101,111,121。十位出
 3.    如果百位上的数字为1，则百位上出现1的次数不仅受更高位影响，还受低位影响。例如12113，受高位影响出现1的情况：100~199,1100~1199,2100~2199，…，11100~11199，共1200个，但它还受低位影响，出现1的情况是12100~12113，共114个，等于低位数字113+1。
 
 ```cpp
+  /*
+    1)此位大于1，这一位上1的个数有 ([n / 10^(b+1) ] + 1) * 10^b
+    2)此位等于0，为 ([n / 10^(b+1) ] ) * 10^b
+    3)此位等于1，在0的基础上加上n mod 10^b + 1
+    
+    举个例子：
+    30143:
+    由于3>1,则个位上出现1的次数为(3014+1)*1
+    由于4>1,则十位上出现1的次数为(301+1)*10
+    由于1=1，则百位上出现1次数为(30+0)*100+(43+1)
+    由于0<1，则千位上出现1次数为(3+0)*1000
+  */
 class Solution
 {
 public:
@@ -379,37 +391,29 @@ public:
      */
     int NumberOf1Between1AndN_Solution(int n)
     {
-        long count = 0;
-
-        long i = 1;
-
-        long current = 0,after = 0,before = 0;
-
-        while((n / i) != 0)
-        {
-            before = n / (i * 10);
-            current = (n / i) % 10;
-            after = n - (n / i) * i;
-            if (current > 1)
-            {
-                count = count + (before + 1) * i;
-            }
-            else if (current == 0)
-            {
-                 count = count + before * i;
-            }
-            else if(current == 1)
-            {
-                count = count + before * i + after + 1;
-            }
-            debug <<before <<" " <<current <<" " <<after <<", count = " <<count <<endl;
-
-
-            i = i * 10;
-
-        }
-
-        return count;
+        if(n <= 0)  
+           return 0;  
+        long long count = 0;    //统计1出现的次数  
+        long long current;    //当前位  
+        long long base = 1; //当前位的基  
+        long long remain = 0;   //当前位为1时，后面位剩余的数（即不完整的部分）中1出现的次数  
+        while(n)  
+        {  
+           current = n%10;  
+           n = n/10;  
+  
+           if(current > 1)  
+              count += (n+1)*base;  
+           else if(current == 1)  
+              count += n*base + (remain+1);  
+           else  
+              count += n*base;  
+      
+           //下一位要用到的基和剩余不完整部分值  
+           remain += current*base;   
+           base *= 10;  
+        }  
+        return count;  
 
     }
 };
diff --git "a/045-\345\255\251\345\255\220\344\273\254\347\232\204\346\270\270\346\210\217(\345\234\206\345\234\210\344\270\255\346\234\200\345\220\216\345\211\251\344\270\213\347\232\204\346\225\260)/README.md" "b/045-\345\255\251\345\255\220\344\273\254\347\232\204\346\270\270\346\210\217(\345\234\206\345\234\210\344\270\255\346\234\200\345\220\216\345\211\251\344\270\213\347\232\204\346\225\260)/README.md"
index 971e417..bc5e41d 100644
--- "a/045-\345\255\251\345\255\220\344\273\254\347\232\204\346\270\270\346\210\217(\345\234\206\345\234\210\344\270\255\346\234\200\345\220\216\345\211\251\344\270\213\347\232\204\346\225\260)/README.md"
+++ "b/045-\345\255\251\345\255\220\344\273\254\347\232\204\346\270\270\346\210\217(\345\234\206\345\234\210\344\270\255\346\234\200\345\220\216\345\211\251\344\270\213\347\232\204\346\225\260)/README.md"
@@ -89,48 +89,35 @@ class Solution
 public:
     int LastRemaining_Solution(unsigned int n, unsigned int m)
     {
-        if(n < 1 || m < 1)
-        {
-            return -1;
-        }
-
-
-        vector<int> numbers;
-
-        for(int i = 0; i < n; i++)
-        {
-            numbers.push_back(i);
-            debug <<i <<" ";
-        }
-        debug <<endl;
-
-        unsigned int cntN = 0;
-        unsigned int cntM = -1;
-        while(numbers.size( ) > 1)
-        {
-            debug <<"count = " <<1 <<", num[" <<cntN <<"] = " <<numbers[cntN] <<endl;
-            for(int cntM = 1; cntM < m; cntM++)
-            {
-                ++cntN;
-                cntN %= numbers.size( );
-                debug <<"count = " <<cntN + 1 <<", num[" <<cntN <<"] = " <<numbers[cntN] <<endl;
-            }
-
-            debug <<numbers[cntN] <<" leave the list" <<endl;
-            numbers.erase(numbers.begin( ) + cntN);
-
-#ifdef debug
-            copy(numbers.begin( ),
-                 numbers.end( ),
-                 ostream_iterator< int >(cout, " "));
-            debug <<endl;
-#endif // debug
-
-        }
-
-        //  循环结束的时候, cntN = 1
-        debug <<"count = " <<1 <<", num[" <<cntN <<"] = " <<numbers[cntN] <<endl;
-        return numbers[0];
+		if (n < 1 || m < 1)
+			return -1;
+
+		list<int> listInt;
+		unsigned i;
+		//初始化链表  
+		for (i = 0; i < n; i++)
+			listInt.push_back(i);
+
+		list<int>::iterator iterCurrent = listInt.begin();
+		while (listInt.size() > 1)
+		{
+			//前进m - 1步  
+			for (i = 0; i < m - 1; i++)
+			{
+				if (++iterCurrent == listInt.end())
+					iterCurrent = listInt.begin();
+			}
+			//临时保存删除的结点  
+			list<int>::iterator iterDel = iterCurrent;
+			if (++iterCurrent == listInt.end())
+				iterCurrent = listInt.begin();
+			cout << *iterDel << endl;
+			//删除结点  
+			listInt.erase(iterDel);
+		}
+
+		return *iterCurrent;
+	 
     }
 };
 
@@ -235,4 +222,4 @@ public:
         }
     }
 };
-```
\ No newline at end of file
+```
diff --git "a/057-\345\210\240\351\231\244\351\223\276\350\241\250\344\270\255\351\207\215\345\244\215\347\232\204\347\273\223\347\202\271/README.md" "b/057-\345\210\240\351\231\244\351\223\276\350\241\250\344\270\255\351\207\215\345\244\215\347\232\204\347\273\223\347\202\271/README.md"
index 1b1c49b..c81a000 100644
--- "a/057-\345\210\240\351\231\244\351\223\276\350\241\250\344\270\255\351\207\215\345\244\215\347\232\204\347\273\223\347\202\271/README.md"
+++ "b/057-\345\210\240\351\231\244\351\223\276\350\241\250\344\270\255\351\207\215\345\244\215\347\232\204\347\273\223\347\202\271/README.md"
@@ -72,42 +72,33 @@ class Solution
 public:
     ListNode* deleteDuplication(ListNode* pHead)
     {
-        //设置一个trick, 作为头指针, 这样我们无需单独考虑第一个元素
-        ListNode *first = new ListNode(-1);
-
-        first->next = pHead;
-
-        ListNode *p = pHead;
-        ListNode *last = first;
-
-        while (p != NULL && p->next != NULL)
+       ListNode* firstNode = new ListNode(-1);//新建头结点
+        firstNode->next = pHead;
+        ListNode* lastNode = firstNode;
+        ListNode* pNode = pHead;
+        
+        while(pNode != NULL && pNode->next != NULL)
         {
-            debug <<p->val <<endl;
-
-            //  如果有元素重复
-            if (p->val == p->next->val)
+            if(pNode->val == pNode->next->val)
             {
-                //  就跳过所有重复的数字
-                int val = p->val;
-                while (p != NULL && p->val == val)
-                {
-                    p = p->next;
-                }
-
-                //  此时p指向了非重复的第一个元素
-                //  我们设置last->next = p
-                //  但是此时p-val也可能是重复的,
-                //  因此我们不可以设置last = p
-                //  而是重新进入循环
-                last->next = p;
+                int val = pNode->val;  //保存重复的结点值
+                ListNode* pToBeDel = pNode;
+               while( (pNode != NULL) && (pNode->val == val) )
+               {
+                   pNode = pToBeDel->next; //执行删除
+                   delete pToBeDel;
+                   pToBeDel = nullptr;
+                   pToBeDel = pNode;
+               }
+                lastNode->next = pNode;
             }
-            else
+	        else
             {
-                last = p;
-                p = p->next;
+                lastNode = pNode;
+                pNode = pNode->next;
             }
         }
-        return first->next;
+        return firstNode->next;
     }
 };
 
@@ -194,4 +185,4 @@ public:
     }
 
 };
-```
\ No newline at end of file
+```
diff --git "a/064-\346\225\260\346\215\256\346\265\201\344\271\213\344\270\255\347\232\204\344\270\255\344\275\215\346\225\260/README.md" "b/064-\346\225\260\346\215\256\346\265\201\344\271\213\344\270\255\347\232\204\344\270\255\344\275\215\346\225\260/README.md"
index 439acd8..afe959f 100644
--- "a/064-\346\225\260\346\215\256\346\265\201\344\271\213\344\270\255\347\232\204\344\270\255\344\275\215\346\225\260/README.md"
+++ "b/064-\346\225\260\346\215\256\346\265\201\344\271\213\344\270\255\347\232\204\344\270\255\344\275\215\346\225\260/README.md"
@@ -30,17 +30,17 @@
 -------
 
 
+```
+| 数据结构        |  插入的时间效率        |  得到的中位数的时间效率 |
+|:-------:        ||:-------:            ||:-------:|
+| 没有排序的数组   | O(1)                  | O(n) |
+| 排序的数组       | O(n)                 | O(1) |
+| 排序的链表       | O(n)                  |  O(1) |
+| 二叉搜索树       | 平均O(logn), 最差O(n) |  平均O(logn), 最差O(n) | 
+| AVL树           | O(logn)               | O(1) |
+| 最大堆和最小堆   | O(logn)               | O(1) |
 
-| 数据结构 | 插入的时间效率 | 得到的中位数的时间效率 |
-|:-------:||:-------:||:-------:|
-| 没有排序的数组 | O(1) | O(n) |
-| 排序的数组 | O(n) | O(1) |
-| 排序的链表 | O(n) |  O(1) |
-| 二叉搜索树 | 平均O(logn), 最差O(n) |  平均O(logn), 最差O(n) | 
-| AVL树 | O(logn) | O(1) |
-| 最大堆和最小堆 | O(logn) | O(1) |
-
-
+```
 
 
 
@@ -247,4 +247,4 @@ public    :
     }
 };
 ```
-
\ No newline at end of file
+
diff --git "a/066 \346\225\260\345\255\227\345\272\217\345\210\227\344\270\255\346\237\220\344\270\200\344\275\215\347\232\204\346\225\260\345\255\227" "b/066 \346\225\260\345\255\227\345\272\217\345\210\227\344\270\255\346\237\220\344\270\200\344\275\215\347\232\204\346\225\260\345\255\227"
new file mode 100644
index 0000000..4fe0757
--- /dev/null
+++ "b/066 \346\225\260\345\255\227\345\272\217\345\210\227\344\270\255\346\237\220\344\270\200\344\275\215\347\232\204\346\225\260\345\255\227"	
@@ -0,0 +1,95 @@
+**题目描述**
+
+题目描述
+
+>数字以01234567891011121314...的格式化系列化到一个字符串中，在这个序列中， 第5位（从0开始计数）是5，第13位是1， 第19位是4，等等。请写一个函数，
+求任意第n位对应的数字。
+
+比如：序列中的二弟1001位是什么？
+    首先，序列的前10位是0~9着10个只有一位的数字。显然，第100位在这10个数字之后，因此，可直接跳过这10个数字。然后在从后面紧跟的序列中找地991
+（1001-10）位的数字。
+    接下来180位数字中有90个10~99的两位数，由于991 > 180，所以991在所有的两位数之后。在跳过90个两位数，继续向后找881（811= 991 -180）位；
+    接下来的2700位是900个100~999的三位数，由于811 < 2700，所以881是某一三位数的一位。因为811/3 = 270，且811%3 = 1。这意味着811是从100开始
+的第270个数字即370的中间一位，也就是7.
+```
+#include <iostream>
+#include <math.h>
+using namespace std;
+
+//取得位数为index的数开头的第一个数
+int getFst(int index)
+{
+	if (index == 1)return 0;
+
+	return static_cast<int>(pow(10, index - 1));
+}
+
+//最后取得指定位上的数字
+int getTheNum(int num, int posi, int index)
+{
+	int n = index - posi - 1;
+
+	for (int i = 0; i < n; i++) {
+		num = num / 10;
+	}
+
+	return num % 10;
+}
+
+//位数为n的数一共有多少个
+int cntOfIntegers(int n)
+{
+	if (n == 1)return 10;
+
+	int resu = 1;
+	for (int i = 1; i != n; i++) {
+		resu *= 10;
+	}
+
+	return 9 * resu;
+}
+
+//位数为n的数一共有多少个
+int cntOfIntegers1(int n)
+{
+	if (n == 1)return 10;
+	return 9 * static_cast<int>(pow(10, n - 1));
+}
+
+int numOnPosiN(int n)
+{
+	//输入出错的情况
+	if (n < 0)return -1;
+
+	int index = 1;
+	while (true) {
+		//cnt为位数为index的数一共所占的位数
+		int cnt = cntOfIntegers(index)*index;
+		if (n - cnt  < 0) {
+			//
+			int fst = getFst(index);
+			int pre = n / index;//从fst开始的第pre个index位数                例：811/3=270==>即为从100开始的第270个数，即370（）
+			int remain = n % index;//从fst开始的第pre个index位数的第remain位  例：811%3==》即为370的从0开始计算的第remain+1为数
+
+			return getTheNum(fst + pre, remain, index);
+		}
+
+		n -= cnt;
+		index++;
+	}
+
+	//如果循环完毕还没有返回，说明出错返回-1
+	return -1;
+}
+
+int main()
+{
+	cout << "Please enter a interger:" << endl;
+	int n;
+	while (cin >> n) {
+		cout << numOnPosiN(n) << endl;
+	}
+	system("pause");
+	return 0;
+}
+```
diff --git a/README.MD b/README.MD
new file mode 100644
index 0000000..4c96dd8
--- /dev/null
+++ b/README.MD
@@ -0,0 +1,179 @@
+
+#include  <iostream>
+#include <vector>
+#include <string>
+#include <stack>
+using namespace std;
+
+//判断是否为操作符
+bool isOperator(char op)
+{
+	return (op == '+' || op == '-' || op == '*' || op == '/');
+}
+
+//判断是否为数字
+bool isDigit(char op)
+{
+	return  (op >= '0' && op <= '9');
+}
+
+//计算表达式结果
+int cal(int left, int right, char op)
+{
+	int res = 0;
+	if (op == '+')
+		res = left + right;
+	else if (op == '-')
+		res = left - right;
+	else if (op == '*')
+		res = left * right;
+	else if (op == '/')
+		res = left / right;
+	return res;
+}
+
+//判断运算符优先级
+int pirority(char op)
+{
+	if (op == '+' || op == '-')
+		return 1;
+	if (op == '*' || op == '/')
+		return 2;
+	else
+		return 0;
+}
+
+//逆波兰表达式转中缀表达式
+int evalRPN(string &tokens)
+{
+	if (tokens.size() <= 0)
+		return 0;
+	stack<int> s1;//创建辅助栈
+	int left = 0, right = 0;//定义左/右操作数
+	int result = 0;//定义中间结果
+	string temp;
+	for (unsigned int i = 0; i < tokens.size(); i++ )
+	{
+		
+		if (isDigit(tokens[i]))//扫描数字入栈
+		{
+			temp.push_back(tokens[i]);
+		}
+		else if (tokens[i] == ' ')
+		{
+			if (temp.size() > 0)   //防止运算符后面跟分隔符，所以判断一下temp里面是否有数字
+			{
+				s1.push(atoi(temp.c_str()));
+				temp.clear();
+			}
+		}
+		else if (isOperator(tokens[i]) && !s1.empty())
+		{
+			//防止数字后面直接跟运算符，所以这里也要判断一下temp是否还有数字没有提取出来
+			if (temp.size() > 0)
+			{
+				s1.push(atoi(temp.c_str()));
+				temp.clear();
+			}
+			right = s1.top();
+			s1.pop();
+			
+			left = s1.top();
+			s1.pop();
+		
+			result = cal(left, right, tokens[i]);
+			s1.push(result);
+		}
+		
+	}
+	if (!s1.empty())
+	{
+		result = s1.top();
+		s1.pop();
+	}
+
+	return result;
+}
+
+
+
+
+//中缀表达式转逆波兰表达式
+vector<char> infixToPRN(const string & token)
+{
+	vector<char> v1;
+	int len = token.size();//string的长度
+	if (len == 0)
+		return v1;
+
+	stack<char> s1;//存放逆波兰式的结果
+	int outLen = 0;
+	for (int i = 0; i < len ; i++)
+	{
+		if (token[i] == ' ')//跳过空格
+			continue;
+		if (isDigit(token[i]) )//若是数字，直接输出
+		{
+			v1.push_back(token[i]);
+		}
+		else if (token[i] == '(')//如果是'('，则压栈
+		{
+			s1.push(token[i]);
+		}else if (token[i] == ')')//如果是')'， 则栈中运算符逐个出栈并输出，直至遇到'('。 '('出栈并丢弃
+		{
+			while (s1.top() != '(')
+			{
+				v1.push_back( s1.top());
+				s1.pop();
+			}
+			s1.pop();//此时栈中为')'，跳过
+		}
+		while (isOperator(token[i]))//如果是运算符
+		{
+			//空栈||或者栈顶为)||新来的元素优先级更高  
+			if( s1.empty() || s1.top() == '(' || pirority(token[i]) > pirority(s1.top()))
+			{
+				s1.push(token[i]);// 当前操作符优先级比栈顶高， 将栈顶操作符写入后缀表达式
+				break;
+			}else 
+			{
+				v1.push_back(s1.top());
+				s1.pop();
+			}
+			 
+			
+		}
+	}
+	while (!s1.empty())//输入结束，将栈中剩余操作符出栈输出
+	{
+		v1.push_back(s1.top());
+		s1.pop();
+	}
+	return v1;
+}
+int main()
+{
+	//vector<string> sRPN = {"4", "13", "5" , "/", "+"};//逆波兰表达式
+	//cout << "逆波兰表达式结果为：" << evalRPN(sRPN) <<endl;
+
+	//vector<string> fix = {"4", "+", "13", "/", "5"};//中缀表达式
+	string fix = "2+2*(1*2-4/2)*1";
+	vector<char> RPN = infixToPRN(fix);
+	string s_fix;
+	for (auto it = RPN.begin(); it != RPN.end(); it++)
+	{
+		cout << *it << " ";
+		s_fix += *it;
+		s_fix += " ";
+	}
+	cout << endl;
+	cout << "逆波兰表达式结果为：" << evalRPN(s_fix) << endl;
+
+
+	
+	system("pause");
+
+	return 0;
+	
+}
+
diff --git "a/\344\270\255\347\274\200\350\241\250\350\276\276\345\274\217\343\200\212==\343\200\213\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.cpp" "b/\344\270\255\347\274\200\350\241\250\350\276\276\345\274\217\343\200\212==\343\200\213\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.cpp"
new file mode 100644
index 0000000..4c96dd8
--- /dev/null
+++ "b/\344\270\255\347\274\200\350\241\250\350\276\276\345\274\217\343\200\212==\343\200\213\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.cpp"
@@ -0,0 +1,179 @@
+
+#include  <iostream>
+#include <vector>
+#include <string>
+#include <stack>
+using namespace std;
+
+//判断是否为操作符
+bool isOperator(char op)
+{
+	return (op == '+' || op == '-' || op == '*' || op == '/');
+}
+
+//判断是否为数字
+bool isDigit(char op)
+{
+	return  (op >= '0' && op <= '9');
+}
+
+//计算表达式结果
+int cal(int left, int right, char op)
+{
+	int res = 0;
+	if (op == '+')
+		res = left + right;
+	else if (op == '-')
+		res = left - right;
+	else if (op == '*')
+		res = left * right;
+	else if (op == '/')
+		res = left / right;
+	return res;
+}
+
+//判断运算符优先级
+int pirority(char op)
+{
+	if (op == '+' || op == '-')
+		return 1;
+	if (op == '*' || op == '/')
+		return 2;
+	else
+		return 0;
+}
+
+//逆波兰表达式转中缀表达式
+int evalRPN(string &tokens)
+{
+	if (tokens.size() <= 0)
+		return 0;
+	stack<int> s1;//创建辅助栈
+	int left = 0, right = 0;//定义左/右操作数
+	int result = 0;//定义中间结果
+	string temp;
+	for (unsigned int i = 0; i < tokens.size(); i++ )
+	{
+		
+		if (isDigit(tokens[i]))//扫描数字入栈
+		{
+			temp.push_back(tokens[i]);
+		}
+		else if (tokens[i] == ' ')
+		{
+			if (temp.size() > 0)   //防止运算符后面跟分隔符，所以判断一下temp里面是否有数字
+			{
+				s1.push(atoi(temp.c_str()));
+				temp.clear();
+			}
+		}
+		else if (isOperator(tokens[i]) && !s1.empty())
+		{
+			//防止数字后面直接跟运算符，所以这里也要判断一下temp是否还有数字没有提取出来
+			if (temp.size() > 0)
+			{
+				s1.push(atoi(temp.c_str()));
+				temp.clear();
+			}
+			right = s1.top();
+			s1.pop();
+			
+			left = s1.top();
+			s1.pop();
+		
+			result = cal(left, right, tokens[i]);
+			s1.push(result);
+		}
+		
+	}
+	if (!s1.empty())
+	{
+		result = s1.top();
+		s1.pop();
+	}
+
+	return result;
+}
+
+
+
+
+//中缀表达式转逆波兰表达式
+vector<char> infixToPRN(const string & token)
+{
+	vector<char> v1;
+	int len = token.size();//string的长度
+	if (len == 0)
+		return v1;
+
+	stack<char> s1;//存放逆波兰式的结果
+	int outLen = 0;
+	for (int i = 0; i < len ; i++)
+	{
+		if (token[i] == ' ')//跳过空格
+			continue;
+		if (isDigit(token[i]) )//若是数字，直接输出
+		{
+			v1.push_back(token[i]);
+		}
+		else if (token[i] == '(')//如果是'('，则压栈
+		{
+			s1.push(token[i]);
+		}else if (token[i] == ')')//如果是')'， 则栈中运算符逐个出栈并输出，直至遇到'('。 '('出栈并丢弃
+		{
+			while (s1.top() != '(')
+			{
+				v1.push_back( s1.top());
+				s1.pop();
+			}
+			s1.pop();//此时栈中为')'，跳过
+		}
+		while (isOperator(token[i]))//如果是运算符
+		{
+			//空栈||或者栈顶为)||新来的元素优先级更高  
+			if( s1.empty() || s1.top() == '(' || pirority(token[i]) > pirority(s1.top()))
+			{
+				s1.push(token[i]);// 当前操作符优先级比栈顶高， 将栈顶操作符写入后缀表达式
+				break;
+			}else 
+			{
+				v1.push_back(s1.top());
+				s1.pop();
+			}
+			 
+			
+		}
+	}
+	while (!s1.empty())//输入结束，将栈中剩余操作符出栈输出
+	{
+		v1.push_back(s1.top());
+		s1.pop();
+	}
+	return v1;
+}
+int main()
+{
+	//vector<string> sRPN = {"4", "13", "5" , "/", "+"};//逆波兰表达式
+	//cout << "逆波兰表达式结果为：" << evalRPN(sRPN) <<endl;
+
+	//vector<string> fix = {"4", "+", "13", "/", "5"};//中缀表达式
+	string fix = "2+2*(1*2-4/2)*1";
+	vector<char> RPN = infixToPRN(fix);
+	string s_fix;
+	for (auto it = RPN.begin(); it != RPN.end(); it++)
+	{
+		cout << *it << " ";
+		s_fix += *it;
+		s_fix += " ";
+	}
+	cout << endl;
+	cout << "逆波兰表达式结果为：" << evalRPN(s_fix) << endl;
+
+
+	
+	system("pause");
+
+	return 0;
+	
+}
+