【算法面試】leetcode最多見的150道前端面試題 --- 簡單題上（44題）

前言

本文題目選自 LeetCode 精選 TOP 面試題，而這些題在本身和同事親身經歷中，確實遇到的概率在百分之80%以上（成都和北京的前端崗位）。本文挑選其中全部簡單題作歸類和解法分析。後續更新全部中等題分析。javascript

爲了幫助你們快速刷題，經過將數據結構 + 題型的方式總結出來，好比說哈希表擁有記數的功能，若是題目中包含字眼至多xx次， 至少xx次,惟一等等字眼，能夠聯想到用哈希表來解決。刷個3-4道相似的題，就會養成一種條件反射。前端

舉例：存在重複元素（相似題還有3道，後面一塊兒說，解法同樣）

題目描述以下：java

給定一個整數數組，判斷是否存在重複元素。node

若是存在一值在數組中出現至少兩次，函數返回 true 。若是數組中每一個元素都不相同，則返回 false 。面試

示例 1:

輸入: [1,2,3,1]
輸出: true

示例 2:

輸入: [1,2,3,4]
輸出: false
複製代碼

這題一看就是計數問題，題目中若是存在一值在數組中出現至少兩次，這句話就告訴咱們記錄每個數字出現的次數就能解決問題了。算法

解決思路：

咱們遍歷數組時，通過數組中的每一項就往map中添加，好比[1,2,3,1]typescript

第一項：遍歷到第一個1時，對象返回{ 1: 1 },表明1出現1次
第二項：遍歷到2時，返回 { 1: 1, 2: 1 }
第三項：遍歷到3時，返回 { 1: 1, 2: 1， 3: 1 }
第四項：遍歷到第二個1時，發現原來的對象裏已經有1了，返回false

因此，代碼天然也就出來了，以下：後端

const containsDuplicate = function(nums) {
    let map = new Map();
    for(let i of nums){
        if(map.has(i)){
            return true;
        }else{
            map.set(i, 1);
        }
    }
    return false;
};
複製代碼

哈希表 + 計數類型

除了上面的那道題，在最熱門的簡單題型中還有一些記數類型的題，咱們一一解答，這是一類題型設計模式

387. 字符串中的第一個惟一字符

一看題目，惟一，條件反射，記數題啊，map走起！咱們先看一下題目：數組

給定一個字符串，找到它的第一個不重複的字符，並返回它的索引。若是不存在，則返回 -1。

示例：

s = "leetcode"
返回 0

s = "loveleetcode"
返回 2
 
// 提示：你能夠假定該字符串只包含小寫字母
複製代碼

思路：

遍歷字符串
用一個對象{}來記數，出現過一次就+1，
- 遍歷完畢，再次遍歷字符串，看它們在以前記錄的對象裏的值，是不是1，是就返回下標，不是返回-1。

參考答案：

var firstUniqChar = function(s) {
  const map = {};
  for(let v of s) map[v] = (map[v] || 0) + 1;
  for(let i = 0; i < s.length; i++) if(map[s[i]] === 1) return i;
  return -1;
};
複製代碼

242. 有效的字母異位詞

咱們先看一下題目：

給定兩個字符串 s 和 t ，編寫一個函數來判斷 t 是不是 s 的字母異位詞。

注意：若 s 和 t 中每一個字符出現的次數都相同，則稱 s 和 t 互爲字母異位詞。

示例 1:

輸入: s = "anagram", t = "nagaram"
輸出: true
示例 2:

輸入: s = "rat", t = "car"
輸出: false
複製代碼

思路：這個題一看字眼，出現次數相同，次數不就是記數嗎，記數題型，map走起！

聲明計數器，一個對象 const obj = {}
遍歷s字符串，若是遍歷到字符串的'a'字母，去看obj[a]是否存在
不存在說明第一次遍歷到'a'字母，那麼初始化obj[a] = 1
若是存在則obj[a] += 1
t字符串同理，它每次減1
遍歷完s字符串後，遍歷obj對象，看它的每一對key：value，是否value都是0

var isAnagram = function(s, t) {

  const sLen = s.length;
  const tLen = t.length;
  if(sLen !== tLen ) {
      return false;
  }
  const obj = {};
  for(let i = 0 ; i < sLen ; i++){
      const currentS = s[i];
      const currentT = t[i];
      obj[currentS] ? obj[currentS]++ : obj[currentS] = 1;
      obj[currentT] ? obj[currentT]-- : obj[currentT] = -1;
  }
  return Object.values(obj).every(v=>v===0);
};
複製代碼

169. 多數元素

咱們先看題目（題目裏有次數兩個字，又是記數題型，map繼續走起）：

給定一個大小爲 n 的數組，找到其中的多數元素。多數元素是指在數組中出現次數大於 ⌊ n/2 ⌋ 的元素。

你能夠假設數組是非空的，而且給定的數組老是存在多數元素。

示例 1：

輸入：[3,2,3]
輸出：3
示例 2：

輸入：[2,2,1,1,1,2,2]
輸出：2
複製代碼

思路：

聲明一個計數器,也就是一個對象const map = {}
遍歷字符串，開始記數，若是字符串的字母第一次遇見，map[第一次遇見的字母] = 1
若是map已經記錄過這個字母，則map[記錄過的的字母] += 1
在遍歷的過程當中，看map[記錄過的的字母] 是否大於 數組總長度/2

解答：

var majorityElement = function(nums) {
  const map = {}
  const n = nums.length >> 1 // >>是右移運算符，意思是除以2
  for(let i = 0; i < nums.length; i++){
      map[nums[i]] = map[nums[i]] !== undefined ? map[nums[i]] + 1 : 1
      if(map[nums[i]] > n) return nums[i]
  }
}
複製代碼

只出現一次的數字

這個題一看，出現一次，map走起，可是呢，這個題比較巧的是，由於題目的一些限制條件，能夠有更好的解法，咱們先看題：

給定一個非空整數數組，除了某個元素只出現一次之外，其他每一個元素均出現兩次。找出那個只出現了一次的元素。

說明：

你的算法應該具備線性時間複雜度。你能夠不使用額外空間來實現嗎？

示例 1:

輸入: [2,2,1]
輸出: 1
示例 2:

輸入: [4,1,2,1,2]
輸出: 4
複製代碼

這裏咱們用map記錄一遍，相似這樣的代碼，

const countMap = {};
數組.forEach((item)=> { countMap[item] ? countMap[item] += 1 : countMap[item] = 1 } )
最後再遍歷一次countMap，而後看誰的次數是`1`，就解決了
複製代碼

可是這套題有另外一個解法，用異或運算符，首先咱們看看異或運算符有啥用：

異或運算符(^)，咱們瞭解下，這個運算符的功能

任何數和本身作異或運算，結果爲 0，即 a⊕a=0。
任何數和 0 作異或運算，結果仍是本身，即 a⊕0=a。
異或運算中，知足交換律和結合律，也就是a⊕b⊕a=b⊕a⊕a=b⊕(a⊕a)=b⊕0=b。

因此出現兩次的字母異或運算得0，跟出現一次的字母異或運算獲得本身

解答：

var singleNumber = function(nums) {
  let init = nums[0];
  for(let i = 1; i < nums.length; i++){
      init ^=  nums[i];
  }
  return init;
};
複製代碼

位1的個數

編寫一個函數，輸入是一個無符號整數（以二進制串的形式），返回其二進制表達式中數字位數爲 '1' 的個數（也被稱爲漢明重量）。

示例 1：

輸入：00000000000000000000000000001011
輸出：3
解釋：輸入的二進制串 00000000000000000000000000001011 中，共有三位爲 '1'。
示例 2：

輸入：00000000000000000000000010000000
輸出：1
解釋：輸入的二進制串 00000000000000000000000010000000 中，共有一位爲 '1'。
複製代碼

思路：

計算個數，按照咱們以前的思路，把整個數字轉爲字符串，相似這樣：

數字 0001 => String(0001) => '0001' => 遍歷看1的個數
複製代碼

而後直接遍歷計算就能夠了，這是我爲何把它歸爲記數類別的緣由，固然也能夠把它歸爲數學類，咱們用數學的算法來解，先看答案，咱們再解析。

var hammingWeight = function(n) {
    let ret = 0;
    while(n){
        n &= (n - 1);
        ret++;
    }
    return ret;
};
複製代碼

原理：

每執行一次x = x & (x-1)，會將x用二進制表示時最右邊的一個1變爲0，由於x-1將會將該位(x用二進制表示時最右邊的一個1)變爲0。所以，對 x 重複該操做，直到 x 變成 0，則操做次數即爲 x 的二進制數中的 1 的數目。

接下來，咱們把其餘類型的哈希表題也介紹了（相同的題型沒那麼多）

哈希表 + 映射功能

哈希表有一個很是常見的功能就是創建映射關係，好比說設計模式裏的策略模式，思路是同樣的，映射表經常見於後端的枚舉類型，typescript也是同樣，咱們舉一個js的例子

// 後端只會返回0，1，2
const TYPE = {
    2: 'orange',
    1: 'red',
    0: 'blue'
}

// 而後前端會這樣用
TYPE[後端返回的數字0或1或2]
複製代碼

對應的題有：

1.兩數之和
349.兩個數組的交集

兩數之和

給定一個整數數組 nums 和一個整數目標值 target，請你在該數組中找出和爲目標值 target 的那兩個整數，並返回它們的數組下標。

你能夠假設每種輸入只會對應一個答案。可是，數組中同一個元素在答案裏不能重複出現。

你能夠按任意順序返回答案。

示例 1：

輸入：nums = [2,7,11,15], target = 9
輸出：[0,1]
解釋：由於 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：

輸入：nums = [3,2,4], target = 6
輸出：[1,2]
示例 3：

輸入：nums = [3,3], target = 6
輸出：[0,1]
複製代碼

用 hashMap 存儲遍歷過的元素和對應的索引。每遍歷一個元素，看看 hashMap 中是否存在知足要求的目標數字。全部事情在一次遍歷中完成（用了空間換取時間）

var twoSum = function(nums, target) {
    const map = new Map();
    for(let i = 0, len = nums.length; i < len; i++){
        if(map.get(nums[i]) !== undefined){
            return [map.get(nums[i]), i];
        } else {
            map.set(target - nums[i], i);
        }
    }
    return [];
};
複製代碼

兩數組交集

題目以下：給定兩個數組，編寫一個函數來計算它們的交集。

示例 1：

輸入：nums1 = [1,2,2,1], nums2 = [2,2]
輸出：[2]
示例 2：

輸入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
輸出：[9,4]
 

說明：

輸出結果中的每一個元素必定是惟一的。
咱們能夠不考慮輸出結果的順序。
複製代碼

這道題能夠用set，很簡單,可是空間複雜度和時間複雜度都過高，不太優雅

var intersection = function (nums1, nums2) {
    return result =[...new Set(nums1)].filter(item=>new Set(nums2).has(item))
};
複製代碼

咱們能夠用map來作，時間和空間複雜度都低不少思路：

用一個map去存nums1數組裏的每一項，相似map[nums1[i]] = true
而後去遍歷nums2，若是在map中已經有的值，相似map[nums2[i]], 就把它push到一個數組裏
而且將map[nums2[i]]設爲false，後面有相同的值就不push到數組了

var intersection = function(nums1, nums2) {
    const map = {};
    const ret = [];
    for(let i = 0; i < nums1.length; i++){
        map[nums1[i]] = true;
    }
    for(let i = 0; i < nums2.length; i++){
        if(map[nums2[i]]){
            ret.push(nums2[i])
            map[nums2[i]] = false
        }
    }
    return ret;
};
複製代碼

找規律題

這類題通常畫個圖或者稍微分析一下就能得出答案

13. 羅馬數字轉整數

這個題，我來簡單描述一下，羅馬數字對應咱們阿拉伯數字的map以下：

I: 1,
        V: 5,
        IV: 4,
        IX: 9,
        X: 10,
        XL: 40,
        XC: 90,
        L: 50,
        C: 100,
        CD: 400,
        CM: 900,
        D: 500,
        M: 1000,
複製代碼

題目是給定一個羅馬數字，將其轉換成整數。輸入確保在 1 到 3999 的範圍內。

示例 1:

輸入: "III"
輸出: 3
示例 2:

輸入: "IV"
輸出: 4
示例 3:

輸入: "IX"
輸出: 9
示例 4:

輸入: "LVIII"
輸出: 58
解釋: L = 50, V= 5, III = 3.
複製代碼

解題思路就是咱們發現這些案例的規律，就是把map表裏面對應數字加起來就好了，好比說

"LVIII" = 'L'（對應map表50）+ 'V'（對應map表5）+ 'I'（對應map表1） + 'I'對應map表1） + 'I'（對應map表1）

因此解答就很簡單了，就是遍歷數字把對應的值加起來，以下：

var romanToInt = function(s) {
    const map = {
        I: 1,
        V: 5,
        IV: 4,
        IX: 9,
        X: 10,
        XL: 40,
        XC: 90,
        L: 50,
        C: 100,
        CD: 400,
        CM: 900,
        D: 500,
        M: 1000,
    }
    let res = 0;
    let index = 0;
    let len = s.length;
    while(index < len){
        if(index + 1 < len && map[s.slice(index, index+2)]){
            res += map[s.slice(index, index+2)];
            index += 2;
        }else{
            res += map[s.slice(index, index+1)];
            index += 1;
        }
    }
    return res;
};
複製代碼

14. 最長公共前綴

題目以下：

編寫一個函數來查找字符串數組中的最長公共前綴。

若是不存在公共前綴，返回空字符串 ""。

示例 1：

輸入：strs = ["flower","flow","flight"]
輸出："fl"
示例 2：

輸入：strs = ["dog","racecar","car"]
輸出：""
解釋：輸入不存在公共前綴。
 

提示：

0 <= strs.length <= 200
0 <= strs[i].length <= 200
strs[i] 僅由小寫英文字母組成
複製代碼

思路：這個題的思路就是，假如你求數組裏3個元素的最長公共前綴

你先拿前兩個比較，求出他們兩個的最長公共前綴
而後上面求出的結果去跟第三個元素求最長公共前綴
n個元素就一直這麼reduce下去

// 這個是求出兩個元素最長公共前綴的方法
var longestCommonPrefix = function (strs) {
  if (strs.length === 0) return ''
  if (strs.length === 1) return strs[0];
  return strs.reduce(getSameStr, strs[0]);
};

function getSameStr(a, b) {
  let res = ''
  for (let j = 0; j < a.length; j++) {
    if (a[j] === b[j]) {
      res += a[j];
    } else {
      return res;
    }
  }
  return res
}
複製代碼

21. 合併兩個有序鏈表

這個題簡而言之就是看圖找規律，就是合併爲升序鏈表，具體題目以下：

咱們先看一下題目：

將兩個升序鏈表合併爲一個新的升序鏈表並返回。新鏈表是經過拼接給定的兩個鏈表的全部節點組成的。

示例 1：


輸入：l1 = [1,2,4], l2 = [1,3,4]
輸出：[1,1,2,3,4,4]
示例 2：

輸入：l1 = [], l2 = []
輸出：[]
示例 3：

輸入：l1 = [], l2 = [0]
輸出：[0]
 

提示：

兩個鏈表的節點數目範圍是 [0, 50]
-100 <= Node.val <= 100
l1 和 l2 均按 非遞減順序 排列
複製代碼

思路:

那就挨個遍歷，按順序誰小拼接誰，接着進入下一輪循環，看代碼更清晰一些：

// 鏈表定義函數
function ListNode(val, next) {
    this.val = (val===undefined ? 0 : val)
    this.next = (next===undefined ? null : next)
}

var mergeTwoLists = function(l1, l2) {
  const dummpy = node = new ListNode();
  while(l1 && l2){
      if(l1.val >= l2.val){
          node.next = l2;
          node = node.next;
          l2 = l2.next;
      } else {
          node.next = l1;
          node = node.next;
          l1 = l1.next;
      }
  }
  node.next = l1 || l2;
  return dummpy.next;
};
複製代碼

28. 實現str（）

題目以下：

實現 strStr() 函數。

給你兩個字符串 haystack 和 needle ，請你在 haystack 字符串中找出 needle 字符串出現的第一個位置（下標從 0 開始）。若是不存在，則返回 -1 。

示例 1：

輸入：haystack = "hello", needle = "ll"
輸出：2
示例 2：

輸入：haystack = "aaaaa", needle = "bba"
輸出：-1
示例 3：

輸入：haystack = "", needle = ""
輸出：0
 

提示：

0 <= haystack.length, needle.length <= 5 * 104
haystack 和 needle 僅由小寫英文字符組成
複製代碼

思路：

原本這道題最佳算法是KMP，這個算法理解起來對我來講有難度，因此本身換了另外一種思路

遍歷字符串看是否有和須要找的字符串第一個字母相同
若是相同，就截取字符串跟須要找的字符串相同長度的字符串對比
相同就返回下標，不一樣就繼續遍歷原字符串

var strStr = function (haystack, needle) {
  if (needle === "") return 0
  for (var i = 0; i < haystack.length; i++) {
      if (haystack[i] === needle[0]) {
          if (haystack.substring(i, i + needle.length) === needle) return i;
      }
  }
  return -1
};
複製代碼

118. 楊輝三角

這個但是找規律的表明題，而且這道題能夠訓練一下你對二維數組 轉化爲 代碼的能力：

給定一個非負整數 numRows， 生成楊輝三角的前 numRows 行。

在楊輝三角中，每一個數是它左上方和右上方的數的和。

示例:

輸入: 5
輸出:
[
     [1],
    [1,1],
   [1,2,1],
  [1,3,3,1],
 [1,4,6,4,1]
]
複製代碼

思路：

看到上圖能夠發現，生成楊輝三角numRows行，數組就有numRows行
每一行，它的數組第一個位置和最後一個位置都是1
每一行，除了第一個和最後一個位置，其它位置的值等於上一行的兩個值相加

把思路翻譯成代碼便可：

var generate = function(numRows) {
  if(numRows === 0){ return [] }
  const result = Array.from(new Array(numRows), ()=>[])
  for(let i = 0; i < numRows; i++){
    result[i][0] = 1; result[i][i] = 1;
      for(let j = 1; j < i; j++){
      result[i][j] = result[i-1][j-1] + result[i-1][j] 
    }
  }
return result
};
複製代碼

121. 買賣股票的最佳時機

接下來這道題，你簡單看下題目就行，解答原理超級簡單，看圖說話，找規律！

咱們先看題：

給定一個數組 prices ，它的第 i 個元素 prices[i] 表示一支給定股票第 i 天的價格。

你只能選擇 某一天買入這隻股票，並選擇在將來的某一個不一樣的日子 賣出該股票。設計一個算法來計算你所能獲取的最大利潤。

返回你能夠從這筆交易中獲取的最大利潤。若是你不能獲取任何利潤，返回 0 。

示例 1：

輸入：[7,1,5,3,6,4]
輸出：5
解釋：在第 2 天（股票價格 = 1）的時候買入，在第 5 天（股票價格 = 6）的時候賣出，最大利潤 = 6-1 = 5 。
     注意利潤不能是 7-1 = 6, 由於賣出價格須要大於買入價格；同時，你不能在買入前賣出股票。
示例 2：

輸入：prices = [7,6,4,3,1]
輸出：0
解釋：在這種狀況下, 沒有交易完成, 因此最大利潤爲 0。
 

提示：

1 <= prices.length <= 105
0 <= prices[i] <= 104
複製代碼

解題思路：咱們先看一張圖，假設給定的數組爲：[7, 1, 5, 3, 6, 4]

第一天是7，咱們記錄一下，由於還沒到次日不知道這個價格是高是低，標記最小值是7
次日是1，比7小，那麼只要當前天數的值比前面小，就說明不賣，由於它是最小值，標記最小值是7
第三天是5，5比前一天大，說明比最小值要大，那麼能夠賣，利潤就是5-1=4
第四天發現是3，比5小，仍是同樣的道理，比以前小，最小值就要變爲當前值，啥也不幹，標記最小值是3
第五天發現是6...，第六天發現是4，規律是同樣的

意思是隻要今天比昨天低，就能夠用今天的減去最小值，就是利潤，而後每次都比較這個利潤是否是最大就好了

結合一下代碼，就會清楚

var maxProfit = function(prices) {
  let res = 0;
  let min = prices[0];
  for(let i = 1; i < prices.length; i++){
      if(prices[i] < min){
          min = prices[i]
      } else {
          res = Math.max(res, prices[i] - min)
      }   
  }
  return res;
};
複製代碼

122. 買賣股票的最佳時機2

又來一道看圖說話題目，簡單！走起！

先看題目：

給定一個數組 prices ，其中 prices[i] 是一支給定股票第 i 天的價格。

設計一個算法來計算你所能獲取的最大利潤。你能夠儘量地完成更多的交易（屢次買賣一支股票）。

注意：你不能同時參與多筆交易（你必須在再次購買前出售掉以前的股票）。

示例 1:

輸入: prices = [7,1,5,3,6,4]
輸出: 7
解釋: 在第 2 天（股票價格 = 1）的時候買入，在第 3 天（股票價格 = 5）的時候賣出, 這筆交易所能得到利潤 = 5-1 = 4 。
     隨後，在第 4 天（股票價格 = 3）的時候買入，在第 5 天（股票價格 = 6）的時候賣出, 這筆交易所能得到利潤 = 6-3 = 3 。
示例 2:

輸入: prices = [1,2,3,4,5]
輸出: 4
解釋: 在第 1 天（股票價格 = 1）的時候買入，在第 5 天 （股票價格 = 5）的時候賣出, 這筆交易所能得到利潤 = 5-1 = 4 。
     注意你不能在第 1 天和第 2 天接連購買股票，以後再將它們賣出。由於這樣屬於同時參與了多筆交易，你必須在再次購買前出售掉以前的股票。
示例 3:

輸入: prices = [7,6,4,3,1]
輸出: 0
解釋: 在這種狀況下, 沒有交易完成, 因此最大利潤爲 0。
複製代碼

思路，看圖立刻思路就出來了：

咱們的利潤就跟上圖綠色部分顯示的同樣，也就是說只要今天減去昨天，是正數就是利潤，簡單吧，哈哈！

var maxProfit = function(prices) {
  let result = 0
  for(let i = 1; i < prices.length; i++){
      if(prices[i] > prices[i-1]){
          result += prices[i] - prices[i - 1]
      }
  }
  return result
};
複製代碼

206. 反轉鏈表

這個題必須掌握牢實，是解不少連接表題的基礎的基礎。先看題目：

給你單鏈表的頭節點 head ，請你反轉鏈表，並返回反轉後的鏈表。

示例 1：

輸入：head = [1,2,3,4,5]
輸出：[5,4,3,2,1]
複製代碼

示例 2：

輸入：head = [1,2]
輸出：[2,1]
複製代碼

解題思路依然是看圖找規律，下圖就是，咱們把鏈表前面加一個null，這樣翻轉前和翻轉後就一致了。解答：

var reverseList = function(head) {
  let [pre, node] = [null, head];
  while(node){
      const temp = node.next;
      node.next = pre;
      pre = node;
      node = temp;
  }
  return pre;
};
複製代碼

雙指針

雙指針是解數組類型題最多見解法

好比有頭尾分別有指針，而後依次向中間靠攏的雙指針，
還有一種是快慢是指針，兩個指針都是從左邊開始，一個走的快，一個走得慢

具體的細節仍是須要從題裏體會，咱們如今就開始！

26. 刪除數組中的重複項

先看一下題目：

給你一個有序數組 nums ，請你原地刪除重複出現的元素，使每一個元素只出現一次，返回刪除後數組的新長度。

不要使用額外的數組空間，你必須在原地修改輸入數組並在使用 O(1) 額外空間的條件下完成。

示例 1：

輸入：nums = [1,1,2]
輸出：2, nums = [1,2]
解釋：函數應該返回新的長度 2 ，而且原數組 nums 的前兩個元素被修改成 1, 2 。不須要考慮數組中超出新長度後面的元素。
示例 2：

輸入：nums = [0,0,1,1,1,2,2,3,3,4]
輸出：5, nums = [0,1,2,3,4]
解釋：函數應該返回新的長度 5 ， 而且原數組 nums 的前五個元素被修改成 0, 1, 2, 3, 4 。不須要考慮數組中超出新長度後面的元素。
 

提示：

0 <= nums.length <= 3 * 104
-104 <= nums[i] <= 104
nums 已按升序排列
複製代碼

初始狀態是：

慢指針是i，快指針是j
若是nums[i] 等於 nums[j] 說明是相同的元素，j繼續走，i還在原位
若是nums[i] 不等於 nums[j] 說明是不相同的元素，那麼nums[i++] = nums[j]，j繼續向前走

依次類推，就至關於i指針保證它和它前面的數字都是不重複的，j就是一個遍歷器

var removeDuplicates = function(nums) {
  let i = 0;
  for(let j = 1; j < nums.length; j++){
      if(nums[j] !== nums[i]){
          nums[i+1] = nums[j];
          i++
      }
  }
  return i + 1
};
複製代碼

88. 合併兩個有序數組

咱們先看題目：

給你兩個有序整數數組 nums1 和 nums2，請你將 nums2 合併到 nums1 中，使 nums1 成爲一個有序數組。

初始化 nums1 和 nums2 的元素數量分別爲 m 和 n 。你能夠假設 nums1 的空間大小等於 m + n，這樣它就有足夠的空間保存來自 nums2 的元素。

示例 1：

輸入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
輸出：[1,2,2,3,5,6]
示例 2：

輸入：nums1 = [1], m = 1, nums2 = [], n = 0
輸出：[1]
 

提示：

nums1.length == m + n
nums2.length == n
0 <= m, n <= 200
1 <= m + n <= 200
-109 <= nums1[i], nums2[i] <= 109
複製代碼

這道題你們很容易想到，新建立一個數組，而後分別比較這兩個數組裏的每一項，push進去就好了

然而由於是有序數組，第一個數組還有正好知足假如第二數組的空間，因此這裏能夠採起雙指針來解答，從後往前遍歷

參考以下：

var merge = function (nums1, m, nums2, n) {
  let len = m + n - 1;
  m--, n--;
  while (m >= 0 && n >= 0) {
    if (nums1[m] > nums2[n]) {
      nums1[len] = nums1[m--]
    } else {
      nums1[len] = nums2[n--]
    }
    len--;
  }
  if(m === -1){
    return nums1.splice(0, len+1, ...nums2.slice(0, n + 1));
  }
  if(n === -1){
    return nums1;
  }
};
複製代碼

125. 驗證迴文串

請看題目：

給定一個字符串，驗證它是不是迴文串，只考慮字母和數字字符，能夠忽略字母的大小寫。

說明：本題中，咱們將空字符串定義爲有效的迴文串。

示例 1:

輸入: "A man, a plan, a canal: Panama"
輸出: true
解釋："amanaplanacanalpanama" 是迴文串
示例 2:

輸入: "race a car"
輸出: false
解釋："raceacar" 不是迴文串
複製代碼

這個題太簡單了，以致於不用寫思路了，看代碼就知道，就是用用雙指針頭尾向中間靠攏的解法，

var isPalindrome = function(s) {
  s = s.replace(/[^\w]/g, '').toLowerCase();
  let leftPointer = 0;
  let rightPointer = s.length - 1;
  while(rightPointer > leftPointer){
      if(s[leftPointer++] === s[rightPointer--]){
          continue;
      }else{
          return false;
      }
  }
  return true;
};
複製代碼

234. 迴文鏈表

這個題思路跟上面是同樣的，都是雙指針對比，可是主要這個題寫起來很麻煩，要用到咱們以前說的翻轉鏈表，

解題思路：

先用快慢指針的手法，讓咱們知道這個鏈表的中點是哪，而後從中點截斷
而後截斷成爲兩個鏈表，把後面的鏈表翻轉
最後依次去判斷這兩個鏈表每一項是否相同

關鍵點：如何從中點截斷這個鏈表,方法以下，讓一個指針每次走一步，另外一個指針每次走兩步，這樣他們每次走的倍數就相差2倍。代碼以下：

let fast = head;
  let slow = head;
  let prev;
  while (fast && fast.next) {
    prev = slow;
    slow = slow.next;
    fast = fast.next.next;
  }
prev.next = null;  // 斷成兩個鏈表
複製代碼

接着咱們須要翻轉鏈表

// 翻轉後半段
  let head2 = null;
  while (slow) {
    const tmp = slow.next;
    slow.next = head2;
    head2 = slow;
    slow = tmp;
  }
複製代碼

最後對比就看下面具體代碼了

const isPalindrome = (head) => {
  if (head == null || head.next == null) {
    return true;
  }
  let fast = head;
  let slow = head;
  let prev;
  while (fast && fast.next) {
    prev = slow;
    slow = slow.next;
    fast = fast.next.next;
  }
  prev.next = null;  // 斷成兩個鏈表
  // 翻轉後半段
  let head2 = null;
  while (slow) {
    const tmp = slow.next;
    slow.next = head2;
    head2 = slow;
    slow = tmp;
  }
  // 比對
  while (head && head2) {
    if (head.val != head2.val) {
      return false;
    }
    head = head.next;
    head2 = head2.next;
  }
  return true;
};
複製代碼

237. 刪除鏈表中的節點

題目以下：

請編寫一個函數，使其能夠刪除某個鏈表中給定的（非末尾）節點。傳入函數的惟一參數爲要被刪除的節點。

現有一個鏈表 -- head = [4,5,1,9]，它能夠表示爲:

示例 1：

輸入：head = [4,5,1,9], node = 5
輸出：[4,1,9]
解釋：給定你鏈表中值爲 5 的第二個節點，那麼在調用了你的函數以後，該鏈表應變爲 4 -> 1 -> 9.
示例 2：

輸入：head = [4,5,1,9], node = 1
輸出：[4,5,9]
解釋：給定你鏈表中值爲 1 的第三個節點，那麼在調用了你的函數以後，該鏈表應變爲 4 -> 5 -> 9.
 

提示：

鏈表至少包含兩個節點。
鏈表中全部節點的值都是惟一的。
給定的節點爲非末尾節點而且必定是鏈表中的一個有效節點。
不要從你的函數中返回任何結果。
複製代碼

這個題很簡單，其實這個node是個引用類型，你只須要把node的val變爲node.next的val，而後node的next指向node.next.next，就移花接木，完成任務了！本身能夠試着在草稿上畫一下，結合代碼很快就會明白！

var deleteNode = function(node) {
  node.val = node.next.val
  node.next = node.next.next
};
複製代碼

283. 移動零

題目以下：給定一個數組 nums，編寫一個函數將全部 0 移動到數組的末尾，同時保持非零元素的相對順序。

示例:

輸入: [0,1,0,3,12]
輸出: [1,3,12,0,0]
說明:

必須在原數組上操做，不能拷貝額外的數組。
儘可能減小操做次數。
複製代碼

如動畫所示，咱們能夠用快慢指針來解答，具體很差用語言敘述，看動圖

var moveZeroes = function(nums) {
  let i = j = 0;
  while(i < nums.length) {
      if(nums[i] !== 0){
          [nums[i], nums[j]] = [nums[j], nums[i]]
          j++
      }
      i++
  }

  return nums
};
複製代碼

344. 反轉字符串

題目以下：

編寫一個函數，其做用是將輸入的字符串反轉過來。輸入字符串以字符數組 char[] 的形式給出。

不要給另外的數組分配額外的空間，你必須原地修改輸入數組、使用 O(1) 的額外空間解決這一問題。

你能夠假設數組中的全部字符都是 ASCII 碼錶中的可打印字符。

示例 1：

輸入：["h","e","l","l","o"]
輸出：["o","l","l","e","h"]
示例 2：

輸入：["H","a","n","n","a","h"]
輸出：["h","a","n","n","a","H"]
複製代碼

這個題目實在太簡單了，知道用首位雙指針便可，看參考：

var reverseString = function(s) {
  let l = 0 ;
  let r = s.length - 1;
  while(l < r){
    [s[l], s[r]] = [s[r], s[l]];
    l++; r--;
  }
  return s;
};
複製代碼

350. 兩個數組的交集II

題目以下：給定兩個數組，編寫一個函數來計算它們的交集。

示例 1：

輸入：nums1 = [1,2,2,1], nums2 = [2,2]
輸出：[2,2]
示例 2:

輸入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
輸出：[4,9]

說明：

輸出結果中每一個元素出現的次數，應與元素在兩個數組中出現次數的最小值一致。
咱們能夠不考慮輸出結果的順序。

複製代碼

這個取交集須要保留重複元素，能夠是用雙指針來解答，具體思路和代碼以下

若是兩個數組是有序的，則可使用雙指針的方法獲得兩個數組的交集。
首先對兩個數組進行排序，而後使用兩個指針遍歷兩個數組。
初始時，兩個指針分別指向兩個數組的頭部。每次比較兩個指針指向的兩個數組中的數字，若是兩個數字不相等，則將指向較小數字的指針右移一位，若是兩個數字相等，將該數字添加到答案，並將兩個指針都右移一位。當至少有一個指針超出數組範圍時，遍歷結束

var intersect = function(nums1, nums2) {
  nums1 = nums1.sort((a, b) => a - b);
  nums2 = nums2.sort((a, b) => a - b);
  let l1 = 0;
  let l2 = 0;
  const nums1Len = nums1.length;
  const nums2Len = nums2.length;
  const ret = [];
  while(l1 < nums1Len && l2 < nums2Len){
    if(nums1[l1] === nums2[l2]){
      ret.push(nums1[l1]);
      l1++;
      l2++;
    }
    if(nums1[l1] > nums2[l2]) l2++;
    if(nums1[l1] < nums2[l2]) l1++;
  }
  return ret;
};
複製代碼

剩下20道題的分類和解答應該明後天寫完，後續包括

棧
動態規劃
數學問題
環問題