js矩陣

螺旋矩陣：

 

 

export default(arr)=>{
  //處理每一圈的數據遍歷過程
  let map=(arr,r=[])=>{
    for(let i=0,len=arr.length;i<len;i++){
      if(i===0){
        r=r.concat(arr[i])
      }else if(i===len-1){
        r=r.concat(arr[i],reverse())
      }else{
        r.push(arr[i].pop())
      }
    }
    arr.shift()
    arr.pop()
    for(let i=arr.length-1;i>=0;i--){
       r.push(arr[i].shift())
    }
    if(arr.length){
      return map(arr,r)
    }else{
      return r
    }
  }
  return map(arr,[])
}

　　

旋轉圖像：

 

 

 

export default(arr)=>{
  // 獲取n的維度
  let vecor=arr.length
  //垂直反轉
  for(let i=0,len=vecor/2;i<len;i++){
    for(let j=0,tmp;j<vecor;j++){
       tmp=arr[i][j]
       arr[i][j]=arr[vecor-i-1][j]
       arr[vecor-i-1][j]=tmp
    }
  }
  //對角線翻轉
  for(let i=0;i<vecor;i++){
    for(let j=0,tmp;j<i;j++){
      tmp=arr[i][j]
      arr[i][j]=arr[j][i]
      arr[j][i]=tmp
    }
  }
  return arr
}

　　二叉樹：

對稱的二叉樹：

 

 

 

  //二叉樹的節點
  class Node{
    constructor(val){
      this.val=val
      this.left=this.right=undefined
    }
  }
  class Tree{
    constructor(data){
      //臨時存儲所有節點，方便尋找父子節點
      let nodeList=[]
      //頂節點
      let root
      for(let i=0,len=data.length;i<len;i++){
        let node=new Node(data[i])
        nodeList.push(node)
        if(i>0){  //第一層
          //計算當前節點屬於哪一層
          let n=Math.floor( Math.sqrt(i+1))
          //記錄當前層的起始點
          let q=Math.pow(2,n)-1
          //記錄上一層的起始點
          let p=Math.pow(2,n-1)-1
          //找到當前節點的父節點
          let parent=nodeList[p+Math.floor((i-q)/2)]
          //將當前節點和上一層的父節點做關聯
          if(parent.left){
            parent.right=node
          }else{
            parent.left=node
          }
        }
      }
      root=nodeList.shift()
      nodeList.length=0 
      return root
    }
    //判斷是不是對稱
    static isSymmetry(root){
      if(!root){
        return true
      }
      let walk=(left,right)=>{
        if(!left&&!right){
          return true
        }
        if((left&&!right)||(!left&&right)||(left.val!==right.val)){
          return false
        }
        return walk(left.left,right.right)&&walk(left.right,right.left)
      }
      return walk(root.left,root.right)
    }
  }

  export default Tree

  export{
    Node
  }

　　

class Node{
  constructor(val){
    this.val=val
    this.left=this.right=undefined
  }
}

class Tree{
  constructor(data){
    let root=new Node(data.shift())
    //遍歷所有的數據，逐漸插入到當前這顆搜索樹中
    data.array.forEach(item => {
      this.insert(root,item)
    });
    return root
  }
  insert(node,data){
    if(node.val>data){
      if(node.left===undefined){//判斷是不是左節點
        node.left=new Node(data)
      }else{
        this.insert(node.left,data)
      }
    }else{
      if(node.right===undefined){
        node.right=new Node(data)
      }else{
        this.insert(node.right,data)
      }
    }
  }

  static walk(root){
    if(!root.left&&!root.right){
      return true
    }else if((root.left&&root.val<root.left.val)||
    root.right&&root.val>root.right.val){
      return false
    }else{
      return Tree.walk(root.left)&&Tree.walk(root.right)
    }
  }
}

export default Tree
export{
  Node
}