javascript 常見的面試題---數組 && 算法

網上匯總而來的題目。

第一題：

用 JavaScript 寫一個函數，輸入 int 型（正整數），返回整數逆序后的字符串。如：輸入整型 1234，返回字符串“4321”。

要求必須使用遞歸函數調用，不能用全局變量，輸入函數必須只有一個參數傳入，必須返回字符串。

查看代碼

// 推薦方法
function format(num) {
  const num1 = num / 10;
  const num2 = num % 10;
  if (num1 < 1) {
    return `${num}`;
  } else {
    num = parseInt(num1);
    return `${num2}${format(num)}`;
  }
}
// 其他實現方法
function format(num) {
  return `${num}`.length === 1 ? `${num}` : `${num}`.slice(-1) + format(`${num}`.slice(0, -1));
}
function format(num) {// 不符合題意，就當順便復習下這些api吧 emmmm....
  return num < 10 ? `${num}` : `${num}`.split('').reverse().join('');
}
// 方法1簡寫
function format(num) {
  return num / 10 < 1 ? `${num}` : `${num % 10}${format(parseInt(num / 10))}`;
}

 

---

 第二題：

給定兩個數組，寫一個方法來計算它們的交集。

例如：給定 nums1 = [1, 2, 2, 1]，nums2 = [2, 2]，返回 [2, 2]。

查看代碼

巨佬的總結：算法題，求兩個數組的最長公共子序列。

思路1：空間換時間。建個表，存放其中一個數組的值和該值出現的次數。此處遍歷n次，n為數組的長度。

接着遍歷另外一個數組。如果數組的值出現在表的鍵里，則把值push進result數組。該鍵對應的值減一。此處遍歷m次，m為數組的長度。時間復雜度O(m+n)。

代碼實現：

function myIntersection(arr1, arr2) {
  const result = [];
  const map = {};

  for (let val of arr1) {
    if (!!map[val]) {
      map[val]++;
    } else {
      map[val] = 1;
    }
  }

  arr2.forEach(val => {
    if (!!map[val]) {
      result.push(val);
      map[val]--;      
    }
  });
  return result;
}

思路2：時間換空間。遍歷其中一個數組，判斷另外一個數組中是否包含該值，有則push進result數組，並在另外一個數組中刪除該值。

代碼實現：

function myIntersection(arr1, arr2) {
  const _arr2 = [...arr2];
  return arr1.filter(val => {
    const idx = _arr2.indexOf(val);
    if (idx > -1) {
      _arr2.splice(idx, 1);
      return true;
    }
    return false;
  });
}

這里直接filter方法返回數組，需要注意的是splice方法會改變原數組。

 

---

 第三題：

冒泡排序如何實現，時間復雜度是多少， 還可以如何改進？

查看代碼

function myBubbleSort(arr, cb = (x, y) => x - y) {
  const res = cb(1, 2);
  
  let i, j, len = arr.length;
  if (res < 0) {// 升序
    for (i = 0; i < len; i++) {
      for(j = 0; j < len - i - 1; j++) {
        if (arr[j] > arr[j + 1]) {
          [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
        }
      }
    }
  } else {// 降序
    for (i = 0; i < len; i++) {
      for(j = len - 1; j > i; j--) {
        if (arr[j] > arr[j - 1]) {
          [arr[j], arr[j - 1]] = [arr[j - 1], arr[j]];
        }
      }
    }
  }
}

時間復雜度O(n^2)。簡單改進：

function myBubbleSort(arr) {
  let len = arr.length - 1;

  while (len > 0) {
    let pos = 0;

    for (let i = 0; i < len; i++) {
      if (arr[i] > arr[i + 1]) {
        pos = i;
        [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]];
      }
    }
    len = pos;
  }
}

思路是把可能出現的好的情況挑出來。注意以上都直接改變了原數組。

 

---

 第四題：

某公司 1 到 12 月份的銷售額存在一個對象里面。

如下：{1:222, 2:123, 5:888}，請把數據處理為如下結構：[222, 123, null, null, 888, null, null, null, null, null, null, null]

查看代碼

function format(origin) {
  const res = [];
  for (let i = 0; i < 12; i++) {
    res[i] = origin[i + 1] || null;
  }
  return res;
}

或者

function format(origin) {
  return Array.from(new Array(12)).map((_, i) => origin[i + 1] || null);
}

 

 

---

第五題：

使用 sort() 對數組 [3, 15, 8, 29, 102, 22] 進行排序，輸出結果

查看代碼

[3, 15, 8, 29, 102, 22].sort();

輸出結果是：[102, 15, 22, 29, 3, 8]。

sort方法在不傳回調函數的情況下。默認將值轉化成字符串，然后按照字符串字符的utf-16編碼比較大小。

先比較首字符。如果首字符相同，則比較第二個字符，以此類推。升序。

js查看字符串字符utf-16編碼對應api是String.prototype.charCodeAt();

 

---

第六題：

兩個數組合並成一個數組

請把兩個數組 ['A1', 'A2', 'B1', 'B2', 'C1', 'C2', 'D1', 'D2'] 和 ['A', 'B', 'C', 'D']，合並為 ['A1', 'A2', 'A', 'B1', 'B2', 'B', 'C1', 'C2', 'C', 'D1', 'D2', 'D']。

查看代碼

 就這題而言：

const arr1 = ['A1', 'A2', 'B1', 'B2', 'C1', 'C2', 'D1', 'D2'];
const arr2 = ['A', 'B', 'C', 'D'];
const _arr = arr1.concat(arr2.map(val => `${val}3`));
const newArr = _arr.sort().map(val => val.includes('3') ? val.replace('3', '') :
val);

或者：

const newArr = arr2.reduce((cur, next) => [...cur, ...arr1.filter(val => val.startsWith(next)), next], []);

 

 

---

第七題：

已知如下數組：

var arr = [ [1, 2, 2], [3, 4, 5, 5], [6, 7, 8, 9, [11, 12, [12, 13, [14] ] ] ], 10];

編寫一個程序將數組扁平化去並除其中重復部分數據，最終得到一個升序且不重復的數組

查看代碼

 方法1：

const arr3 = [ [1, 2, 2], [3, 4, 5, 5], [6, 7, 8, 9, [11, 12, [12, 13, [14] ] ] ], 10];
const arr5 = [...new Set(arr3.flat(Infinity))].sort((x, y) => x - y);

flat方法可以將數組拍扁。Set構造函數去重，sort方法排序。

方法2：

const arr3 = [ [1, 2, 2], [3, 4, 5, 5], [6, 7, 8, 9, [11, 12, [12, 13, [14] ] ] ], 10];
const arr6 = Array.from(new Set(arr3.join(',').split(',').map(Number).sort((x, y) => x - y)));

set構造函數去重，join方法把數組拍扁，由於值變成了字符串，split方法轉成數組后，map方法加Number轉成數字。sort方法排序。

方法3：

function format(arr) {
  return arr.reduce((acc, val) => Array.isArray(val) ? acc.concat(format(val)) : acc.concat(val), []);
}

　　

  const arr3 = [ [1, 2, 2], [3, 4, 5, 5], [6, 7, 8, 9, [11, 12, [12, 13, [14] ] ] ], [10]];

  const arr4 = [...new Set(format(arr3))].sort((x, y) => x - y);

reduce、concat方法加遞歸把數組拍扁。Set構造函數去重。sort方法排序。

方法4：

function format(arr) {
  const res = [];
  const stack = [...arr];
  while (stack.length) {
    const next = stack.pop();
    if (Array.isArray(next)) {
      stack.push(...next);
    } else {
      res.push(next);
    }
  }
  return [...new Set(res)].sort((x, y) => x - y);
}

棧方法把數組拍扁。使用數組的push、pop方法實現后進先出。

 

---

第八題：

 給定一個數組 nums，編寫一個函數將所有 0 移動到數組的末尾，同時保持非零元素的相對順序。

示例:

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

說明:

1. 必須在原數組上操作，不能拷貝額外的數組。

2. 盡量減少操作次數。

查看代碼

 方法1：冒泡排序的思路。比較相鄰兩個值，若為0，交換位置。代碼演示：

function format(arr) {
  let len = arr.length - 1;

  while (len) {
    let pos = 0;

    for (let i = 0; i < len; i++) {
      if (arr[i] === 0) {
        [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]];
        pos = i;
      }
    }
    
    len = pos;
  }
}

方法2：數組的push方法實現0的移動，splice方法保持順序不變。代碼演示：

驗證： 

function format(arr) {
  let i, len = arr.length;
  for (i = 0; i < len; i++) {
    if (arr[i] === 0) {
      arr.push(0);
      arr.splice(arr.indexOf(0), 1);
      i--;
      len--;
    }
  }
}

push0進數組后，遍歷長度需要減1。0無需在遍歷。刪除數組當前項后，i需減1

const arr = [5, 0, 0, 0, 3, 0, 12, 0];
format(arr);
console.log(arr);

 

---

第九題：

打印出 1 - 10000 之間的所有對稱數

例如：121、1331 等

查看代碼

方法1：對稱數反過來也是原來那個數，利用這個特點。

function printNum() {
  return [...Array(10000).keys()].filter(val => val > 10 && `${val}`.split('').reverse().join('') == val);
}

不管三七二十一循環10000次，每個值先轉成字符串再拆成數組在反轉在轉化成字符串，最后利用隱式轉換與原值比較，判斷是否相等。

方法2：

function printNum() {
  let i, _i, res = [];
  for (i = 1; i < 10; i++) {
    res.push(i * 11);
    _i = 0;
    while (_i < 10) {
      res.push(i * 101 + _i * 10);
      res.push(i * 1001 + _i * 110);
      _i++;
    }
  }
  return res;
}

利用對稱數的特點，用數學的方式實現。外層循環9層，1-9。內層10次。總共90次。

 

---

第十題：

 給定一個數組，將數組中的元素向右移動 k 個位置，其中 k 是非負數。

查看代碼

 方法1：pop、unshift方法實現從尾到頭。

function carousel(arr, k = 0) {
  let  i, len = arr.length;
  for (i = 0; i < k % len; i++) {
    arr.unshift(arr.pop(len - 1));
  }
}

k值有可能大於數組長度，取余可以避免不必要的循環。

方法2：

function carousel([...arr], k = 0) {
  return arr.splice(-k % arr.length).concat(arr);
}

k值有可能大於數組長度，對數組長度取余，余數為需要旋轉的個數。利用splice方法第一個參數為負數時，值為數組長度+負值。

截取需要旋轉的部分，然后再和原數組拼接。

有錯誤的地方歡迎指出。