数据结构示例-将二叉树转换为二叉搜索树

📌 相关文章

📜 数据结构示例-将二叉树转换为二叉搜索树

📅 最后修改于: 2020-10-15 06:25:43 🧑 作者: Mango

问：将二进制树转换为二进制搜索树的程序。

说明

在此程序中，我们需要将给定的二叉树转换为相应的二叉树。如果每个节点最多有两个子代，则将一棵树称为二叉树。而二叉搜索树是二叉树的一种特殊情况，其中根节点左侧的所有节点都应小于根节点，而右侧节点则应大于根节点。

通过将给定的二叉树转换为其相应的数组表示形式，可以解决此问题。对数组进行排序。根据数组元素计算中间节点，因为它将成为相应的二进制搜索树的根节点。

算法

定义具有三个属性的Node类，即：左和右数据。在此，左代表节点的左子节点，右代表节点的右子节点。
创建节点时，数据将传递到该节点的data属性，并且左右都将设置为null。
定义另一个具有两个属性root和treeArray的类。
1. 根表示树的根节点，并将其初始化为null。
2. treeArray将存储二叉树的数组表示形式。
convertBTBST()会将二进制树转换为相应的二进制搜索树：
1. 它将通过调用convertBTtoArray()将二叉树转换为相应的数组。
2. 将步骤1中的结果数组升序排序。
3. 通过调用createBST()将数组转换为二进制搜索树。
computeSize()将计算树中存在的节点数。
convertBTtoArray()将通过遍历二叉树并将元素添加到treeArray来将二叉树转换为其数组表示形式。
createBST()将通过选择排序的treeArray的中间节点作为其根节点来创建相应的二进制搜索树。 treeArray将分为两部分，即[0，mid-1]和[mid + 1，end]。从每个数组中递归地找到中间节点，分别创建左子树和右子树。
Inorder()将以有序的方式显示树的节点，即左子节点，后跟根节点，右子节点。

示例：

Python

#Represent a node of binary tree
class Node:
    def __init__(self,data):
        #Assign data to the new node, set left and right children to None
        self.data = data;
        self.left = None;
        self.right = None;
 
class ConvertBTtoBST:
    def __init__(self):
        #Represent the root of binary tree
        self.root = None;
        self.treeArray = [];
        
    #convertBTBST() will convert a binary tree to the binary search tree
    def convertBTBST(self, node):
        
        #Converts binary tree to array
        self.convertBTtoArray(node);
        
        #Sort treeArray
        self.treeArray.sort();
        
        #Converts array to binary search tree
        d = self.createBST(0, len(self.treeArray) -1);
        return d;
        
    #convertBTtoArray() will convert the given binary tree to its corresponding array representation
    def convertBTtoArray(self, node):
        
        #Check whether tree is empty
        if(self.root == None):
            print("Tree is empty\n");
            return;
        else:
            if(node.left!= None):
                self.convertBTtoArray(node.left);
            #Adds nodes of binary tree to treeArray
            self.treeArray.append(node.data); 
 
            if(node.right!= None):
                self.convertBTtoArray(node.right);
                
    #createBST() will convert array to binary search tree
    def createBST(self, start, end):
        
        #It will avoid overflow
        if(start > end):
            return None;
            
        #Variable will store middle element of array and make it root of binary search tree
        mid = (start + end) // 2;
        node = Node(self.treeArray[mid]);
        
        #Construct left subtree
        node.left = self.createBST(start, mid - 1);
        
        #Construct right subtree
        node.right = self.createBST(mid + 1, end);
        
        return node;
        
    #inorder() will perform inorder traversal on binary search tree
    def inorderTraversal(self, node):
        
        #Check whether tree is empty
        if(self.root == None):
            print("Tree is empty\n");
            return;
        else:
            if(node.left != None):
                self.inorderTraversal(node.left);
            print(node.data),
            if(node.right!= None):
                self.inorderTraversal(node.right);
                
bt = ConvertBTtoBST();
#Add nodes to the binary tree
bt.root = Node(1);
bt.root.left = Node(2);
bt.root.right = Node(3);
bt.root.left.left = Node(4);
bt.root.left.right = Node(5);
bt.root.right.left = Node(6);
bt.root.right.right = Node(7);
 
#Display given binary tree
print("Inorder representation of binary tree: ");
bt.inorderTraversal(bt.root);
 
#Converts binary tree to corresponding binary search tree
bst = bt.convertBTBST(bt.root);
 
#Display corresponding binary search tree
print("\nInorder representation of resulting binary search tree: ");
bt.inorderTraversal(bst);

输出：

Inorder representation of binary tree: 
4 2 5 1 6 3 7 
Inorder representation of resulting binary search tree: 
1 2 3 4 5 6 7

C

#include 
#include 
 
//Represent a node of binary tree
struct node{
    int data;
    struct node *left;
    struct node *right;
};
 
//Represent the root of binary tree
struct node *root = NULL;
 
int treeArray[100];
int ind = 0;
    
//createNode() will create a new node
struct node* createNode(int data){
    //Create a new node
    struct node *newNode = (struct node*)malloc(sizeof(struct node));
    //Assign data to newNode, set left and right children to NULL
    newNode->data= data;
    newNode->left = NULL;
    newNode->right = NULL;
    
    return newNode;
}
 
//calculateSize() will calculate size of tree
int calculateSize(struct node *node)
{    
    int size = 0;
    if (node == NULL)
     return 0;
    else {
        size = calculateSize (node->left) + calculateSize (node->right) + 1;
        return size;
    }
}
 
//convertBTtoArray() will convert the given binary tree to its corresponding array representation
void convertBTtoArray(struct node *node) {
    //Check whether tree is empty
    if(root == NULL){
        printf("Tree is empty\n");
        return;
    }
    else {
        if(node->left != NULL)
            convertBTtoArray(node->left);
        //Adds nodes of binary tree to treeArray
        treeArray[ind] = node->data; 
        ind++;
        if(node->right!= NULL)
            convertBTtoArray(node->right);  
        }      
}
 
//createBST() will convert array to binary search tree
struct node* createBST(int start, int end) {
    
    //It will avoid overflow
    if (start > end) {
        return NULL;
    }
    
    //Variable will store middle element of array and make it root of binary search tree
    int mid = (start + end) / 2;
    struct node *temp = createNode(treeArray[mid]);
 
    //Construct left subtree
    temp->left = createBST(start, mid - 1);
 
    //Construct right subtree
    temp->right = createBST(mid + 1, end);
 
    return temp;
}
 
//convertBTBST() will convert a binary tree to binary search tree
struct node* convertBTBST(struct node *node) {
    
    //Variable treeSize will hold size of tree
    int treeSize = calculateSize(node);
    
    //Converts binary tree to array
    convertBTtoArray(node);
    
    //Sort treeArray
    int compare (const void * a, const void * b) {
        return ( *(int*)a - *(int*)b );
    }
    qsort(treeArray, treeSize, sizeof(int), compare);
    
    //Converts array to binary search tree
    struct node *d = createBST(0, treeSize - 1);
    return d;
}
 
//inorder() will perform inorder traversal on binary search tree
void inorderTraversal(struct node *node) {
    
    //Check whether tree is empty
    if(root == NULL){
        printf("Tree is empty\n");
        return;
       }
    else {
        
        if(node->left!= NULL)
            inorderTraversal(node->left);
        printf("%d ", node->data);
        if(node->right!= NULL)
            inorderTraversal(node->right);
    }      
}
      
int main()
{
    //Add nodes to the binary tree
    root = createNode(1);
    root->left = createNode(2);
    root->right = createNode(3);
    root->left->left = createNode(4);
    root->left->right = createNode(5);
    root->right->left = createNode(6);
    root->right->right = createNode(7);
    
    //Display given binary tree
    printf("Inorder representation of binary tree: \n");
    inorderTraversal(root);
    
    //Converts binary tree to corresponding binary search tree
    struct node *bst = convertBTBST(root);
    
    //Display corresponding binary search tree
    printf("\nInorder representation of resulting binary search tree: \n");
    inorderTraversal(bst);
 
    return 0;
}

输出：

Inorder representation of binary tree: 
4 2 5 1 6 3 7 
Inorder representation of resulting binary search tree: 
1 2 3 4 5 6 7

JAVA

import java.util.Arrays;
 
public class ConvertBTtoBST {
    
    //Represent a node of binary tree
    public static class Node{
        int data;
        Node left;
        Node right;
            
        public Node(int data){
            //Assign data to the new node, set left and right children to null
            this.data = data;
            this.left = null;
            this.right = null;
            }
        }
    
    //Represent the root of binary tree
    public Node root;
    
    int[] treeArray;
    int index = 0;
    
    public ConvertBTtoBST(){
        root = null;
    }
    
    //convertBTBST() will convert a binary tree to binary search tree
    public Node convertBTBST(Node node) {
        
        //Variable treeSize will hold size of tree
        int treeSize = calculateSize(node);
        treeArray = new int[treeSize];
        
        //Converts binary tree to array
        convertBTtoArray(node);
        
          //Sort treeArray
        Arrays.sort(treeArray);
      
        //Converts array to binary search tree
        Node d = createBST(0, treeArray.length -1);
        return d;
    }
    
    //calculateSize() will calculate size of tree
    public int calculateSize(Node node)
    {    
        int size = 0;
        if (node == null)
         return 0;
        else {
            size = calculateSize (node.left) + calculateSize (node.right) + 1;
            return size;
        }
    }
    
    //convertBTtoArray() will convert the given binary tree to its corresponding array representation
    public void convertBTtoArray(Node node) {
        //Check whether tree is empty
        if(root == null){
            System.out.println("Tree is empty");
            return;
        }
        else {
            if(node.left != null)
                convertBTtoArray(node.left);
            //Adds nodes of binary tree to treeArray
            treeArray[index] = node.data; 
            index++;
            if(node.right != null)
                convertBTtoArray(node.right);  
            }      
        }
    
    //createBST() will convert array to binary search tree
    public Node createBST(int start, int end) {
        
        //It will avoid overflow
        if (start > end) {
            return null;
        }
        
        //Variable will store middle element of array and make it root of binary search tree
        int mid = (start + end) / 2;
        Node node = new Node(treeArray[mid]);
 
        //Construct left subtree
        node.left = createBST(start, mid - 1);
 
        //Construct right subtree
        node.right = createBST(mid + 1, end);
 
        return node;
    }
    
    //inorder() will perform inorder traversal on binary search tree
    public void inorderTraversal(Node node) {
        
        //Check whether tree is empty
        if(root == null){
            System.out.println("Tree is empty");
            return;
           }
        else {
            
            if(node.left!= null)
                inorderTraversal(node.left);
            System.out.print(node.data + " ");
            if(node.right!= null)
                inorderTraversal(node.right);
              
          }      
      }
    
    public static void main(String[] args) {
        
        ConvertBTtoBST bt = new ConvertBTtoBST();
        //Add nodes to the binary tree
        bt.root = new Node(1);
        bt.root.left = new Node(2);
        bt.root.right = new Node(3);
        bt.root.left.left = new Node(4);
        bt.root.left.right = new Node(5);
        bt.root.right.left = new Node(6);
        bt.root.right.right = new Node(7);
        
        //Display given binary tree
        System.out.println("Inorder representation of binary tree: ");
        bt.inorderTraversal(bt.root);
        
        //Converts binary tree to corresponding binary search tree
        Node bst = bt.convertBTBST(bt.root);
        
        //Display corresponding binary search tree
        System.out.println("\nInorder representation of resulting binary search tree: ");
        bt.inorderTraversal(bst);
      }
}

输出：

Inorder representation of binary tree: 
4 2 5 1 6 3 7 
Inorder representation of resulting binary search tree: 
1 2 3 4 5 6 7

C＃

using System;
namespace Tree 
{                     
    public class Program
    {
        //Represent a node of binary tree
        public class Node{
            public T data;
            public Node left;
            public Node right;
            
            public Node(T data) {
                //Assign data to the new node, set left and right children to null
                this.data = data;
                this.left = null;
                this.right = null;
            }
        }
        
        public class ConvertBTtoBST{
            //Represent the root of binary tree
            public Node root;
            
            T[] treeArray;
            int index = 0;
            
            public ConvertBTtoBST(){
                root = null;
            }
        
            //convertBTBST() will convert a binary tree to binary search tree
            public Node convertBTBST(Node node) {
 
                //Variable treeSize will hold size of tree
                int treeSize = calculateSize(node);
                treeArray = new T[treeSize];
 
                //Converts binary tree to array
                convertBTtoArray(node);
 
                //Sort treeArray
                Array.Sort(treeArray);
 
                //Converts array to binary search tree
                Node d = createBST(0, treeArray.Length -1);
                return d;
            }
    
            //calculateSize() will calculate size of tree
            int calculateSize(Node node)
            {    
                int size = 0;
                if (node == null)
                 return 0;
                else {
                    size = calculateSize (node.left) + calculateSize (node.right) + 1;
                    return size;
                }
            }
    
            //convertBTtoArray() will convert the given binary tree to its corresponding array representation
            public void convertBTtoArray(Node node) {
                //Check whether tree is empty
                if(root == null){
                    Console.WriteLine("Tree is empty");
                    return;
                }
                else {
                    if(node.left != null)
                        convertBTtoArray(node.left);
                    //Adds nodes of binary tree to treeArray
                    treeArray[index] = node.data; 
                    index++;
                    if(node.right != null)
                        convertBTtoArray(node.right);  
                    }      
                }
    
                //createBST() will convert array to binary search tree
                public Node createBST(int start, int end) {
 
                    //It will avoid overflow
                    if (start > end) {
                        return null;
                    }
 
                    //Variable will store middle element of array and make it root of binary search tree
                    int mid = (start + end) / 2;
                    Node node = new Node(treeArray[mid]);
 
                    //Construct left subtree
                    node.left = createBST(start, mid - 1);
 
                    //Construct right subtree
                    node.right = createBST(mid + 1, end);
 
                    return node;
                }
    
                //inorder() will perform inorder traversal on binary search tree
                public void inorderTraversal(Node node) {
 
                    //Check whether tree is empty
                    if(root == null){
                        Console.WriteLine("Tree is empty");
                        return;
                       }
                    else {
 
                        if(node.left!= null)
                            inorderTraversal(node.left);
                        Console.Write(node.data + " ");
                        if(node.right!= null)
                            inorderTraversal(node.right);
 
                      }      
                  }
        }
        
        public static void Main()
        {
            ConvertBTtoBST bt = new ConvertBTtoBST();
        
            //Add nodes to the binary tree
            bt.root = new Node(1);
            bt.root.left = new Node(2);
            bt.root.right = new Node(3);
            bt.root.left.left = new Node(4);
            bt.root.left.right = new Node(5);
            bt.root.right.left = new Node(6);
            bt.root.right.right = new Node(7);
 
            //Display given binary tree
            Console.WriteLine("Inorder representation of binary tree: ");
            bt.inorderTraversal(bt.root);
 
            //Converts binary tree to corresponding binary search tree
            Node bst = bt.convertBTBST(bt.root);
 
            //Display corresponding binary search tree
            Console.WriteLine("\nInorder representation of resulting binary search tree: ");
            bt.inorderTraversal(bst);                
        }    
    }
}

输出：

Inorder representation of binary tree: 
4 2 5 1 6 3 7 
Inorder representation of resulting binary search tree: 
1 2 3 4 5 6 7

PHP：




data = $data;
        $this->left = NULL;
        $this->right = NULL;
    }
}
class ConvertBTtoBST{
    //Represent the root of binary tree
    public $root;
    public $treeArray;
    public $index;
    function __construct(){
        $this->root = NULL;
        $this->treeArray = array();
        $this->index = 0;
    }
    
    //convertBTBST() will convert a binary tree to binary search tree
    function convertBTBST($node) {
        
        //Converts binary tree to array
        $this->convertBTtoArray($node);
        
          //Sort treeArray
        sort($this->treeArray);
      
        //Converts array to binary search tree
        $d = $this->createBST(0, count($this->treeArray) -1);
        return $d;
    }
    
    //convertBTtoArray() will convert the given binary tree to its corresponding array representation
    function convertBTtoArray($node) {
        //Check whether tree is empty
        if($this->root == null){
            print("Tree is empty 
");
            return;
        }
        else {
            if($node->left != NULL)
                $this->convertBTtoArray($node->left);
            //Adds nodes of binary tree to treeArray
            $this->treeArray[$this->index] = $node->data; 
            $this->index++;
            if($node->right != NULL)
                $this->convertBTtoArray($node->right);  
            }      
        }
    
    //createBST() will convert array to binary search tree
    function createBST($start, $end) {
        
        //It will avoid overflow
        if ($start > $end) {
            return NULL;
        }
        
        //Variable will store middle element of array and make it root of binary search tree
        $mid = ($start + $end) / 2;
        $node = new Node($this->treeArray[$mid]);
 
        //Construct left subtree
        $node->left = $this->createBST($start, $mid - 1);
 
        //Construct right subtree
        $node->right = $this->createBST($mid + 1, $end);
 
        return $node;
    }
    
    //inorder() will perform inorder traversal on binary search tree
    function inorderTraversal($node) {
        
        //Check whether tree is empty
        if($this->root == NULL){
            print("Tree is empty 
");
            return;
           }
        else {
            
            if($node->left!= NULL)
                $this->inorderTraversal($node->left);
            print("$node->data ");
            if($node->right!= NULL)
                $this->inorderTraversal($node->right);
              
          }      
      }
}
$bt = new ConvertBTtoBST();
//Add nodes to the binary tree
$bt->root = new Node(1);
$bt->root->left = new Node(2);
$bt->root->right = new Node(3);
$bt->root->left->left = new Node(4);
$bt->root->left->right = new Node(5);
$bt->root->right->left = new Node(6);
$bt->root->right->right = new Node(7);
 
//Display given binary tree
print("Inorder representation of binary tree: 
");
$bt->inorderTraversal($bt->root);
 
//Converts binary tree to corresponding binary search tree
$bst = $bt->convertBTBST($bt->root);
 
//Display corresponding binary search tree
print("
 Inorder representation of resulting binary search tree: 
");
$bt->inorderTraversal($bst);      
?>

输出：

Inorder representation of binary tree: 
4 2 5 1 6 3 7 
Inorder representation of resulting binary search tree: 
1 2 3 4 5 6 7