剑指offer算法05

27. 二叉树的镜像

请完成一个函数，输入一个二叉树，该函数输出它的镜像。

例如输入：

     4
   /   \
  2     7
 / \   / \
1   3 6   9

镜像输出：

     4
   /   \
  7     2
 / \   / \
9   6 3   1

示例 1：

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {TreeNode}
 */
var mirrorTree = function(root) {
    if(root==null)
    {
        return root;
    }
    
    let temp;
    temp=root.left;
    root.left=root.right;
    root.right=temp;

    root.left=mirrorTree(root.left);
    root.right=mirrorTree(root.right);

    return root;
};

Offer 28. 对称的二叉树

请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

    1
   / \
  2   2
 / \ / \
3  4 4  3

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

    1
   / \
  2   2
   \   \
   3    3

示例 1：

输入：root = [1,2,2,3,4,4,3]
输出：true

示例 2：

输入：root = [1,2,2,null,3,null,3]
输出：false

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {boolean}
 */
var isSymmetric = function(root) {
    function isMirror(r1,r2){
        if(!r1&&!r2) return true
        if(!r1||!r2) return false

        return r1.val===r2.val&&isMirror(r1.left,r2.right)&&isMirror(r1.right,r2.left)
    }

    return isMirror(root,root)
};

30. 包含min函数的栈

定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。

示例:

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.min();   --> 返回 -3.
minStack.pop();
minStack.top();      --> 返回 0.
minStack.min();   --> 返回 -2.

/**
 * initialize your data structure here.
 */
var MinStack = function() {
    this.dataStack=[];
    this.minStack=[];
};

/** 
 * @param {number} x
 * @return {void}
 */
MinStack.prototype.push = function(x) {
    this.dataStack.push(x);
    let num = this.dataStack[this.dataStack.length-1];

    if(this.minStack.length==0)
    {
        this.minStack.push(x);
    }else if(num<=this.minStack[this.minStack.length-1])
    {
        this.minStack.push(x);
    }

};

/**
 * @return {void}
 */
MinStack.prototype.pop = function() {
    let num = this.dataStack[this.dataStack.length-1];
    this.dataStack.pop();
    
    if(this.minStack[this.minStack.length-1]==num)
    {
        this.minStack.pop();
    }
};

/**
 * @return {number}
 */
MinStack.prototype.top = function() {
    let num = this.dataStack[this.dataStack.length-1];
    if(this.dataStack.length){
        return num;
    }else{
        return null;
    }
};

/**
 * @return {number}
 */
MinStack.prototype.min = function() {
    if(this.minStack.length){
        return this.minStack[this.minStack.length-1];
    }else{
        return null;
    }
};

/**
 * Your MinStack object will be instantiated and called as such:
 * var obj = new MinStack()
 * obj.push(x)
 * obj.pop()
 * var param_3 = obj.top()
 * var param_4 = obj.min()
 */

39.数组中出现次数超过一半的数字

数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

示例 1:

输入: [1, 2, 3, 2, 2, 2, 5, 4, 2]
输出: 2

/**
* @param {number[]} nums
* @return {number}
*/
var majorityElement = function(nums) {
   nums.sort((a,b)=>a-b);
   return nums[Math.floor(nums.length/2)];
}

40.最小的k个数

输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。

示例 1：

输入：arr = [3,2,1], k = 2
输出：[1,2] 或者 [2,1]

示例 2：

输入：arr = [0,1,2,1], k = 1
输出：[0]

/**
 * @param {number[]} arr
 * @param {number} k
 * @return {number[]}
 */
var getLeastNumbers = function(arr, k) {
    arr.sort((a,b)=>a-b);
    var number=[];
    for(var i=0;i<k;i++)
    {
        number.push(arr[i]);
    }
    return number;
};

50. 第一个只出现一次的字符

在字符串 s 中找出第一个只出现一次的字符。如果没有，返回一个单空格。 s 只包含小写字母。

示例:

s = "abaccdeff"
返回 "b"

s = "" 
返回 " "

/**
 * @param {string} s
 * @return {character}
 */
var firstUniqChar = function(s) {
    let str=s.split('');
    for(let i=0;i<str.length;i++)
    {
        if(str.indexOf(str[i])==str.lastIndexOf(str[i]))
        {
            return str[i];
        }
    }
    return " ";
};

52.两个链表的第一个公共节点

这题蛮有意思的，终究会相遇

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */

/**
 * @param {ListNode} headA
 * @param {ListNode} headB
 * @return {ListNode}
 */
var getIntersectionNode = function(headA, headB) {
    var h1=headA,h2=headB;

    while(h1!==h2)
    {
        h1=h1?h1.next:headB;
        h2=h2?h2.next:headA;
    }
    return h1;
};

53 - I. 在排序数组中查找数字 I

统计一个数字在排序数组中出现的次数。

示例 1:

输入: nums = [5,7,7,8,8,10], target = 8
输出: 2

示例 2:

输入: nums = [5,7,7,8,8,10], target = 6
输出: 0

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
var search = function(nums, target) {
    if(nums.indexOf(target)==-1)
    {
        return 0;
    }
    return nums.lastIndexOf(target)-nums.indexOf(target)+1;
};

53 - II. 0～n-1中缺失的数字

一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0～n-1之内。在范围0～n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字。

示例 1:

输入: [0,1,3]
输出: 2

示例 2:

输入: [0,1,2,3,4,5,6,7,9]
输出: 8

/**
 * @param {number[]} nums
 * @return {number}
 */
var missingNumber = function(nums) {
    let n=0;
    for(let i=0;i<nums.length;i++)
    {
        if(nums[i]!=n)
        {
            return n;
        }
        n++;
    }
    return n;

};

57. 和为s的两个数字

这个要用双指针压缩左右两边的边界，不然会超时。

输入一个递增排序的数组和一个数字s，在数组中查找两个数，使得它们的和正好是s。如果有多对数字的和等于s，则输出任意一对即可。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[2,7] 或者 [7,2]

示例 2：

输入：nums = [10,26,30,31,47,60], target = 40
输出：[10,30] 或者 [30,10]

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function(nums, target) {
    var i=0,j=nums.length-1;
    
    while(i!==j)
    {
        let sum=nums[i]+nums[j];
        if(sum<target) i++;
        if(sum>target) j--;
        if(sum==target) return [nums[i],nums[j]];
    }
};