Given n appointments, find all conflicting appointments

import java.util.*;

public class Main {
  static class Pair<K, V> {
    private K key;
    private V value;

    public Pair(K key, V value) {
      this.key = key;
      this.value = value;
    }

    public K getKey() {
      return key;
    }

    public V getValue() {
      return value;
    }
  }

  public static void main(String[] args) {
    // Given Appointments.
    List<List<Integer>> v = new ArrayList<>();
    v.add(Arrays.asList(1, 5));
    v.add(Arrays.asList(3, 7));
    v.add(Arrays.asList(2, 6));
    v.add(Arrays.asList(10, 15));
    v.add(Arrays.asList(5, 6));
    v.add(Arrays.asList(4, 100));

    // sort according to start time of meet/appointment.
    // sort(v.begin(), v.end());
    // number of pair or appointments.
    int n = v.size();

    // for stoping the overlapping
    // vector<bool>vis(n,0);
    // traverse over and check for it.
    List<Pair<Pair<Integer, Integer>, Pair<Integer, Integer>>> result = new ArrayList<>();
    for (int i = 0; i < n; i++) {
      for (int j = i - 1; j >= 0; j--) {
        // to reduce extra/unwanted comparisons.
        // if(v[j][0]>v[i][1])break;
        // else{
        if (v.get(j).get(0) < v.get(i).get(1)) {
          result.add(new Pair<>(
            new Pair<>(v.get(i).get(0), v.get(i).get(1)),
            new Pair<>(v.get(j).get(1), v.get(j).get(0))
          ));
        }
      }
    }

    // final output.
    for (Pair<Pair<Integer, Integer>, Pair<Integer, Integer>> it : result) {
      System.out.printf("[%d,%d] having Conflict with [%d,%d]\n",
                        it.getKey().getKey(), it.getKey().getValue(),
                        it.getValue().getKey(), it.getValue().getValue());
    }
  }
}

// Java program to print all conflicting
// appointments in a given set of appointments
class GfG{

// Structure to represent an interval
static 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 node
static 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 node
static 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 property
static 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 overlap
static 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 code
public 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