Given n appointments, find all conflicting appointments

24 Jun, 2022
Given n appointments, find all conflicting appointments. 
Examples:
Input: appointments[] = { {1, 5} {3, 7}, {2, 6}, {10, 15}, {5, 6}, {4, 100}}
Output: Following are conflicting intervals
[3,7] Conflicts with [1,5]
[2,6] Conflicts with [1,5]
[5,6] Conflicts with [3,7]
[4,100] Conflicts with [1,5]
An appointment is conflicting if it conflicts with any of the previous appointments in the array.
We strongly recommend to minimize the browser and try this yourself first.
A Simple Solution is to one by one process all appointments from the second appointment to last. For every appointment i, check if it conflicts with i-1, i-2, ... 0. The time complexity of this method is O(n2). We can use Interval Tree to solve this problem in O(nLogn) time. Following is a detailed algorithm. 
Create an Interval Tree, initially with the first appointment.Do following for all other appointments starting from the second one.Check if the current appointment conflicts with any of the existing  appointments in Interval Tree.  If conflicts, then print the current appointment.  This step can be done O(Logn) time.nsert the current appointment in Interval Tree. This step also can be done O(Logn) time.
Create an Interval Tree, initially with the first appointment.
Do following for all other appointments starting from the second one.Check if the current appointment conflicts with any of the existing  appointments in Interval Tree.  If conflicts, then print the current appointment.  This step can be done O(Logn) time.nsert the current appointment in Interval Tree. This step also can be done O(Logn) time.
Check if the current appointment conflicts with any of the existing  appointments in Interval Tree.  If conflicts, then print the current appointment.  This step can be done O(Logn) time.nsert the current appointment in Interval Tree. This step also can be done O(Logn) time.
Check if the current appointment conflicts with any of the existing  appointments in Interval Tree.  If conflicts, then print the current appointment.  This step can be done O(Logn) time.
nsert the current appointment in Interval Tree. This step also can be done O(Logn) time.
Following is the implementation of the above idea.
C++
Java
Python3
C#
Javascript
// C++ program to print all conflicting appointments in a// given set of appointments#include <bits/stdc++.h>using namespace std; // Structure to represent an intervalstruct Interval{    int low, high;}; // Structure to represent a node in Interval Search Treestruct ITNode{    Interval *i;  // 'i' could also be a normal variable    int max;    ITNode *left, *right;}; // A utility function to create a new Interval Search Tree NodeITNode * newNode(Interval i){    ITNode *temp = new ITNode;    temp->i = new Interval(i);    temp->max = i.high;    temp->left = temp->right = NULL;      return temp;}; // A utility function to insert a new Interval Search Tree// Node. This is similar to BST Insert.  Here the low value//  of interval is used tomaintain BST propertyITNode *insert(ITNode *root, Interval i){    // Base case: Tree is empty, new node becomes root    if (root == NULL)        return newNode(i);     // Get low value of interval at root    int l = root->i->low;     // If root's low value is smaller, then new interval    //  goes to left subtree    if (i.low < l)        root->left = insert(root->left, i);     // Else, new node goes to right subtree.    else        root->right = insert(root->right, i);     // Update the max value of this ancestor if needed    if (root->max < i.high)        root->max = i.high;     return root;} // A utility function to check if given two intervals overlapbool doOVerlap(Interval i1, Interval i2){    if (i1.low < i2.high && i2.low < i1.high)        return true;    return false;} // The main function that searches a given interval i// in a given Interval Tree.Interval *overlapSearch(ITNode *root, Interval i){    // Base Case, tree is empty    if (root == NULL) return NULL;     // If given interval overlaps with root    if (doOVerlap(*(root->i), i))        return root->i;     // If left child of root is present and max of left child    // is greater than or equal to given interval, then i may    // overlap with an interval is left subtree    if (root->left != NULL && root->left->max >= i.low)        return overlapSearch(root->left, i);     // Else interval can only overlap with right subtree    return overlapSearch(root->right, i);} // This function prints all conflicting appointments in a given// array of appointments.void printConflicting(Interval appt[], int n){     // Create an empty Interval Search Tree, add first     // appointment     ITNode *root = NULL;     root = insert(root, appt[0]);      // Process rest of the intervals     for (int i=1; i<n; i++)     {         // If current appointment conflicts with any of the         // existing intervals, print it         Interval *res = overlapSearch(root, appt[i]);         if (res != NULL)            cout << "[" << appt[i].low << "," << appt[i].high                 << "] Conflicts with [" << res->low << ","                 << res->high << "]\n";          // Insert this appointment         root = insert(root, appt[i]);     }}  // Driver program to test above functionsint main(){    // Let us create interval tree shown in above figure    Interval appt[] = { {1, 5}, {3, 7}, {2, 6}, {10, 15},                        {5, 6}, {4, 100}};    int n = sizeof(appt)/sizeof(appt[0]);    cout << "Following are conflicting intervals\n";    printConflicting(appt, n);    return 0;}
// Java program to print all conflicting// appointments in a given set of appointmentsclass GfG{ // Structure to represent an intervalstatic class Interval{    int low, high;} static class ITNode{         // 'i' could also be a normal variable    Interval i;    int max;    ITNode left, right;} // A utility function to create a new nodestatic Interval newNode(int l, int h){    Interval temp = new Interval();    temp.low = l;    temp.high = h;    return temp;} // A utility function to create a new nodestatic ITNode newNode(Interval i){    ITNode temp = new ITNode();    temp.i = i;    temp.max = i.high;    temp.left = temp.right = null;    return temp;} // A utility function to insert a new// Interval Search Tree Node. This is// similar to BST Insert. Here the// low value of interval is used to// maintain BST propertystatic ITNode insert(ITNode root, Interval i){         // Base case: Tree is empty,    // new node becomes root    if (root == null)        return newNode(i);     // Get low value of interval at root    int l = root.i.low;     // If root's low value is smaller,    // then new interval goes to left subtree    if (i.low < l)        root.left = insert(root.left, i);     // Else, new node goes to right subtree.    else        root.right = insert(root.right, i);     // Update the max value of this    // ancestor if needed    if (root.max < i.high)        root.max = i.high;     return root;} // A utility function to check if given// two intervals overlapstatic boolean doOVerlap(Interval i1, Interval i2){    if (i1.low < i2.high && i2.low < i1.high)        return true;             return false;} // The main function that searches a given// interval i in a given Interval Tree.static Interval overlapSearch(ITNode root,                              Interval i){         // Base Case, tree is empty    if (root == null)        return null;     // If given interval overlaps with root    if (doOVerlap(root.i, i))        return root.i;     // If left child of root is present    // and max of left child is greater    // than or equal to given interval,    // then i may overlap with an interval    // is left subtree    if (root.left != null &&        root.left.max >= i.low)        return overlapSearch(root.left, i);     // Else interval can only    // overlap with right subtree    return overlapSearch(root.right, i);} // This function prints all conflicting// appointments in a given array of appointments.static void printConflicting(Interval appt[], int n){         // Create an empty Interval Search    // Tree, add first appointment    ITNode root = null;    root = insert(root, appt[0]);     // Process rest of the intervals    for(int i = 1; i < n; i++)    {                 // If current appointment conflicts        // with any of the existing intervals,        // print it        Interval res = overlapSearch(root, appt[i]);                 if (res != null)            System.out.print("[" + appt[i].low +                             "," + appt[i].high +                             "] Conflicts with [" +                             res.low + "," +                             res.high + "]\n");                                      // Insert this appointment        root = insert(root, appt[i]);    }} // Driver codepublic static void main(String[] args){    Interval appt[] = new Interval[6];    appt[0] = newNode(1, 5);    appt[1] = newNode(3, 7);    appt[2] = newNode(2, 6);    appt[3] = newNode(10, 15);    appt[4] = newNode(5, 6);    appt[5] = newNode(4, 100);         int n = appt.length;    System.out.print(        "Following are conflicting intervals\n");             printConflicting(appt, n);}} // This code is contributed by tushar_bansal
# Python3 program to print all conflicting# appointments in a given set of appointments # Structure to represent an intervalclass Interval:         def __init__(self):                 self.low = None        self.high = None         # Structure to represent a node# in Interval Search Treeclass ITNode:         def __init__(self):                 self.max = None        self.i = None        self.left = None        self.right = None def newNode(j):         #print(j)    temp = ITNode()    temp.i = j    temp.max = j[1]     return temp # A utility function to check if# given two intervals overlapdef doOVerlap(i1, i2):         if (i1[0] < i2[1] and i2[0] < i1[1]):        return True             return False # Function to create a new nodedef insert(node, data):         global succ         # If the tree is empty, return a new node    root = node     if (node == None):        return newNode(data)     # If key is smaller than root's key, go to left    # subtree and set successor as current node    # print(node)    if (data[0] < node.i[0]):                 # print(node)        root.left = insert(node.left, data)     # Go to right subtree    else:        root.right = insert(node.right, data)    if root.max < data[1]:        root.max = data[1]     return root # The main function that searches a given# interval i in a given Interval Tree.def overlapSearch(root, i):         # Base Case, tree is empty    if (root == None):        return None     # If given interval overlaps with root    if (doOVerlap(root.i, i)):        return root.i     # If left child of root is present and    # max of left child is greater than or    # equal to given interval, then i may    # overlap with an interval is left subtree    if (root.left != None and root.left.max >= i[0]):        return overlapSearch(root.left, i)     # Else interval can only overlap    # with right subtree    return overlapSearch(root.right, i) # This function prints all conflicting# appointments in a given array of# appointments.def printConflicting(appt, n):         # Create an empty Interval Search Tree,    # add first appointment    root = None    root = insert(root, appt[0])         # Process rest of the intervals    for i in range(1, n):                 # If current appointment conflicts        # with any of the existing intervals,        # print it        res = overlapSearch(root, appt[i])                 if (res != None):            print("[", appt[i][0], ",", appt[i][1],                  "] Conflicts with [", res[0],                  ",", res[1], "]")         # Insert this appointment        root = insert(root, appt[i]) # Driver codeif __name__ == '__main__':         # Let us create interval tree    # shown in above figure    appt = [ [ 1, 5 ], [ 3, 7 ],             [ 2, 6 ], [ 10, 15 ],             [ 5, 6 ], [ 4, 100 ] ]                  n = len(appt)         print("Following are conflicting intervals")         printConflicting(appt, n) # This code is contributed by mohit kumar 29
// C# program to print all conflicting// appointments in a given set of appointmentsusing System;public class GfG{ // Structure to represent an intervalpublicclass Interval{    publicint low, high;}publicclass ITNode{         // 'i' could also be a normal variable   public  Interval i;    public int max;    publicITNode left, right;} // A utility function to create a new nodestatic Interval newNode(int l, int h){    Interval temp = new Interval();    temp.low = l;    temp.high = h;    return temp;} // A utility function to create a new nodestatic ITNode newNode(Interval i){    ITNode temp = new ITNode();    temp.i = i;    temp.max = i.high;    temp.left = temp.right = null;    return temp;} // A utility function to insert a new// Interval Search Tree Node. This is// similar to BST Insert. Here the// low value of interval is used to// maintain BST propertystatic ITNode insert(ITNode root, Interval i){         // Base case: Tree is empty,    // new node becomes root    if (root == null)        return newNode(i);     // Get low value of interval at root    int l = root.i.low;     // If root's low value is smaller,    // then new interval goes to left subtree    if (i.low < l)        root.left = insert(root.left, i);     // Else, new node goes to right subtree.    else        root.right = insert(root.right, i);     // Update the max value of this    // ancestor if needed    if (root.max < i.high)        root.max = i.high;    return root;} // A utility function to check if given// two intervals overlapstatic bool doOVerlap(Interval i1, Interval i2){    if (i1.low < i2.high && i2.low < i1.high)        return true;         return false;} // The main function that searches a given// interval i in a given Interval Tree.static Interval overlapSearch(ITNode root,                              Interval i){         // Base Case, tree is empty    if (root == null)        return null;     // If given interval overlaps with root    if (doOVerlap(root.i, i))        return root.i;     // If left child of root is present    // and max of left child is greater    // than or equal to given interval,    // then i may overlap with an interval    // is left subtree    if (root.left != null &&        root.left.max >= i.low)        return overlapSearch(root.left, i);     // Else interval can only    // overlap with right subtree    return overlapSearch(root.right, i);} // This function prints all conflicting// appointments in a given array of appointments.static void printConflicting(Interval []appt, int n){         // Create an empty Interval Search    // Tree, add first appointment    ITNode root = null;    root = insert(root, appt[0]);     // Process rest of the intervals    for(int i = 1; i < n; i++)    {                 // If current appointment conflicts        // with any of the existing intervals,        // print it        Interval res = overlapSearch(root, appt[i]);                 if (res != null)            Console.Write("[" + appt[i].low +                             "," + appt[i].high +                             "] Conflicts with [" +                             res.low + "," +                             res.high + "]\n");                                      // Insert this appointment        root = insert(root, appt[i]);    }} // Driver codepublic static void Main(String[] args){    Interval []appt = new Interval[6];    appt[0] = newNode(1, 5);    appt[1] = newNode(3, 7);    appt[2] = newNode(2, 6);    appt[3] = newNode(10, 15);    appt[4] = newNode(5, 6);    appt[5] = newNode(4, 100);      int n = appt.Length;    Console.Write(        "Following are conflicting intervals\n");    printConflicting(appt, n);}} // This code is contributed by gauravrajput1
<script>  // Javascript program to print all conflicting// appointments in a given set of appointments // Structure to represent an intervalclass Interval{    constructor()    {        this.low = 0;        this.high = 0;    }} class ITNode{    // 'i' could also be a normal variable    constructor()    {        this.max = 0;        this.left = null;        this.right = null;        this.i = null;    }} // A utility function to create a new nodefunction newNodeDouble(l, h){    var temp = new Interval();    temp.low = l;    temp.high = h;    return temp;} // A utility function to create a new nodefunction newNodeSingle(i){    var temp = new ITNode();    temp.i = i;    temp.max = i.high;    temp.left = temp.right = null;    return temp;} // A utility function to insert a new// Interval Search Tree Node. This is// similar to BST Insert. Here the// low value of interval is used to// maintain BST propertyfunction insert(root, i){         // Base case: Tree is empty,    // new node becomes root    if (root == null)        return newNodeSingle(i);     // Get low value of interval at root    var l = root.i.low;     // If root's low value is smaller,    // then new interval goes to left subtree    if (i.low < l)        root.left = insert(root.left, i);     // Else, new node goes to right subtree.    else        root.right = insert(root.right, i);     // Update the max value of this    // ancestor if needed    if (root.max < i.high)        root.max = i.high;    return root;} // A utility function to check if given// two intervals overlapfunction doOVerlap(i1, i2){    if (i1.low < i2.high && i2.low < i1.high)        return true;         return false;} // The main function that searches a given// interval i in a given Interval Tree.function overlapSearch(root, i){         // Base Case, tree is empty    if (root == null)        return null;     // If given interval overlaps with root    if (doOVerlap(root.i, i))        return root.i;     // If left child of root is present    // and max of left child is greater    // than or equal to given interval,    // then i may overlap with an interval    // is left subtree    if (root.left != null &&        root.left.max >= i.low)        return overlapSearch(root.left, i);     // Else interval can only    // overlap with right subtree    return overlapSearch(root.right, i);} // This function prints all conflicting// appointments in a given array of appointments.function printConflicting(appt, n){         // Create an empty Interval Search    // Tree, add first appointment    var root = null;    root = insert(root, appt[0]);     // Process rest of the intervals    for(var i = 1; i < n; i++)    {                 // If current appointment conflicts        // with any of the existing intervals,        // print it        var res = overlapSearch(root, appt[i]);                 if (res != null)            document.write("[" + appt[i].low +                             "," + appt[i].high +                             "] Conflicts with [" +                             res.low + "," +                             res.high + "]<br>");                                      // Insert this appointment        root = insert(root, appt[i]);    }} // Driver codevar appt = Array(6);appt[0] = newNodeDouble(1, 5);appt[1] = newNodeDouble(3, 7);appt[2] = newNodeDouble(2, 6);appt[3] = newNodeDouble(10, 15);appt[4] = newNodeDouble(5, 6);appt[5] = newNodeDouble(4, 100);  var n = appt.length;document.write(    "Following are conflicting intervals<br>");printConflicting(appt, n);  </script>
Following are conflicting intervals
[3,7] Conflicts with [1,5]
[2,6] Conflicts with [1,5]
[5,6] Conflicts with [3,7]
[4,100] Conflicts with [1,5]
Note that the above implementation uses a simple Binary Search Tree insert operations. Therefore, the time complexity of the above implementation is more than O(nLogn). We can use Red-Black Tree or AVL Tree balancing techniques to make the above implementation O(nLogn).
This article is contributed by Anmol. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above
mysticpeaks
mohit kumar 29
GauravRajput1
rutvik_56
mathuriarajatkumar
surindertarika1234
hardikkoriintern
Binary Search Tree
Binary Search Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
set vs unordered_set in C++ STL
Flatten BST to sorted list | Increasing order
Count BST nodes that lie in a given range
Find median of BST in O(n) time and O(1) space
Largest BST in a Binary Tree | Set 2
Replace every element with the least greater element on its right
Convert BST to Min Heap
Floor and Ceil from a BST
Common operations on various Data Structures
Find the largest BST subtree in a given Binary Tree | Set 3