js-剑指offer（1-6）

参考：https://www.cnblogs.com/wuguanglin/p/code-interview.html

1、在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

1、二维数组表示
var array=[[1,2,3],[4,5,6],[7,8,9]]
array.length=2
array[0].length=3

数组排列顺序
1 2 3
4 5 6
7 8 9

2、解法
2.1 遍历
 function Find(target, array) {
     for (var i = 0; i < array.length; i++) {
         for (var j = 0; j < array[i].length; j++) {
            if (array[i][j] == target) {
                return true;
             }
         } 
     }
        return false;
 }
2.2 找最右上角的数字和target比较，如果大于target，
抛弃这一列，col--；如果小于target，抛弃这一行，row++
    
 function Find(target, array) {
    var row =0;//从右上角的a[0][a[0].length-1]进行查找
    var col=array[0].length-1;
    while(row<array.length&&col>=0){//row不大于数组长度，col不小于0
        if(array[row][col]==target){
            return true;
        } 
        if(array[row][col]>target){//如果当前数值大于目标值，就去左列查找
            col--;
        }
       if(array[row][col]<target){//如果当前数值小于目标值，就去下行查找
            row++;
        }
    }
    return false;
}

2、请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

1、  使用正则表达式以及replace()
  /xxxx/两个斜杠表示这个是正则表达式
  后面的g表示匹配全部(即替换全部)，
  \s表示匹配空白字符(空格等什么的)
  
  function replaceSpace(str)
  {
    // write code here
    return str.replace(/\s/g,'%20')
  }

2、 function replaceSpace(str)
  {
    // write code here
    return str.split(' ').join('%20')
  }

3、输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。

unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度。

/*function ListNode(x){
    this.val = x;
    this.next = null;
}*/
 function printListFromTailToHead(head) {
        // write code here
        var ArrayList = [];//创建一个ArrayList之后并将其返回
        var p = head;//创建p指针
        while (p) {//p指针不为空
            ArrayList.unshift(p.val)//将p指针所指向的值通过unshift()存储到数组的第一项
            p = p.next//遍历链表
          }
        return ArrayList;
    }

4、输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

/* function TreeNode(x) {
    this.val = x;
    this.left = null;
    this.right = null;
} */
//先序遍历的第一个节点为根节点（先根再左最后右）
//中序遍历先左中根后右（以根节点为分界线）
//所以中序序列中根节点前的节点都是根节点左边的节点
//中序序列中根节点后面的节点都是根节点右边的节点
//根节点前的数都是左孩子，根节点右边的数都是右孩子
function reConstructBinaryTree(pre,vin){
if (pre.length === 0 || vin.length === 0) {
    return null;
  }
    var index=vin.indexOf(pre[0]);//indexof()获取到中序序列根节点所在位置
    var left=vin.slice(0,index);//创建左孩子为中序序列中根节点左边的数：从第1位到根节点都是左孩子
    var right=vin.slice(index+1);//创建右孩子为中序序列中根节点右边的数：根节点以后的数都是右孩子
    return {
        val:pre[0],//根节点
        //调用reConstructBinaryTree对左孩子再分割直到重建成功
        //左孩子的前序序列从原先的前序序列的从第2位开始到左孩子个数的序列
        //左孩子的中序遍历为从原先中序序列根节点左边的数
        left:reConstructBinaryTree(pre.slice(1,index+1), left),
        //调用reConstructBinaryTree给右孩子再分割知道重建成功
        //右孩子的前序序列从原先的前序序列的除去左孩子个数后开始的序列
        //右孩子的中序遍历为从原先中序序列根节点右边的数
        right:reConstructBinaryTree(pre.slice(index+1), right)
    }
}

5、用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。

//先创建两个栈
//stack1用来push逆序
//stack2用来pop，先将stack1内的值压入stack2实现顺序的先进先出
//要想在Stack2内压入stack1内的值必须确保stack2为空
var stack1=[];
var stack2=[];
function push(node){
    stack1.push(node);//向stack1中放node
}
function pop(){
    if(!stack2.length){//srtack2本来为空时压入stack1里出栈的值
        while(stack1.length){//并且将stack1内所有的值压入stack2内
        stack2.push(stack1.pop());//实现先进先出  
      } 
       return  stack2.pop(); //执行一次pop()操作弹出stack2中最上方的值
    }
    else{//如果stack2中的值还没有排空，直接弹出stack2最上方的值
       return  stack2.pop();
    }
//【1，2，3，pop,pop,4】此种情况下执行两次pop后还有3在stack2
}

6、把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

1、直接返回最小值
function minNumberInRotateArray(rotateArray)
{
    // write code here
    if(rotateArray.length==0){return -1}
    return Math.min.apply(null,rotateArray)
}

2、二分法
function minNumberInRotateArray(rotateArray)
{
    // write code here
        // write code here
    var left=0;
    var right=rotateArray.length-1;
    while(left<right){
        var c=(left+right)/2;
        var mid=Math.floor(c);//获取中间值并且每次都和最右值进行比较
        if(rotateArray[mid]>rotateArray[right]){//中间值大于最右值,最小值在右半区间
            left=mid+1;
        }
        else if(rotateArray[mid]==rotateArray[right]){//中间值和最右值相等，最右值向左移移一位
            right-=1;
        }else{//中间值小于最右值，最小值在左半区间包括中间值
            right=mid;
        }
    } 
    return rotateArray[left]
}