javascript剑指offer编程练习#4

第二十二题

题目描述
从上往下打印出二叉树的每个节点，同层节点从左至右打印。

/* function TreeNode(x) {
    this.val = x;
    this.left = null;
    this.right = null;
} */
function PrintFromTopToBottom(root)
{
    // write code here
    if(!root){
        return []
    }
    let queue=[]
    queue.push(root)
    let result=[]
    while(queue.length){
        let node=queue.shift()
        result.push(node.val)
        if(node.left){
            queue.push(node.left)
        }
        if(node.right){
            queue.push(node.right)
        }
    }
    return result
}

二叉树的层次遍历，也就是BFS广度优先搜索，借助一个队列，储存二叉树。

第二十三题

题目描述
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

function VerifySquenceOfBST(sequence)
{
    // write code here
    if(!sequence.length){
        return false
    }
    return adjustSquence(sequence,0,sequence.length-1)
}
function adjustSquence(squence,start,end){
    if(start>end){
        return true
    }
    let i=start
    while(i<end&&squence[i]<squence[end]){
        i++
    }
    for(let j=i;j<end;j++){
        if(squence[j]<squence[end]){
            return false
        }
    }
    return adjustSquence(squence,start,i-1)&&adjustSquence(squence,i,end-1)
}

主要要搞清楚后序遍历结果是什么样子，result为后序遍历结尾，去除结尾最后一个元素为x，剩余数组可分为左右两部分，一部分全部小于x，另一部分全部大于x，例如[5,8,7,10,13,12,9]就是一个后序比那里结果。去除9后，[5,7,8]全部小于9，[10,13,12]全部大于9，利用BST二叉树搜索树算法进行递归

第二十四题

题目描述
输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)

/* function TreeNode(x) {
    this.val = x;
    this.left = null;
    this.right = null;
} */
function FindPath(root, expectNumber)
{
    // write code here
    let result=[]
    let stack=[]
    if(!root){
        return result
    }
    dfs(root,0)
    return result
    function dfs(root,sum){
        if(!root){
            return 
        }
        stack.push(root.val)
        sum+=root.val
        if(!root.left&&!root.right&&sum==expectNumber){
            result.push(stack.concat())//concat()的作用是做一个浅复制
        }
        if(root.left){
            dfs(root.left,sum)
        }
        if(root.right){
            dfs(root.right,sum)
        }
        stack.pop()
    }
}

DFS深度优先搜索

第二十五题

题目描述
输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）

/*function RandomListNode(x){
    this.label = x;
    this.next = null;
    this.random = null;
}*/
function Clone(pHead)
{
    // write code here
    if(!pHead){
        return null
    }
    var head=new RandomListNode(pHead.label)
    head.random=pHead.random
    head.next=Clone(pHead.next)
    return head
}	

第二十六题

题目描述
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。

/* function TreeNode(x) {
    this.val = x;
    this.left = null;
    this.right = null;
} */
function Convert(pRootOfTree)
    if(!pRootOfTree) {
        return null;
    }
    var lastNode = null;
    lastNode = ConvertNode(pRootOfTree);
    var head = lastNode;
    while(head && head.left) {
        head = head.left;
    }
    return head;

    function ConvertNode(node){
        if(!node){
            return;
        }
        if(node.left) {
            lastNode = ConvertNode(node.left);
        }
        node.left = lastNode;
        if(lastNode){
            lastNode.right = node;
        }
        lastNode = node;
        if(node.right){
            lastNode = ConvertNode(node.right);
        }
        return lastNode;
    }
}

第二十七题

题目描述
输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
输入描述:
输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。

function Permutation(str)
{
    // write code here
    if(!str||str.length===0){
        return []
    }
    let result=[]
    let temp=''
    let arr=str.split('')
    sort(arr)
    result=result.filter(function(item,index){
        return result.indexOf(item)===index
    })
    function sort(arr){
        if(arr.length===0){
            result.push(temp)
            return 
        }
        for(let i=0;i<arr.length;i++){
            temp+=arr[i]
            copyArr=arr.concat()
            copyArr.splice(i,1)
            sort(copyArr)
            temp = temp.substring(0,temp.length-1)//回溯
        }
    }
    return result
    
}

利用回溯法进行暴力搜索，遍历出所有结果

第二十八题

题目描述
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。

function MoreThanHalfNum_Solution(numbers)
{
    // write code here
    if(!numbers||numbers.length===0){
        return 0
    }
    let arr=[]
    let len=numbers.length
    numbers.forEach((item,index)=>{
        arr[item]!==undefined?arr[item]++:arr[item]=1
    })

  for(var i = 0; i < arr.length; i++){
        if(arr[i] > len/2){
            return i;
        }
    }
    return 0

新建一个数组，数组的每项的key为元素值，value为元素个数

第二十九题

题目描述
输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。

function GetLeastNumbers_Solution(input, k)
{
    // write code here
    if(!input||input.length===0||k>input.length){
        return []
    }
    return input.sort((a,b)=>{
        return a-b
   }).slice(0,k)
}

第三十题

题目描述
HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)

function FindGreatestSumOfSubArray(array)
{
    // write code here
    if(!array||array.length===0){
        return 0
    }
    let max=array[0]
    let result=array[0]
    for(let i=1;i<array.length;i++){
        max=Math.max(max+array[i],array[i])
        result=Math.max(max,result)
    }
    return result
    
}

利用动态规划法拆分成子问题：
F(i):以array[i]为末尾元素的子元素和的最大值
F（i）=max（F（i-1）+array[i] ， array[i]）
res：所有子数组的和的最大值
res=max（res，F（i））