29、酷家乐面试算法题

1、长字符串寻找给定的子串的索引

直接使用indexof

2、两个两个有序的数组

/*** * @param A int整型一维数组 * @param B int整型一维数组 * @return void*/function merge( A, m, B, n ) {// 每次从后面插入最大的元素let len = m+n;while(n>0 && m>0){if(A[m-1]>B[n-1]){A[--len] = A[--m];}else{A[--len] = B[--n];}}while(n){A[--len] = B[--n];}return A;
}
module.exports = {merge : merge
};

3、反转链表

/*** Definition for singly-linked list.* function ListNode(val) {*     this.val = val;*     this.next = null;* }*/
/*** @param {ListNode} head* @return {ListNode}*/
var reverseList = function(head) {//头插法let h = null;let p = null;while(head!=null){p = head.next;head.next = h;h = head;head = p;}return h;
};

4、两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个整数，并返回它们的数组下标。先返回较小的下标(下标从0开始)

/*** @param {number[]} nums* @param {number} target* @return {number[]}*/
var twoSum = function(nums, target) {let map = [];let res = [];for(let i=0; i<nums.length; i++){let p = target- nums[i];if(map[p]!=null){res[0] = map[p];res[1] = i;break;}else{map[nums[i]] = i;}}return res;
};

5、找最小的k个数

给定一个数组，找出其中最小的K个数。例如数组元素是4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。如果K>数组的长度，那么返回一个空的数组

function GetLeastNumbers_Solution(input, k)
{if(k>input.length){return [];}return input.sort((a,b) => (a-b)).slice(0,k);
}

6、给定一个链表，判断链表中是否有环。

快慢指针

/*** Definition for singly-linked list.* function ListNode(val) {*     this.val = val;*     this.next = null;* }*//*** @param {ListNode} head* @return {boolean}*/
var hasCycle = function(head) {if(head==null) return false;let fast = head;let slow = head;while(fast!=null && fast.next!=null){fast = fast.next.next;slow = slow.next;if(fast == slow){return true;}}return false;
};

7、链表中环的入口节点

/** function ListNode(x){*   this.val = x;*   this.next = null;* }*//*** * @param head ListNode类 * @return ListNode类*/
function detectCycle( head ) {if(head == null) {return head;}let slow = head;let fast = head;while(fast!=null && fast.next!=null){fast = fast.next.next;slow = slow.next;if(slow==fast){let slow2 = head;while(slow2 != slow){slow = slow.next;slow2 = slow2.next;}return slow2;}}}
module.exports = {detectCycle : detectCycle
};

8、调整数组顺序使奇数位于偶数前面

/*** @param {number[]} nums* @return {number[]}*/
var exchange = function(nums) {let i=0,j=nums.length-1;while(i<j){while(i<j && nums[i]%2==1){i++;}while(i<j && nums[j]%2==0){j--;}if(i<j){let temp = nums[i];nums[i] = nums[j];nums[j] = temp; }}return nums;
};

9、手写快排

function MySort( arr ) {QuickSort(arr,0,arr.length-1);return arr;
}
function QuickSort(arr, low, high){let l = low;let h = high;if(l<h){let p = arr[l];while(l<h){while(l<h && arr[h]>=p) h--;arr[l] = arr[h];while(l<h && arr[l]<=p) l++;arr[h] = arr[l];}arr[l] = p;QuickSort(arr,low,l-1);QuickSort(arr,l+1,high);}
}

10、手写树的遍历

分别按照二叉树先序，中序和后序打印所有的节点。

/** function TreeNode(x) {*   this.val = x;*   this.left = null;*   this.right = null;* }*//*** * @param root TreeNode类 the root of binary tree* @return int整型二维数组*/
function threeOrders( root ) {// write code herelet res=[];let a1 = [], a2=[], a3=[];pre(root,a1);mid(root,a2);post(root,a3);res.push(a1,a2,a3);return res;
}
function pre(root, a1){if(root!=null) a1.push(root.val);if(root.left) pre(root.left,a1);if(root.right) pre(root.right,a1);
}
function mid(root, a2){if(root.left) {mid(root.left,a2);}if(root!=null) a2.push(root.val);if(root.right) mid(root.right, a2);
}
function post(root, a3){if(root.left){post(root.left, a3);}if(root.right){post(root.right, a3);}if(root!=null) a3.push(root.val);
}
module.exports = {threeOrders : threeOrders
};

11、在二叉树中找到两个节点的最近公共祖先

function lowestCommonAncestor( root ,  o1 ,  o2 ) {return Ancestor(root, o1, o2).val;
}function Ancestor(root, o1, o2){//1. 遍历到叶子节点的孩子、o1或o2为根节点if(root==null || root.val==o1 || root.val==o2){return root;}//2. 分别遍历左右两侧中 o1和o2的公共祖先节点let left = Ancestor(root.left, o1, o2);let right = Ancestor(root.right, o1, o2);//3. o1和o2都在右子树中if(left==null){return right;}//4. o1和o2都在左子树中if(right==null){return left;}//5. o1和o2分别在左右子数中return root;
}

12、括号生成

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

方法：使用深度优先遍历。

使用加法，即 left 表示「左括号使用了几个」，right 表示「右括号使用了几个」，可以画出另一棵递归树。

/*** @param {number} n* @return {string[]}*/
var generateParenthesis = function(n) {let res = [];// 1. 生成的括号对数为0if(n==0){ return res;}//2. 深度优先遍历。//当前的括号组合为""，左括号使用了0个，右括号使用了0个，结果数组res, 生成n对括号dfs("", 0, 0, res, n);return res;
};
function dfs(cur, left, right, res, n){//1. 获取一对括号组合if(left == n && right == n){res.push(cur);return;}//2. 剪枝：右括号的数量多于左括号，错误if(left < right){return;}//3. 添加一个左括号if(left < n){dfs(cur+"(", left+1, right, res, n);}//4. 添加一个右括号if(right < n){dfs(cur+")", left, right+1, res, n);}
}

13、数组中有一个出现次数超过一半的数字，如何快速找到

摩尔投票法： 核心理念为 票数正负抵消 。此方法时间和空间复杂度分别为 O(N)O(N) 和 O(1)O(1) ，为本题的最佳解法。（将出现次数超过一半的数字记为众数）

推论一：若遇与众数相同的数字 +1 ，不相同 −1 ，则一定有所有数字的票数和 >0 。
推论二：若数组的前 a 个数字的票数和 =0 ，则数组剩余 (n−a) 个数字的票数和一定仍 >0，即后 (n-a)个数字的众数仍为 x。

算法流程:

初始化：票数统计 votes = 0 ，要找的数字记为x；
循环：遍历数组 nums 中的每个数字 num ；
当票数 votes 等于 0 ，则假设当前数字 num 是众数；
当 num = x 时，票数 votes 自增 1 ；当 num != x 时，票数 votes 自减 1 ；
返回值：返回 x 即可；

/*** @param {number[]} nums* @return {number}*/
var majorityElement = function(nums) {let x = nums[0], vote = 0;for(let i=0; i<nums.length; i++){//1. 票数为0，重新确定众数if(vote == 0) x = nums[i];//2. 与当前众数相同，+1；不同，-1if(nums[i] == x) vote++;else vote--;}//3. 验证 x 是否为众数let count = 0;for(let i=0; i<nums.length; i++){if(nums[i] == x) count++;}if(count > nums.length/2){return x;}else{return 0;}
};

14、求二叉树的最大深度

/*** Definition for a binary tree node.* function TreeNode(val) {*     this.val = val;*     this.left = this.right = null;* }*/
/*** @param {TreeNode} root* @return {number}*/
var maxDepth = function(root) {if(root==null) return 0;return Math.max(maxDepth(root.left) ,maxDepth(root.right))+1;
};

15、单链表的实现

16、数组去重，数组里面存的是数字或字符串

set集合

17、爬楼梯

18、获取一个链表的倒数第k个结点

19、冒泡排序

20、两个栈模拟一个队列，实现删除插入等功能