面试常见算法

目录

• 位运算
  • 计算汉明重量
  • 判断奇偶数
• 二分查找
  • 不用递归
  • 递归
• 常见排序
  • 快速排序
  • 冒泡排序
• 二叉树
  • 先序遍历
    • 递归实现
    • 非递归实现
  • 中序遍历
    • 递归实现
    • 非递归实现
  • 后序遍历
    • 递归实现
    • 非递归实现
  • 层叠遍历

参考：奇舞周刊

位运算

汉明距离 两个等长的字符串对应位置上的字符不同的个数

汉明重量 他是一个特殊的汉明距离，指一个字符串中非零字符的个数

计算汉明重量

function hanmingWeight(n) {
    let num = 0;
    while(n !== 0) {
        n &= (n-1);
        num++;
    }
    return num;
}

判断奇偶数

// 0001 0010 0011 0100 0101 0110 0111 1000
// 1    2    3    4    5    6    7    8
// 0001
function isOdd(n) {
    return n & 1 === 1;
}

二分查找

将原本是线性时间提升到了对数时间范围， 使用前提，必须在有序集合中查找

不用递归

function binarySearch(nums, target) {
    let high = nums.length - 1;
    let low = 0;
    while(low < high) {
        // parseInt向下取整
        let mid = parseInt((low + high) / 2);
        if (nums[mid] === target) {
            return mid;
        }
        if (nums[mid] > target) {
            // 不包括mid
            high = mid - 1;
        }
        if (nums[mid] < target) {
            // 不包括mid
            low = mid + 1;
        }
    }
}

递归

function binarySearch2(nums, target) {
    let low = 0;
    let high = nums.length - 1;

    const binaryWalk = (nums, low, high, target) => {
        if (low > high) return -1;
        let mid = parseInt((low + high) / 2);
        if (nums[mid] === target) return mid;
        if (nums[mid] > target) binaryWalk(nums, low, mid - 1, target);
        if (nums[mid] < target) binaryWalk(nums, mid + 1, high, target);
    }
    return binaryWalk(nums, low, high, target);
}

常见排序

快速排序

冒泡排序的改进版

任意选取一个元素作为基准（一般选取第一个元素），将待排序元素进行分区，比基准元素大的放右边，小的放左边

function quickSort(arr) {
    const len = arr.length;
    if(len <= 1) return arr;
    let left = [];
    let right = [];
    let pivot = arr[0];
    for (let i = 1;i < len; i++) {
        if (arr[i] >= pivot) {
            right.push(arr[i]);
        } else {
            left.push(arr[i]);
        }
    }
    return [...quickSort(left), ...quickSort[right]];
}

冒泡排序

比较相邻的元素，如果第一个比第二个大，就交换他们, 完成该步骤后，最后一个元素是数组中最大的数

针对所有元素重复上述步骤，除了最后一个

持续对越来越少的元素重复上述步骤，直到没有数字可以比较

function bubbleSort(arr) {
    let i = arr.length - 1;
    while(i > 0) {
        for(let j=0; j < i; j++) {
            if(arr[j] > arr[j + 1])  {
                [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
            }
        }
        i--;
    }

    return arr;
}

二叉树

有限个节点的集合

先序遍历

根节点排最先，然后同级先左后右

递归实现

function preOrderTraverse(root) {
    if (root) {
        console.log(root);
        preOrderTraverse(root.left);
        preOrderTraverse(root.right);
    }
}

非递归实现

function preOrderTraverse1(root) {
    let stack = [];

    if (root) {
        stack.push(root);
    }

    while(stack.length) {
        // 删除并返回数组的最后一个元素
        let temp = stack.pop();// 先进后出
        console.log(temp);

        if(temp.right) stack.push(temp.right);

        if(temp.left) stack.push(temp.left);
    }
}

中序遍历

先左后根最后右

递归实现

function midOrderTraverse(root) {
    if(root) {
        midOrderTraverse(root.left);
        console.log(root);
        midOrderTraverse(root.right);
    }
}

非递归实现

function midOrderTraverse1(root) {
    let stack = [];
    while(true) {
        while(root) {
            stack.push(root);
            root = root.left;
        }

        if(!stack.length) break;

        let temp = stack.pop();
        console.log(temp);
        root = temp.right;
    }
}

后序遍历

先左后右最后根

递归实现

function postOrderTraverse(root) {
    if (root) {
        postOrderTraverse(root.left);
        postOrderTraverse(root.right);
        console.log(root);
    }
}

非递归实现

function postOrderTraverse1(root) {
    let stack = [];
    let rest = [];
    if(root)stack.push(root);
    while(stack.length) {
      let temp = stack.pop();
      rest.push(temp);
      if(temp.left) stack.push(temp.left);
      if(temp.right) stack.push(temp.right);
    }
    return rest.reverse();
  }

层叠遍历

从上到下一层一层遍历

function levelTraverse(root) {
    if(!root) return;
    let stack = [];
    stack.push(root);
    while(stack.length) {
        // 删除数组中的第一个元素并返回
        let temp = stack.shift();// 先进先出
        console.log(temp);
        if(temp.left) stack.push(temp.left);
        if(temp.right) stack.push(temp.right);
    }
}