JavaScript-二叉樹的前中後排序以及刪除

阿新 • • 發佈：2019-01-06

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body 
>
    <script>
        function BinaryTree(){
            var Node = function(key){
                this.key = key;
                this.left =null;
                this.right=null;
                }
            var root = null;

            var insertNode = function(node, newNode){
                if 
(newNode.key <node.key){
                    if(node.left === null){
                        node.left=newNode;
                    }else{
                        insertNode(node.left, newNode);
                    }
                }else{
                    if(node.right===null){
                    node.right = newNode;
                    }
                    else 
{
                        insertNode(node.right, newNode);
                     }
                }
            }

            this.insert = function(key){
                var newNode = new Node(key);
            if(root === null){
                root = newNode;
            }else{
                insertNode(root,newNode);
                }
            };
            //中序遍歷
            var inOrderTaverseNode = function(node, callback){
                if(node!==null){
                    inOrderTaverseNode(node.left, callback);
                    callback(node.key);
                    inOrderTaverseNode(node.right,callback);
                }
            }

            this.insOrderTraverse = function(callback){
                inOrderTaverseNode(root, callback)
            }

            //前序遍歷
            var preOrderTraverseNode = function(node, callback){
                if(node !== null){
                    callback(node.key)
                    preOrderTraverseNode(node.left, callback);
                    preOrderTraverseNode(node.right, callback);
                }
            }
            this.preOrderTraverse = function(callback){
                preOrderTraverseNode(root, callback);
            }
            //後序遍歷 
           var postOrderTraverseNode = function(node, callback)
           {
               if(node !== null){
                   postOrderTraverseNode(node.left, callback);
                   postOrderTraverseNode(node.right, callback);
                   callback(node.key);
               }

           }     
           this.postOrderTraverse = function(callback){
               postOrderTraverseNode(root, callback);
           } 
           //查詢最小值
           var minNode = function(node){
               if(node){
                   while(node&&node.left !== null){
                       node = node.left;
                   }
                   return node.key;
               }
               return null;
           }
           this.min = function(){
               return minNode(root);
           }
           //查詢最大值
           var maxNode = function(node){
               if(node){
                   while(node && node.right !== null){
                       node = node.right;
                   }
                   return node.key;
               }
               return null;
           }

           this.max = function(){
               return maxNode(root);
           }

           //查詢指定值
           var searchNode = function(node, key){
               if(node === null){
                   return false;
               }
               if(key < node.key){
                   return searchNode(node.left, key);
               }else if(key>node.key){
                   return searchNode(node.right, key);
               }else{
                   return true;
               }
           }
           this.search =function(key){
               return searchNode(root, key);
           }
        var findMinNode =function(node){
            if(node){
                while(node && node.left !== null){
                    node = node.left;
                }
                return node;
            }
            return null;
        }

           var removeNode = function(node, key){
               if(node === null){
                   return null;
               }
               if(key < node.key){
                   node.left = removeNode(node.left, key);
                   return node;
               }else if(key > node.key){
                   node.right = removeNode(node.right, key);
                   return node;
               }else{
                   if(node.left === null && node.right === null){
                       node = null;
                       return node;
                   }
                   if(node.left === null){
                       node = node.right;
                       return node;
                   }else if(node.right === null){
                       node = node.left;
                       return node;

                   }
                   var aux = findMinNode(node.right);
                   node.key = aux.key;
                   node.right = removeNode(node.right, aux.key);
                   return node;
               }
           }
           this.remove = function(key){
               root = removeNode(root, key);
           }
        }
        var nodes = [8, 3, 10, 1, 6, 4, 7, 13];
        var binaryTree = new BinaryTree();
        nodes.forEach(function(key){
            binaryTree.insert(key);
        });

        var callback = function(key){
            console.log(key);
        }
        console.log("min node is:"+binaryTree.min());
        console.log("max node is:"+binaryTree.max());
        binaryTree.postOrderTraverse(callback);   //前中後序遍歷

        console.log(binaryTree.search(7)?'key 7 is found':'key 7 is not found');
        console.log(binaryTree.search(5)?'key 5 is found':'key 5 is not found');


        binaryTree.remove(3);
    </script>
</body>
</html>

JavaScript-二叉樹的前中後排序以及刪除

<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-widt

二叉樹先中後序遍歷的C++程式碼

馬上就要資料結構考試了，會考到二叉樹的遍歷演算法設計題，然後就自己總結了一個關於二叉樹的簡單演算法程式碼。 #include <iostream> #include <stdio.h> #include <stdlib.h> #inclu

二叉樹先中後序遍歷（遞迴、非遞迴方法）、層序遍歷 Java實現

第一部分：二叉樹結點的定義二叉樹結點有三個屬性：資料域、左結點、右結點。構造方法寫三個引數，這樣建立結點的時候程式碼更簡潔，且要從葉子結點開始建立（從底往上建立）。注：如果只寫一個賦值引數的構造器，那麼建立節點的順序就無所謂了，但是建立二叉樹時要多寫幾行程式碼。 pack

二叉樹---前中序陣列建立唯一二叉樹

二叉樹的個數具有n個結點的不同的二叉樹有多少種？這與用棧得出的從1到n的數字有多少種不同的排列具有相同的結論。那麼，利用給定了一顆二叉樹的前序序列（ABHFDECKG）和中序序列（HBDFA

js二叉樹,前序/中序/後序(最大最小值，排序)

data nod can ole right unshift func pro node function Node(data,left,right) { this.left=left this.right=right

POJ2255-已知二叉樹前序中序求後序

nbsp def 二叉樹水題輸出 ostream -i sin root 水題……也可以不建立二叉樹來做如果pre[pl:pr]對應in[il:ir]，那麽pre[pl]是這棵樹的根，它在in的位置記為root，顯然root在[il,ir]內那麽二叉樹的左子樹是in

二叉樹前序、中序遍歷得到後序遍歷

() level struct OS spa str sel src [] 二叉樹的前序遍歷為:{1,2,4,7,3,5,6,8}，中序遍歷為:{4,7,2,1,5,3,8,6}，求後序遍歷　 # -*- coding:utf-8 -*- class Nod

數據結構35：二叉樹前序遍歷、中序遍歷和後序遍歷

tdi 代碼 nod 完成循環同時 reat pan 設置遞歸算法底層的實現使用的是棧存儲結構，所以可以直接使用棧寫出相應的非遞歸算法。先序遍歷的非遞歸算法從樹的根結點出發，遍歷左孩子的同時，先將每個結點的右孩子壓棧。當遇到結點沒有左孩子的時候，取棧頂的右

golang二叉樹前序，中序，後序非遞歸遍歷算法

rec == int post order nta rev UC right package main import ( "container/list" "fmt" ) // Binary Tree type Bin

二叉樹前序、中序、後序（遞迴 / 非遞迴）遍歷

前語二叉樹的遍歷是指按一定次序訪問二叉樹中的每一個結點，且每個節點僅被訪問一次。前序遍歷若二叉樹非空，則進行以下次序的遍歷：根節點—>根節點的左子樹—>根節點的右子樹若要遍歷左子樹和右子樹，仍然需要按照以上次序進行，所以前序遍歷也是一個遞

【演算法】二叉樹前序、中序、後序遍歷相互求法（轉）

二叉樹前序、中序、後序遍歷相互求法原文地址今天來總結下二叉樹前序、中序、後序遍歷相互求法，即如果知道兩個的遍歷，如何求第三種遍歷方法，比較笨的方法是畫出來二叉樹，然後根據各種遍歷不同的特性來求，也可以程式設計求出，下面我們分別說明。

JavaScript中利用二叉樹對陣列進行排序

二叉樹和二叉搜尋樹二叉樹中的節點最多隻能有兩個子節點：一個是左側子節點，另一個是右側子節點。二叉搜尋樹(BST)是二叉樹中的一種，但是它只允許在左側節點儲存比父節點小的值，在右側幾點儲存比節點大(或相等)的值。可以利用BST的這種特性，對陣列進行排序： class Node{

二叉樹前序中序後序遞迴非遞迴解法

遞迴解法很簡單，構建一個輔助函式helper，改變一下其中的兩行程式碼的順序便可實現前序中序後序遍歷，程式碼如下：前序遍歷（遞迴） vector<int> preorderTraversal(TreeNode* root) { vector<in

水平遍歷二叉樹程式碼中包含前序、中序、後序和水平遍歷四種

水平遍歷二叉樹要求一層一層從上往下從左往右遍歷，例如：上面二叉樹的遍歷順序為：2、4、5、1、3 思路：利用佇列先進先出的性質 1、將根節點放入佇列 2、while迴圈佇列，只要佇列不為空，就取出第一個節點。獲取資料 3、將第二步取出的節點的左子節點和右子節點

已知中序、後序構造二叉樹（關鍵詞：二叉樹/前序/先序/中序/後序/先根/中根/後根/遍歷/搜尋/查詢）

已知中序、後序構造二叉樹遞迴演算法 def buildTree(inorder, postorder): if inorder and postorder: postRootVal = postorder

已知前序、中序構造二叉樹（關鍵詞：二叉樹/前序/先序/中序/後序/先根/中根/後根/遍歷/搜尋/查詢）

已知前序、中序構造二叉樹實現 def buildTree(self, preorder, inorder): if inorder: rootVal = preorder.pop(0) rootIdx = inorder.index(rootVal) root

二叉樹——前、中、後序遍歷遞迴以及非遞迴寫法

#include <iostream> #include <stack> #include <queue> using namespace std; typedef struct Node{ int data; Node *l

二叉樹，中序遍歷+後序遍歷輸出前序遍歷

引用： https://blog.csdn.net/m0_37698652/article/details/79218014 #include <iostream> #include <string> using namespace std; struct Tree

二叉樹已知前序中序兩個序列，建立二叉樹（中序和後序也有）

本文主要講二叉樹的建樹，具體的說就是，題目給出你二叉樹的前序和中序，你來建樹，還有一個題目是給出中序和後序來建樹第一題：A binary tree is a finite set of vertices that is either empty or consists

資料結構--樹--線索二叉樹（中序，前序，後序）

線索二叉樹在遍歷二叉樹的時候，會有許多空指標域，這些空間不儲存任何事物，白白浪費了記憶體的資源。那麼在做遍歷的時候，提前記錄下每個結點的前驅和後繼，這樣就更加節約了時間。 [ lchild ] [ LTag ] [ data ] [ R

JavaScript-二叉樹的前中後排序以及刪除

相關推薦