coding 1

1、输入一个链表 链表按从尾到头的顺序返回一个ArrayList。
shift()把数组的第一个元素从中删除 并返回这个元素的值
unshift()向数组的开头添加一个或多个元素返回新的长度

function printListFromTailToHead(head) {
    var arr = []
    while (head) {
        arr.unshift(head.val);//unshift 在数组的开头添加元素
        head = head.next;
    }
    return arr;
}
console.log(printListFromTailToHead({ 'val': 1, 'next': { 'val': 2, 'next': null }}));  //[2,1]

2、用两个栈来实现一个对列 完成队列的 pop和push操作。
pop push 元素的入队出队
①入队push 把元素放入栈1
②出队pop 判断栈2是否为空 如果为空 就将栈1中的元素进栈2 栈2再出栈
JavaScript中：pop()方法用于删除并返回最后一个元素
push()方法可向数组的末尾添加一个或多个元素 并返回新的长度。

var stack1=[];
var stack2=[];
function push(node) //添加元素
{
    stack1.push(node);
    return stack1;
}
function pop() //弹出元素
{
    if (stack2.length===0 && stack1.length===0){
        return false;
    }else if(stack2.length===0){
        while (stack1.length!==0){
            stack2.push(stack1.pop()); 
        }
    }
    return stack2.pop();
}
console.log(push([1,2,3])); //[Array(3)];
console.log(pop());  //[1,2,3]

3、斐波那契数列
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项

function Fibonacci(n)
{
    if(n==0){
        return 0;
    }
    if(n==1){
        return 1;
    }
    var fibo=[0,1];
    for(var i=2;i<=n;i++){
       fibo.push(fibo[i-1]+fibo[i-2]);
    }
    return fibo.pop();
}

function fibo(number){
    var fibo=[];
    fibo[1]=1;
    fibo[2]=2;
    for(var i=3;i<number;i++){
        fibo[i]=fibo[i-1]+fibo[i-2];
    }
    for(var i=1;i<fibo.length;i++){
        console.log(fibo[i]); //输出每一项
    }
    console.log(fibo[number-1]); //输出最后一项
}
fibo(10);

4、一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
跳0阶台阶时有0种跳法
跳1阶台阶时有1种跳法
跳2阶台阶时有2种跳法
跳3阶台阶时有3种跳法
跳4阶台阶时有5种跳法
这是一个斐波那契数列

function jumpFloor(number)
{
    var a=1;
    var b=2;
    var c=0;
    if(number==0){return 0;}
    if(number==1){return 1;}
    if(number==2){return 2;}
    for(var i=3;i<=number;i++){
        c=a+b;
        a=b;
        b=c;
    }
    return c;
}

5、一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
跳0阶台阶时 0种方法
跳1阶台阶时 1种方法
跳2阶台阶时 2种方法 1+1 、2
跳3阶台阶时 4种方法1+1+1、2+1、1+2、3
跳4阶台阶时 8种方法1*4、2+2、2+1+1、1+2+1、1+1+2、3+1、1+3、4
也就是 第n阶台阶的跳法等于钱一阶台阶跳法的2倍(除了跳0阶的情况)

function jumpFloorII(number) {
    if (number === 0) { return 0; }
    if (number === 1) { return 1; }
    if (number >= 2) {
        return Math.pow(2, number - 1);
    }
}
console.log(jumpFloorII(5));

6、输入一个链表 输出该链表的倒数第k个节点

function FindKthToTail(head, k)
{
    if(head==null){return false;}
    var count=0;
    var arr=[];
    while(head){
        count++;
        arr.push(head);
        head=head.next;
    }
    if(k>arr.length){
        return false;
    }else{
        return arr[arr.length-k];
    }
}

7、镜像二叉树
交换左右节点的位置

function Mirror(root)
{
    if(root==null){return false;}else{
        var temp=root.right;
        root.right=root.left;
        root.left=temp;
    //我们规定每个子树的root都跟第一个root处理方式一样
        Mirror(root.left);
        Mirror(root.right);
    }
}

8、输入一个矩阵 按照从外向里以顺时针的顺序依次打印出每一个数字
定义一个矩阵

var rows=matrix.length; //行
var cols=matrix[0].length; //列
//矩阵输入样例 matrix([[1,2,3],[1,2,4],[1,2,3],[1,2,3]])

9、定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
apply call bind 第一个参数都是this的指向对象 即你需要对象的一个方位
apply之后的参数用逗号分隔
apply之后的参数用数组保存
bind之后的参数也是用逗号分隔但是bind返回一个函数bind()();

var stack=[];
function push(node)
{
    return stack.push(node);
}
function pop()
{
    return stack.pop();
}
function top()
{
    return arr[arr.length-1]
}
function min()
{
    return Math.min.apply(push,stack);
}

10、
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）


判断popV的第一个值是不是等于stack栈进栈过程中的一个值 如果相等 就开始判断 popV的第二个值是不是等于stack栈中栈顶元素的下一个值或者是未入栈的值

function IsPopOrder(pushV, popV)
{
var stack=[];
    var j=0;
    for(var i=0;i<pushV.length;i++){
        stack.push(pushV[i]);
           while(j<popV.length&&stack[stack.length-1]==popV[j]){
            j++;
            stack.pop();
        }
    }
    if(stack.length==0){
        return true;
    }else{
        return false;
    }
}

11、求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。
递归计算

function Sum_Solution(n)
{
     if(n==1){
        return 1;
    }else{
        n+=Sum_Solution(n-1);
        return n;
    }
}

13、在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5。

function deleteDuplication(pHead)
{
    if(pHead == null || pHead.next == null){
        return pHead; //只有0个或1个结点，则返回
    }
    if(pHead.val == pHead.next.val)
    //如果当前节点是重复节点
    {
        var pNode = pHead.next;
        while(pNode!=null && pNode.val==pHead.val){
//跳过与当前节点相同的全部节点 找到第一个与当前节点不同的节点
            pNode = pNode.next;
        }
        //从第一个与当前节点不同的节点开始递归
        return deleteDuplication(pNode);
    }else{//当前节点不是重复节点从下一个节点开始递归
        pHead.next = deleteDuplication(pHead.next);
        return pHead;
    }
}