使用 BST 在数组中删除重复项

给定一个整数数组 arr[] ，任务是从给定数组中删除重复项。

例子：

Input: arr[] = {1, 2, 3, 2, 5, 4, 4}
Output: arr[] = {1, 2, 3, 4, 5} 

Input: arr[] = {127, 234, 127, 654, 355, 789, 355, 355, 999, 654}
Output: arr[] = {127, 234, 355, 654, 789, 999}

可以使用二叉搜索树删除数组中的重复项。这个想法是使用数组元素创建一个二叉搜索树，条件是第一个元素被作为根(父)元素，当元素“小于”出现时，它被设为左子元素和元素“大于“根”成为根的右孩子。由于不存在“相等”的条件，因此当我们从数组元素形成二叉搜索树时，会自动删除重复项。

For the array, arr[] = {1, 2, 3, 2, 5, 4, 4}
BST will be: 
 

 

方法：

• 使用数组元素形成 BST
• 使用任何树遍历方法显示元素。

下面是上述方法的实现。

C++

// C++ Program of above implementation
#include 
using namespace std;
 
// Struct declaration
struct Node {
    int data;
    struct Node* left;
    struct Node* right;
};
 
// Node creation
struct Node* newNode(int data)
{
    struct Node* nn
        = new Node;
    nn->data = data;
    nn->left = NULL;
    nn->right = NULL;
    return nn;
}
 
// Function to insert data in BST
struct Node* insert(struct Node* root, int data)
{
    if (root == NULL)
        return newNode(data);
    else {
        if (data < root->data)
            root->left = insert(root->left, data);
        if (data > root->data)
            root->right = insert(root->right, data);
        return root;
    }
}
 
// InOrder function to display value of array
// in sorted order
void inOrder(struct Node* root)
{
    if (root == NULL)
        return;
    else {
        inOrder(root->left);
        cout << root->data << " ";
        inOrder(root->right);
    }
}
 
// Driver code
int main()
{
    int arr[] = { 1, 2, 3, 2, 5, 4, 4 };
 
    // Finding size of array arr[]
    int n = sizeof(arr) / sizeof(arr[0]);
 
    struct Node* root = NULL;
 
    for (int i = 0; i < n; i++) {
 
        // Insert element of arr[] in BST
        root = insert(root, arr[i]);
    }
 
    // Inorder Traversal to print nodes of Tree
    inOrder(root);
    return 0;
}
 
// This code is contributed by shivanisingh

C

// C Program of above implementation
#include 
#include 
 
// Struct declaration
struct Node {
    int data;
    struct Node* left;
    struct Node* right;
};
 
// Node creation
struct Node* newNode(int data)
{
    struct Node* nn
        = (struct Node*)(malloc(sizeof(struct Node)));
    nn->data = data;
    nn->left = NULL;
    nn->right = NULL;
    return nn;
}
 
// Function to insert data in BST
struct Node* insert(struct Node* root, int data)
{
    if (root == NULL)
        return newNode(data);
    else {
        if (data < root->data)
            root->left = insert(root->left, data);
        if (data > root->data)
            root->right = insert(root->right, data);
        return root;
    }
}
 
// InOrder function to display value of array
// in sorted order
void inOrder(struct Node* root)
{
    if (root == NULL)
        return;
    else {
        inOrder(root->left);
        printf("%d ", root->data);
        inOrder(root->right);
    }
}
 
// Driver code
int main()
{
    int arr[] = { 1, 2, 3, 2, 5, 4, 4 };
 
    // Finding size of array arr[]
    int n = sizeof(arr) / sizeof(arr[0]);
 
    struct Node* root = NULL;
 
    for (int i = 0; i < n; i++) {
 
        // Insert element of arr[] in BST
        root = insert(root, arr[i]);
    }
 
    // Inorder Traversal to print nodes of Tree
    inOrder(root);
    return 0;
}

Java

// Java implementation of the approach
import java.util.Scanner;
 
// Node declaration
class Node
{
    int data;
    public Node left;
    public Node right;
    Node(int data)
    {
        this.data = data;
        left = right = null;
    }
}
 
class GFG
{
 
    // Function to insert data in BST
    public static Node insert(Node root, int data)
    {
        if (root == null)
            return new Node(data);
        if (data < root.data)
            root.left = insert(root.left, data);
        if (data > root.data)
            root.right = insert(root.right, data);
        return root;
    }
 
    // InOrder function to display value of array
    // in sorted order
    public static void inOrder(Node root)
    {
        if (root == null)
            return;
        inOrder(root.left);
        System.out.print(root.data+" ");
        inOrder(root.right);
    }
 
    // Driver Code
    public static void main(String []args){
        int arr[] = { 1, 2, 3, 2, 5, 4, 4 };
 
        // Finding size of array arr[]
        int n = arr.length;
 
        Node root = null;
        for (int i = 0; i < n; i++)
        {
            // Insert element of arr[] in BST
            root = insert(root,arr[i]);
        }
 
        // Inorder Traversal to print nodes of Tree
        inOrder(root);
    }
}
 
// This code is contributed by anishma

Python3

# Python3 implementation of the approach
 
# Binary tree node consists of data, a
# pointer to the left child and a
# pointer to the right child
class newNode :
    def __init__(self,data) :
        self.data = data;
        self.left = None;
        self.right = None;
 
# Function to insert data in BST
def insert(root, data) :
 
    if (root == None) :
        return newNode(data);
         
    else :
        if (data < root.data) :
            root.left = insert(root.left, data);
             
        if (data > root.data) :
            root.right = insert(root.right, data);
             
        return root;
 
# InOrder function to display value of array
# in sorted order
def inOrder(root) :
 
    if (root == None) :
        return;
         
    else :
        inOrder(root.left);
        print(root.data, end = " ");
        inOrder(root.right);
     
# Driver code
if __name__ == "__main__" :
 
    arr = [ 1, 2, 3, 2, 5, 4, 4 ];
 
    # Finding size of array arr[]
    n = len(arr);
 
    root = None;
 
    for i in range(n) :
 
        # Insert element of arr[] in BST
        root = insert(root, arr[i]);
 
    # Inorder Traversal to print nodes of Tree
    inOrder(root);
 
# This code is contributed by AnkitRai01

C#

// C# program of above implementation
using System;
 
// Node declaration 
public class Node 
{ 
    public int data; 
    public Node left; 
    public Node right;
     
    public Node(int data)
    {
        this.data = data;
        left = right = null;
    }
}
     
class GFG{
     
// Function to insert data in BST 
public static Node insert(Node root, int data)
{
    if (root == null)
        return new Node(data);
    if (data < root.data) 
        root.left = insert(root.left, data); 
    if (data > root.data)
        root.right = insert(root.right, data);
         
    return root; 
} 
 
// InOrder function to display value of array 
// in sorted order 
public static void inOrder(Node root)
{ 
    if (root == null) 
        return; 
         
    inOrder(root.left); 
    Console.Write(root.data + " ");
    inOrder(root.right); 
}
 
// Driver Code   
static void Main()
{
    int[] arr = { 1, 2, 3, 2, 5, 4, 4 }; 
     
    // Finding size of array arr[] 
    int n = arr.Length; 
     
    Node root = null; 
    for(int i = 0; i < n; i++) 
    { 
         
        // Insert element of arr[] in BST
        root = insert(root, arr[i]);
    } 
     
    // Inorder Traversal to print nodes of Tree 
    inOrder(root);
}
}
 
// This code is contributed by divyeshrabadiya07

输出：

1 2 3 4 5

时间复杂度： $O(N^2)$在最坏的情况下(当数组被排序时)，其中 N 是给定数组的大小。

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live