add C++ indicator before code

Author: ShusenTang

solutions/118. Pascal's Triangle.md

@@ -2,7 +2,7 @@
 # 思路
 首先明白题目要求返回的是一个vector，其元素也是vector，按照题目规律构造每个vector即可。
 # C++
-```
+``` C++
 class Solution {
 public:
     vector<vector<int>> generate(int numRows) {

solutions/119. Pascal's Triangle II.md

@@ -5,7 +5,7 @@
 在得到第i-1行结果时，可以从前往后依次更新数组里的值来得到第i行的结果，这是内层循环。  
 注意用一个pre来记录第i-1行里面第j个元素的前一个元素的值。
 # C++
-```
+``` C++
 class Solution {
 public:
     vector<int> getRow(int rowIndex) {

solutions/121. Best Time to Buy and Sell Stock.md

@@ -4,7 +4,7 @@
 因此prices[j]肯定是prices[i]之前的元素中最小的那一个，所以从前往后遍历，并用min_price记录当前位置前的元素中最小的一个。  
 另外注意单独判断空数组的情况。
 # C++
-```
+``` C++
 class Solution {
 public:
     int maxProfit(vector<int>& prices) {

solutions/122. Best Time to Buy and Sell Stock II.md

@@ -10,7 +10,7 @@ max(dp[j] + max(prices[i+1] - prices[k])), 其中k属于j~i+1
 
 # C++
 改进前：
-```
+``` C++
 class Solution {
 public:
     int maxProfit(vector<int>& prices) {
@@ -29,7 +29,7 @@ public:
 };
 ```
 改进后：
-```
+``` C++
 class Solution {
 public:
     int maxProfit(vector<int>& prices) {

solutions/125. Valid Palindrome.md

@@ -9,7 +9,7 @@
 然后再用两个指针low和high从两头往中间遍历并比较大小即可。   
 时间复杂度O(n),空间复杂度O(1)
 # C++
-```
+``` C++
 class Solution {
 private:
     int transformer(char c){ // 将所有字符映射到整数以方便比较

solutions/13. Roman to Integer.md

@@ -4,7 +4,7 @@
 用res代表结果，将代表罗马数字的字符串s从前往后遍历，如果当前字母对应的数大于等于下一个字母对应的数，则res加上对应的数，否则减。   
 注意：根据题意是没有可能发生s[i] < s[i + 1] < s[i + 2]的。
 # C++
-```
+``` C++
 class Solution {
 public:
     int romanToInt(string s) {

solutions/136. Single Number.md

@@ -10,7 +10,7 @@ unordered_map: 时间复杂度O(n), 空间复杂度O(N)
 时间复杂度O(n), 空间复杂度O(1), 完美
 # C++
 ## 思路二
-```
+``` C++
 class Solution {
 public:
     int singleNumber(vector<int>& nums) {

solutions/14. Longest Common Prefix.md

@@ -5,7 +5,7 @@
 注意：  
 append函数可以用来在字符串的末尾追加字符和字符串。由于string重载了运算符，也可以用+=操作实现。
 # C++
-```
+``` C++
 class Solution {
 public:
     string longestCommonPrefix(vector<string>& strs) {

solutions/141. Linked List Cycle.md

@@ -4,7 +4,7 @@
 设置两个指针p1和p2，用步长分别为1和2从前往后遍历，若链表是环则p1和p2总会相遇。   
 时间复杂度O(n)，空间复杂度O(1)
 # C++
- ```
+ ``` C++
  /**
  * Definition for singly-linked list.
  * struct ListNode {

solutions/155. Min Stack.md

@@ -3,7 +3,7 @@
 实现最小栈，要求所有操作的时间复杂度都为O(1)。   
 可考虑用两个站S1、S2，S1就正常记录minStack的值，而S2的栈顶记录了当前Minstack的最小值。S2的更新规则见代码。
 # C++
-```
+``` C++
 class MinStack {
 private:
     stack<int> s1;

solutions/160. Intersection of Two Linked Lists.md

@@ -5,7 +5,7 @@
 直到p1 == p2即到达所求节点c1或者遇到NULL。   
 时间复杂度O(n), 空间复杂度O(1)
 # C++
-```
+``` C++
 /**
  * Definition for singly-linked list.
  * struct ListNode {

solutions/167. Two Sum II - Input array is sorted.md

@@ -10,7 +10,7 @@ map查找的复杂度为O(logn),所以总的时间复杂度O(nlogn), 空间复
 此时时间复杂度O(n), 空间复杂度O(1).
 # C++
 ## 思路一
-```
+``` C++
 class Solution {
 public:
     vector<int> twoSum(vector<int>& numbers, int target) {
@@ -28,7 +28,7 @@ public:
 };
 ```
 ## 思路二
-```
+``` C++
 class Solution {
 public:
     vector<int> twoSum(vector<int>& numbers, int target) {

solutions/168. Excel Sheet Column Title.md

@@ -3,7 +3,7 @@
 题目的要求相当于是十进制转二十六进制。用一个循环每次对n取模然后n除26进入下一次循环即可。   
 不过需要注意的是，题目给的是1-26对应A-Z而不是0-25对应A-Z，所以每次循环时都要对n作自减操作。
 # C++
-```
+``` C++
 class Solution {
 public:
     string convertToTitle(int n) {

solutions/169. Majority Element.md

@@ -13,7 +13,7 @@
 时间复杂度O(n)。
 # C++
 ## 思路一
-```
+``` C++
 // 提交结果为16ms
 class Solution {
 public:
@@ -24,7 +24,7 @@ public:
 };
 ```
 ## 思路二
-```
+``` C++
 // 提交结果为12ms，较思路一有提升
 class Solution {
 public:
@@ -40,7 +40,7 @@ public:
 };
 ```
 ## 思路三
-```
+``` C++
 // 提交结果20ms
 class Solution {
 public:

solutions/171. Excel Sheet Column Number.md

@@ -3,7 +3,7 @@
 第[168题](https://leetcode.com/problems/excel-sheet-column-title/description/)是将10进制转换为26进制，这题是将26进制转换为10进制.    
 例：将k进制数"abcd"转换为10进制数：`res = d * k^0 + c * k^1 + b * k^2 + a * k^3`.
 # C++
-```
+``` C++
 class Solution {
 public:
     int titleToNumber(string s) {

solutions/172. Factorial Trailing Zeroes.md

@@ -15,7 +15,7 @@ n = 4617.
 所以 4617! 有 923 + 184 + 36 + 7 + 1 = 1151 个尾0.     
 [参考](https://leetcode.com/problems/factorial-trailing-zeroes/discuss/52373/Simple-CC++-Solution-(with-detailed-explaination))
 # C++
-```
+``` C++
 class Solution {
 public:
     int trailingZeroes(int n) {

solutions/189. Rotate Array.md

@@ -7,7 +7,7 @@
 再对后面的元素翻转:【5,6,7,1,2,3,4]。   
 时间复杂度O(n), 空间复杂度O(1)。
 # C++
-```
+``` C++
 class Solution {
 public:
     void rotate(vector<int>& nums, int k) {

solutions/190. Reverse Bits.md

@@ -17,7 +17,7 @@
 
 # C++
 ## 思路一
-```
+``` C++
 class Solution {
 public:
     uint32_t reverseBits(uint32_t n) {
@@ -33,7 +33,7 @@ public:
 };
 ```
 ## 思路二
-```
+``` C++
 class Solution {
 public:
     uint32_t reverseBits(uint32_t n) {

solutions/191. Number of 1 Bits.md

@@ -8,7 +8,7 @@
 依然是循环，但是每次循环不是得到最低位的值，而是每次循环去掉一个1，用一个count计数即可得到答案。
 # C++
 ## 思路一
-```
+``` C++
 // 方法1
 class Solution {
 public:
@@ -37,7 +37,7 @@ public:
 };
 ```
 ## 思路二*
-```
+``` C++
 class Solution {
 public:
     int hammingWeight(uint32_t n) {

solutions/198. House Robber.md

@@ -12,7 +12,7 @@
 ## 空间优化且不改变原数组
 用pre记录dp[i-1]，这样既不改变原数组nums也使得空间复杂度为o(1), 完美
 # C++
-```
+``` C++
 class Solution {
 public:
     int rob(vector<int>& nums){
@@ -27,7 +27,7 @@ public:
 };
 ```
 ## 空间优化
-```
+``` C++
 class Solution {
 public:
     int rob(vector<int>& nums){
@@ -40,7 +40,7 @@ public:
 };
 ```
 ## 空间优化且不修改原数组
-```
+``` C++
 class Solution {
 public:
     int rob(vector<int>& nums){

solutions/20. Valid Parentheses.md

@@ -4,7 +4,7 @@
 退出循环后，若栈不空，说明还剩下未配对的左括号，则应该返回false。   
 时间复杂度O(n), 空间复杂度O(n)
 # C++
-```
+``` C++
 class Solution {
 private:
     bool isLegal(const char& a, const char&b){

solutions/202. Happy Number.md

@@ -2,7 +2,7 @@
 # 思路
 按照题目的意思进行循环，判断每次循环结果是否为1，若是则返回true，否则用map记录结果，然后修改n进行下一次循环。  
 # C++
-```
+``` C++
 class Solution {
 private:
     int count_sum(int n){ // 定义题目中所述的求和函数

solutions/203. Remove Linked List Elements.md

@@ -8,7 +8,7 @@
 最后将p指向pre的next。  
 为了操作方便，可以设置一个头结点。
 # C++
-```
+``` C++
 /**
  * Definition for singly-linked list.
  * struct ListNode {

solutions/204. Count Primes.md

@@ -14,7 +14,7 @@
 
 # C++
 ## 思路一
-```
+``` C++
 class Solution {
 private:
     bool isPrime(int n){
@@ -33,7 +33,7 @@ public:
 };
 ```
 ## 思路二
-```
+``` C++
 class Solution {
 public:
     int countPrimes(int n) {

solutions/205. Isomorphic Strings.md

@@ -6,7 +6,7 @@
 为了记录是否出现过，用map来实现，此外还用一个count计数。   
 时间复杂度O(nlogn)
 # C++
-```
+``` C++
 class Solution {
 public:
     bool isIsomorphic(string s, string t) {

solutions/206. Reverse Linked List.md

@@ -10,7 +10,7 @@
 
 # C++
 ## 思路一
-```
+``` C++
 /**
  * Definition for singly-linked list.
  * struct ListNode {
@@ -38,7 +38,7 @@ public:
 };
 ```
 ## 思路二
-```
+``` C++
 /**
  * Definition for singly-linked list.
  * struct ListNode {

solutions/21. Merge Two Sorted Lists.md

@@ -3,7 +3,7 @@
 合并两个已有序的链表，注意题目给的链表没有头结点，所以为了操作方便可以自己设一个头结点，最后返回头结点的下一个节点即可。两个链表的工作指针就用传进来的l1和
 l2即可。
 # C++
-```
+``` C++
 /**
  * Definition for singly-linked list.
  * struct ListNode {

solutions/217. Contains Duplicate.md

@@ -2,7 +2,7 @@
 # 思路
 先对数组进行排序，排序后重复的数一定是相邻的，再遍历一遍即可。
 # C++
-```
+``` C++
 class Solution {
 public:
     bool containsDuplicate(vector<int>& nums) {

solutions/219. Contains Duplicate II.md

@@ -3,7 +3,7 @@
 判断数组是否有重复元素，而且重复元素下标差的绝对值不大于k，首先简单的思路就是用map，这里给出另一种解法:  
 定义一个结构体num_with_index记录数组元素的值和下标，然后再对结构体按照值进行排序，排序后重复元素肯定相邻，再判断下标是否满足条件即可。
 # C++
-```
+``` C++
 class Solution {
     struct num_with_index{
         int num;

solutions/225. Implement Stack using Queues.md

@@ -5,7 +5,7 @@
 因为pop和top都要求找到栈顶元素，采用前者思路的话会产生混乱。    
 注意学习stl中queue的一些操作：push、pop、front
 # C++
-```
+``` C++
 class MyStack {
 private:
     queue<int>q;

solutions/231. Power of Two.md

@@ -5,7 +5,7 @@
 2. 若n是不为1的奇数返回false；
 3. 令n = n / 2，若n=1则返回true否则返回第2步。   
 # C++
-```
+``` C++
 class Solution {
 public:
     bool isPowerOfTwo(int n) {

solutions/232. Implement Queue using Stacks.md

@@ -5,7 +5,7 @@
 若stk1不空，对队列入队的话直接对stk1入栈即可，否则要将stk2中所有元素pop到stk1中后再对stk1入栈。   
 若stk2不空，对队列出队的话直接对stk2出栈即可，否则要将stk1中所有元素pop到stk2中后再对stk2出栈。
 # C++
-```
+``` C++
 class MyQueue {
 private:
     stack<int>stk1;

solutions/234. Palindrome Linked List.md

@@ -3,7 +3,7 @@
 判断所给链表是不是回文的，要求线性时间复杂度且空间复杂度为O(1)。  
 可以考虑现将链表的后半部分（或前半部分）反转一下，然后再设置两个指针p和q，初始分别指向前、后半部分的第一个节点，然后同时往后移动并判断值是否相等。
 
-```
+``` C++
 /**
  * Definition for singly-linked list.
  * struct ListNode {