前端面试——算法题
匹配括号
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. 前端面试算法题
- 2. 前端面试题--算法
- 3. 前端算法面试题汇总
- 4. 前端常见算法面试题
- 5. 前端面试遇到的算法题
- 6. 前端面试之算法题
- 7. 前端面试算法
- 8. 前端面试之算法
- 9. 96道前端面试题+前端经常使用算法
- 10. 后端面试算法题