前端面試——算法題
匹配括號
var isValid = function(s) {
let map = {
'(': -1,
')': 1,
'[': -2,
']': 2,
'{': -3,
'}': 3
}
let stack = []
for (let i = 0; i < s.length; i++) {
if (map[s[i]] < 0) {
stack.push(s[i])
} else {
let last = stack.pop()
if (map[last] + map[s[i]] != 0) return false
}
}
if (stack.length > 0) return false
return true
}複製代碼
位運算與按位運算
左移 <<
左移能夠當作a*(2 ^ b)
node
右移 >>
右移能夠當作v = a / (2 ^ b)
git
按位與
每一位都爲 1，結果才爲 1算法
按位或shell
其中一位爲 1，結果就是 1api
按位異或數組
每一位都不一樣，結果才爲 1bash
二分查找
function binary_search(arr,low, high, key) {
if (low > high){
return -1;
}
var mid = parseInt((high + low) / 2);
if(arr[mid] == key){
return mid;
}else if (arr[mid] > key){
high = mid - 1;
return binary_search(arr, low, high, key);
}else if (arr[mid] < key){
low = mid + 1;
return binary_search(arr, low, high, key);
}
};
var arr = [1,2,3,4,5,6,7,8,9,10,11,23,44,86];
var result = binary_search(arr, 0, 13, 10); 複製代碼
兩個數不使用四則運算得出和
function sum(a, b) {
if (a == 0) return b
if (b == 0) return a
let newA = a ^ b//異或
let newB = (a & b) << 1
return sum(newA, newB)
}複製代碼
駝峯轉換
function toHump(name) { return name.replace(/\_(\w)/g, function(all, letter){ return letter.toUpperCase(); });}複製代碼
排序
原文連接：blog.csdn.net/YongxiaWu/a…ui
一、插入排序——直接插入排序
基本思想
a、先將待排序序列的第1個元素當作是一個有序的子序列；
b、從第2個元素開始，逐個將待排序的元素x與已排序序列[i-1] ~[0]（從後往前）進行比較；
c、若x小於比較元素，則比較元素向後移動一位；不然，將x插入序列當前位置。
spa
function insertSort(arr){
//第一層循環：遍歷待比較的數組元素
for(let i = 1; i < arr.length; i++){
let temp = arr[i];
//第二層循環：將本輪帶比較的元素與已經排序的元素相比較
for(var j = i - 1; j >= 0 && arr[j] > temp; j--){
arr[j + 1] = arr[j];
}
//將插入元素插入到正確位置
arr[j + 1] = temp;
}
return arr;
}複製代碼
二、插入排序——希爾排序（最小增量排序）
基本思想–直接插入排序的改進 .net
a、先將要數組按某個增量d（n/2,n爲要排序數的個數）分紅若干組，全部距離爲d的倍數的記錄放在同一個組中；在各組內進行直接插入排序；
b、而後再用一個較小的增量（d/2）對它進行分組，每組再進行直接插入排序；直至增量減爲1，進行直接插入排序後，總體排序完成。
function shellSort(arr){
let n = arr.length,
d = n;
//第一層循環:分割增量d
while(d > 1){
d = Math.floor(d/2);
//下面；兩層循環是直接插入排
for(var i = d; i < n; i++){
//記錄待比較的元素
var temp = arr[i];
for(var j = i - d; j >= 0 && arr[j] > temp; j = j -d){
arr[j + d] = arr[j];
}
arr[j + d] = temp;
}
}
return arr;
}複製代碼
三、選擇排序——簡單選擇排序
基本思想——比較+交換
每次遍歷找到待排序元素中的最小值，將最小值和待排序的第一個元素交換，直至排序結束。
function directSelectSort(arr){
let minIndex, temp;
for(var i = 0; i < arr.length; i++){
minIndex = i;
//找到最小的值
for(var j = i + 1; j < arr.length; j++){
if(arr[j] < arr[minIndex]){
minIndex = j;
}
}
//將最小的值與未排序的第一個元素進行交換
temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
return arr;
}複製代碼
四、選擇排序——堆排序
基本思想
大頂堆：每一個節點的值都大於或等於其子節點的值，在堆排序算法中用於升序排列；
a、首先將長度爲n的序列構建稱爲大頂堆，此時根節點必定是當前序列的最大值；
b、取出當前大頂堆的根節點，將其與序列末尾元素進行交換；
c、對交換後的n-1個序列元素進行調整，使其知足大頂堆的性質；
d、重複b、c兩個步驟，直至堆中只有1個元素爲止。
小頂堆：每一個節點的值都小於或等於其子節點的值，在堆排序算法中用於降序排列。
function heapSort1(arr) {
len = arr.length;
//建堆
for(let i = Math.floor(len/2); i >= 0; i--){
heapify(arr, i);
}
for(let i = len - 1; i > 0; i--){
//輸出堆頂元素
[arr[0], arr[i]] = [arr[i], arr[0]];
len--;
//從新調整堆
heapify(arr, 0);
}
return arr;
}
//調整堆
function heapify(arr, i) {
var left = 2 * i + 1,
right = 2 * i + 2,
largest = i;
if(left < len && arr[left] > arr[largest]){
largest = left;
}
if(right < len && arr[right] > arr[largest]){
largest = right;
}
if(largest !== i){
[arr[i], arr[largest]] = [arr[largest], arr[i]];
heapify(arr, largest);
}
}複製代碼
五、交換排序——冒泡排序
基本思想
兩兩比較相鄰的元素，若是反序，則交換位置，直到沒有反序爲止。有序區在後面。
a、將序列中的相鄰元素依次比較，較大的數向上冒（即交換到後面）；第一輪比較結束後，序列最後一個元素是當前序列的最大值。
b、對序列當中剩下的n-1個元素再次執行步驟b，直至完成。共須要n-1輪比較。
function bubbleSort(arr) {
let len = arr.length;
//共須要n-1趟排序
for(let i = 1; i < len; i++){
for(let j = 0; j < len - i; j++){
if(arr[j] > arr[j + 1]){
[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]]; //解構賦值進行交換
}
}
}
return arr;
}
console.log(bubbleSort([7, 3, 4, 5, 10, 7, 8, 2,21]));
//改進的冒泡排序，記錄上次交換的位置pos，避免對排好序的數據進行重複比較
function bubbleSort1(arr) {
let len = arr.length;
var pos = len; //初始化時無序元素的範圍
while(pos !== 0){
var bound = pos; //本趟無序元素的範圍
pos = 0;
for(let i = 0; i < bound; i++){
if(arr[i] > arr[i + 1]){
[arr[i], arr[i + 1]] = [arr[i + 1], arr[i]]; //解構賦值進行交換
pos = i;
}
}
}
return arr;
}
console.log(bubbleSort1([7,2, 3, 4, 5, 10, 7, 8, 2,21]));複製代碼
六、交換排序——快速排序
基本思想：
a、從序列當中選擇一個基準數（通常選第一個數）；
b、遍歷數組，小於基準的放在left，大於基準的放在right；
c、遞歸。
//方式1
function QSort(arr) {
//若是數組<=1,則直接返回
if(arr.length <= 1){
return arr;
}
//找基準，並把基準從原數組刪除
var pivot = arr.splice(0, 1)[0];
//定義左右數組
var left = [];
var right = [];
//比基準小的放在left，比基準大的放在right
for(var i = 0; i < arr.length; i++){
if(arr[i] <= pivot){
left.push(arr[i]);
}
else{
right.push(arr[i]);
}
}
//遞歸
return QSort(left).concat([pivot],QSort(right));
}
console.log(QSort([7,2, 3, 4, 5, 10, 7, 8, 2,21]));
//方式2
function QSort2(arr, left, right) {
if(left < right){
//找基數第一趟排序後的位置
let pivot = partion(arr,left,right);
//遞歸排序左右區間
QSort2(arr, left, pivot - 1);
QSort2(arr, pivot + 1, right);
}
return arr;
}
//快排第一趟
function partion(arr, left, right) {
//第一個元素做爲基數
let pivotVal = arr[left];
pivot = left;
while(left<right){
while(right>left && arr[right]>=pivotVal){
right--;
}
[arr[left], arr[right]] = [arr[right], arr[left]];
while(left<right && arr[left]<=pivotVal){
left++;
}
[arr[left], arr[right]] = [arr[right], arr[left]];
}
return left;
}
var arr = [7,2, 3, 4, 5, 10, 7, 8, 2,21];
console.log(QSort2(arr, 0, arr.length-1));複製代碼
七、歸併排序
基本思想
a、先將數組進行分組（折半拆分），直至子序列長度爲1；
b、而後再將子數組進行合併，關鍵點是實現兩個數組的合併。
function merge(left, right) {
var res = [];
while(left.length > 0 && right.length > 0){
if(left[0] <= right[0]){
res.push(left.shift()); //刪除第一個元素，並將其返回
}else{
res.push(right.shift());
}
}
return res.concat(left, right);
}
//歸併排序
function mergeSort(arr){
//一直分到長度爲1時，中止遞歸
if(arr.length === 1){
return arr;
}
var mid = Math.floor(arr.length/2);
var left = arr.slice(0, mid);
var right = arr.slice(mid);
return merge(mergeSort(left), mergeSort(right));
}
console.log(mergeSort([7,2, 3, 4, 5, 10, 7, 8,21]));複製代碼
八、基數排序
基本思想
一、MSD 從高位開始進行排序
二、LSD 從低位開始進行排序：
a、將全部待比較元素（正整數）統一爲一樣的數位長度，數位較短的數前面補零；
b、從個位開始，進行排序；而後一次從低位到高位，進行排序；直至最高位完成排序。
function radixSort(arr, maxDigit) { //maxDigit表示最大數字的位數
var counter = [];
var mod = 10; //以十進制進行排序
var dev = 1;
for (var i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
for(var j = 0; j < arr.length; j++) {
var bucket = parseInt((arr[j] % mod) / dev);
if (counter[bucket]==null) {
counter[bucket] = [];
}
counter[bucket].push(arr[j]);
}
var pos = 0;
for(var j = 0; j < counter.length; j++) {
var value = null;
if(counter[j]!=null) {
while ((value = counter[j].shift()) != null) {
arr[pos++] = value;
}
}
}
}
return arr;
}
var a = [3, 4, 5, 10, 713, 8,21,4,2,124];
console.log(radixSort(a, 3));複製代碼
比較
反轉二叉樹
function Mirror(root){
if(root === null) {
return ;
}
let temp = root.left;
root.left = root.right;
root.right = temp;
Mirror(root.left);
Mirror(root.right);
}複製代碼
深度優先遍歷
let deepTraversal2 = (node) => {
let nodes = []
if (node !== null) {
nodes.push(node)
let children = node.children
for (let i = 0; i < children.length; i++) {
nodes = nodes.concat(deepTraversal2(children[i]))
}
}
return nodes
}複製代碼
廣度優先遍歷
let widthTraversal2 = (node) => {
let nodes = []
let stack = []
if (node) {
stack.push(node)
while (stack.length) {
let item = stack.shift()
let children = item.children
nodes.push(item)
for (let i = 0; i < children.length; i++) {
stack.push(children[i])
}
}
}
return nodes
}複製代碼
斐波那契數列
function Fibonacci(n)
{
// write code here
if(n<1){
return 0;
}
if(n==1||n==2){
return 1;
}
var f1 = 1;
var f2 = 1;
var temp;
for(let i=2;i<n;i++){
temp =f2
f2 = f1+f2;
f1 =temp;
}
return f2;
}複製代碼
青蛙跳臺階
function jumpFloor(number)
{
if(number<=0){
return 0;
}else if(number==1){
return 1;
}else if(number==2){
return 2;
}else{
var f1=1;
var f2=2;
var fn;
for(var i=2;i<number;i++){
fn=f1+f2;
f1=f2;
f2=fn;
}
return fn;
}
}複製代碼
變態跳臺階
function jumpFloorII(n)
{
// write code here
if(n<=0){
return 0;
}
if(n==1){
return 1;
}
if(n==2){
return 2;
}
return 2*jumpFloorII(n-1);
}複製代碼
樹的深度
function TreeDepth(pRoot){
if(pRoot){
var right = 1 +TreeDepth(pRoot.right);
var left = 1 +TreeDepth(pRoot.left);
}else{
return 0;
}
return Math.max(right,left)
}複製代碼
樹的遍歷
function DLR(root){
if(root){
console.log(root.val)
}
if(root.left){
DLR(root.left);
}
if(root.right){
DLR(root.right);
}
}
//前序遍歷
function LDR(root){
if(root.left){
LDR(root.left); }
if(root){
console.log(root.val)
}
if(root.right){
LDR(root.right); }
}
//中序遍歷
function LRD(root){
if(root.left){
LRD(root.left); }
if(root.right){
LRD(root.right); }
if(root){
console.log(root.val)
}
}
//後序遍歷複製代碼
JavaScript版本號對比
/*
- 版本號比較方法
- 傳入兩個字符串，當前版本號：curV；比較版本號：reqV
- 調用方法舉例：compare("1.1","1.2")，將返回false
*/
function compare(curV,reqV){
if(curV && reqV){
//將兩個版本號拆成數字
var arr1 = curV.split('.'),
arr2 = reqV.split('.');
var minLength=Math.min(arr1.length,arr2.length),
position=0,
diff=0;
while(position<minLength && ((diff=parseInt(arr1[position])-parseInt(arr2[position]))==0)){
position++;
}
diff=(diff!=0)?diff:(arr1.length-arr2.length);
//若curV大於reqV，則返回true
return diff>0;
}else{
//輸入爲空
console.log("版本號不能爲空");
return false;
}
}複製代碼
揹包問題
| 物品 ID / 重量 | 價值 |
|---|---|
| 1 | 3 |
| 2 | 7 |
| 3 | 12 |
| 物品 ID / 剩餘容量 | 0 | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|---|
| 1 | 0 | 3 | 3 | 3 | 3 | 3 |
| 2 | 0 | 3 | 7 | 10 | 10 | 10 |
| 3 | 0 | 3 | 7 | 12 | 15 | 19 |
/**
* @param {*} w 物品重量
* @param {*} v 物品價值
* @param {*} C 總容量
* @returns
*/
function knapsack(w, v, C) {
let length = w.length
if (length === 0) return 0
// 對照表格，生成的二維數組，第一維表明物品，第二維表明揹包剩餘容量
// 第二維中的元素表明揹包物品總價值
let array = new Array(length).fill(new Array(C + 1).fill(null))
// 完成底部子問題的解
for (let i = 0; i <= C; i++) {
// 對照表格第一行， array[0] 表明物品 1
// i 表明剩餘總容量
// 當剩餘總容量大於物品 1 的重量時，記錄下揹包物品總價值，不然價值爲 0
array[0][i] = i >= w[0] ? v[0] : 0
}
// 自底向上開始解決子問題，從物品 2 開始
for (let i = 1; i < length; i++) {
for (let j = 0; j <= C; j++) {
// 這裏求解子問題，分別爲不放當前物品和放當前物品
// 先求不放當前物品的揹包總價值，這裏的值也就是對應表格中上一行對應的值
array[i][j] = array[i - 1][j]
// 判斷當前剩餘容量是否能夠放入當前物品
if (j >= w[i]) {
// 能夠放入的話，就比大小
// 放入當前物品和不放入當前物品，哪一個揹包總價值大
array[i][j] = Math.max(array[i][j], v[i] + array[i - 1][j - w[i]])
}
}
}
return array[length - 1][C]
}複製代碼
最長遞增子序列
| 數字 | 0 | 3 | 4 | 17 | 2 | 8 | 6 | 10 |
|---|---|---|---|---|---|---|---|---|
| 長度 | 1 | 2 | 3 | 4 | 2 | 4 | 4 | 5 |
function lis(n) {
if (n.length === 0) return 0
// 建立一個和參數相同大小的數組，並填充值爲 1
let array = new Array(n.length).fill(1)
// 從索引 1 開始遍歷，由於數組已經全部都填充爲 1 了
for (let i = 1; i < n.length; i++) {
// 從索引 0 遍歷到 i
// 判斷索引 i 上的值是否大於以前的值
for (let j = 0; j < i; j++) {
if (n[i] > n[j]) {
array[i] = Math.max(array[i], 1 + array[j])
}
}
}
let res = 1
for (let i = 0; i < array.length; i++) {
res = Math.max(res, array[i])
}
return res
}複製代碼
相關文章
- 1. 前端面試算法題
- 2. 前端面試題--算法
- 3. 前端算法面試題彙總
- 4. 前端常見算法面試題
- 5. 前端面試遇到的算法題
- 6. 前端面試之算法題
- 7. 前端面試算法
- 8. 前端面試之算法
- 9. 96道前端面試題+前端經常使用算法
- 10. 後端面試算法題
- 更多相關文章...
- • Lua 調試(Debug) - Lua 教程
- • Markdown 標題 - Markdown 教程
- • 使用阿里雲OSS+CDN部署前端頁面與加速靜態資源
- • 算法總結-廣度優先算法
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. Duang!超快Wi-Fi來襲
- 2. 機器學習-補充03 神經網絡之**函數(Activation Function)
- 3. git上開源maven項目部署 多module maven項目（多module maven+redis+tomcat+mysql）後臺部署流程學習記錄
- 4. ecliple-tomcat部署maven項目方式之一
- 5. eclipse新導入的項目經常可以看到「XX cannot be resolved to a type」的報錯信息
- 6. Spark RDD的依賴於DAG的工作原理
- 7. VMware安裝CentOS-8教程詳解
- 8. YDOOK：Java 項目 Spring 項目導入基本四大 jar 包 導入依賴，怎樣在 IDEA 的項目結構中導入 jar 包 導入依賴
- 9. 簡單方法使得putty（windows10上）可以免密登錄樹莓派
- 10. idea怎麼用本地maven
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 前端面試算法題
- 2. 前端面試題--算法
- 3. 前端算法面試題彙總
- 4. 前端常見算法面試題
- 5. 前端面試遇到的算法題
- 6. 前端面試之算法題
- 7. 前端面試算法
- 8. 前端面試之算法
- 9. 96道前端面試題+前端經常使用算法
- 10. 後端面試算法題