每週一練 之 數據結構與算法（Tree）

時間  2019-11-20
標籤 每週 數據 結構 算法 tree 简体版
原文   原文鏈接

封面

這是第六週的練習題，最近加班比較多，上週主要完成一篇 GraphQL入門教程 ，有興趣的小夥伴能夠看下哈。前端

下面是以前分享的連接：node

歡迎關注個人 我的主頁 && 我的博客 && 我的知識庫 && 微信公衆號「前端自習課」git

本週練習內容：數據結構與算法 —— Treegithub

這些都是數據結構與算法，一部分方法是團隊其餘成員實現的，一部分我本身作的，有什麼其餘實現方法或錯誤，歡迎各位大佬指點，感謝。web

1、什麼是樹？

1.樹有什麼特色，什麼是二叉樹和二叉搜索樹（BST: Binary Search Tree）？
2.生活中常見的例子有哪些？算法

解析：微信

  1. 樹有什麼特色，什麼是二叉樹和二叉搜索樹：

  • 樹是一種非線性的數據結構，以分層方式存儲數據，用來表示有層級關係的數據。數據結構

  • 每棵樹至多隻有一個根結點，根結點會有不少子節點，每一個子節點只有一個父結點。架構

  • 父結點和子節點是相對的。svg

  1. 生活中的例子：
    如：家譜、公司組織架構圖。

2、請實現二叉搜索樹（BST），並實現如下方法：

  • insert(key)：向樹中插入一個新的鍵；
  • search(key)：樹中查找一個鍵，若是節點存在返回true，不存在返回false；
  • min()：返回樹中最小的值/鍵；
  • max()：返回樹中最大的值/鍵；
  • remove(key)：移除某個鍵；

提示：所謂的鍵對應於以前章節所學的節點（Node）

class Node {
    constructor(key){
        this.key = key
        this.left = null
        this.right = null
    }
}
class BST {
    constructor(){
        this.root = null
    }
    /** * 插入一個節點 * @param {*} node 插入的位置節點 * @param {*} newNode 插入的節點 */
    insertNode (node, newNode){
        if(newNode.key < node.key){
            if(node.left === null && node.right === null){
                node.left = newNode
            }else if(node.left !== null && node.right === null){
                node.right = newNode
            }else{
                this.insertNode(node.left, newNode)
            }
        }else{
            if(node.left === null && node.right === null){
                node.left = newNode
            }else if(node.left !== null && node.right === null){
                node.right = newNode
            }else{
                this.insertNode(node.right, newNode)
            }
        }
    }
    /** * 插入操做 * @param {*} key */
    insert (key){
        let newNode = new Node(key)
        if(this.root === null){
            this.root = newNode
        }else{
            this.insertNode(this.root, newNode)
        }
    }
    searchNode (node, key){
        if(node === null) return false
        if(key < node.key){
            return this.searchNode(node.left, key)
        }else if(key > node.key){
            return this.searchNode(node.right, key)
        }else{
            return true
        }
    }
    /** * 搜索操做 * @param {*} key */
    search (key){
        return this.searchNode(this.root, key)
    }
    /** * 最小值的節點 */
    min (){
        let node = this.root
        if(node === null) return null
        while(node && node.left !== null){
            node = node.left
        }
        return node.key
    }
    /** * 最大值的節點 */
    max (){
        let node = this.root
        if(node === null) return null
        while(node && node.right !== null){
            node = node.right
        }
        return node.key
    }
    /** * 找到最小節點 * @param {*} node */
    findMinNode (node){
        if(node === null) return null
        while(node && node.left !== null){
            node = node.left
        }   
        return node
    }
    /** * 刪除一個節點 * @param {*} node * @param {*} key */
    removeNode (node, key){
        if(node === null) return null
        if(key < node.key){
            node.left = this.removeNode(node.left, key)
            return node
        }else if(key > node.key){
            node.right = this.removeNode(node.right, key)
            return node
        }else{
            // 1.葉節點
            if(node.left === null && node.right === null){
                node = null
                return node
            }
            // 2.只有一個子節點
            if(node.left === null){
                node = node.right
                return node
            }else if(node.right === null){
                node = node.left
            }
            // 3.有兩個子節點
            let curNode = this.findMinNode(node.right)
            node.key = curNode.key
            node.right = this.removeNode(node.right, curNode.key)
            return node
        }
    }
    /** * 刪除一個節點 * @param {*} key */
    remove (key){
        if(this.root === null) return null
        this.root = this.removeNode(this.root, key)
    }
}

3、基於題二實現二叉搜索樹擴展如下方法：

  • preOrderTraverse()： 經過先序遍歷方式遍歷全部節點；
  • inOrderTraverse()： 經過中序遍歷方式遍歷全部節點；
  • postOrderTraverse()： 經過後序遍歷方式遍歷全部節點；

提示：

  • 先序：先訪問根節點，而後以一樣方式訪問左子樹和右子樹；（根==>左==>右）

輸出 =》 11 7 5 3 6 9 8 10 15 13 12 14 20 18 25
tree_pre

  • 中序：先訪問左子樹，再訪問根節點，最後訪問右字數；以升序訪問全部節點；（左==>根==>右）

輸出 =》 3 5 6 7 8 9 10 11 12 13 14 15 18 20 25

tree_in

  • 後序：先訪問葉子節點，從左子樹到右子樹，再到根節點。（左==>右==>根）

輸出 =》 3 6 5 8 10 9 7 12 14 13 18 25 20 15 11

tree_post

解析：

// 1. 先序
BST.prototype.preOrderTraverseNode = function(node, callback){
    if(node !== null){
        callback(node.key)
        this.preOrderTraverseNode(node.left, callback)
        this.preOrderTraverseNode(node.right, callback)
    }
}
BST.prototype.preOrderTraverse = function(callback){
    this.preOrderTraverseNode(this.root, callback)
}

// 2. 中序
BST.prototype.inOrderTraverseNode = function(node, callback){
    if(node !== null){
        this.inOrderTraverseNode(node.left, callback)
        callback(node.key)
        this.inOrderTraverseNode(node.right, callback)
    }
}
BST.prototype.inOrderTraverse = function(callback){
    this.inOrderTraverseNode(this.root, callback)
}

// 3. 後序
BST.prototype.postOrderTraverseNode = function(node, callback){
    if(node !== null){
        this.postOrderTraverseNode(node.left, callback)
        this.postOrderTraverseNode(node.right, callback)
        callback(node.key)
    }
}
BST.prototype.postOrderTraverse = function(callback){
    this.postOrderTraverseNode(this.root, callback)
}

4、請實現從上往下打印二叉樹

給定的二叉樹爲：[3, 9 , 20, null, null, 15, 7]

3
   / \
  9  20
     / \
    15  7

請實現一個 printLevelOrder 方法，輸出如下結果：

[
  [3],
  [9, 20],
  [15, 7]
]

來源：102.二叉樹的層次遍歷
解析：

  • 方法一：
BST.prototype.printLevelOrder = function (root, arr = [], i = 0){
    if (root && (root.key || root.key === 0)) {
      !arr[i] && (arr[i] = [])
      arr[i].push(root.key)
      i++
      root.left && this.printLevelOrder(root.left, arr, i)
      root.right && this.printLevelOrder(root.right, arr, i)
    }
    return arr
}
  • 方法二：
BST.prototype.printLevelOrder = function (){
    if(this.root === null) return []
    let result = [], queue = [this.root]
    while(true){
        let len = queue.length, arr = []
        while(len > 0){
            console.log(queue)
            let node = queue.shift()
            len -= 1
            arr.push(node.key)
            if(node.left !== null) queue.push(node.left)
            if(node.right !== null) queue.push(node.right)
        }
        if(arr.length === 0) return result
        result.push([...arr])
    }
}

5、給定一個二叉樹，判斷其是不是一個有效的二叉搜索樹。

假設一個二叉搜索樹具備以下特徵：

  • 節點的左子樹只包含小於當前節點的數。
  • 節點的右子樹只包含大於當前節點的數。
  • 全部左子樹和右子樹自身必須也是二叉搜索樹。

示例 1：

輸入:
    2
   / \
  1   3
輸出: true

示例 2：

輸入:
    5
   / \
  1   4
     / \
    3   6
輸出: false
解釋: 輸入爲: [5,1,4,null,null,3,6]。
根節點的值爲 5 ，可是其右子節點值爲 4 。

代碼實現：

/** * 二叉樹節點定義 */
function TreeNode(val) {
  this.val = val;
  this.left = this.right = null;
}

/** - @param {TreeNode} root - @return {boolean} */
function isValidBST(root) {};

來源：99.驗證二叉搜索樹
解析：

function isValidBST(root) {
    let arr = []
    function inOrderTraverse(node){
        if(node === null) return;
        node.left && inOrderTraverse(node.left);
        arr.push(node.val);
        node.right && inOrderTraverse(node.right);
    }
    inOrderTraverse(root)
    for(let i = 0; i < arr.length - 1; i++){
        if(arr[i] >= arr[i+1]) return false
    }
    return true
};
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程