Question

You have to use Binary Tree ADT.

Problem Use Java as Programming Language Define an ESports World Cup class that implements the E-Games World Cup using a Binary Tree ADT. The external nodes of the tree correspond to each competing player. The internal nodes correspond to games played at different rounds of the cup (i.e. root of the tree is the final game, its children are the semifinals, etc.). Two players compete against each other and the winner goes to the next round. The internal nodes keep track of the winner in each game (i.e. the root node will eventually hold the champion of the World Cup). At any given round, if a player does not have an opponent to compete against, he/she is directly promoted to the next round. Implement necessary methods to add players to the cup, execute the games at each round of the cup, display the game results starting from the first round until the final game. Use Breadth-First Search Traversal to execute and print the games played at each round of the World Cup. Also, implement a method that displays the performance of a given player during the World Cup (i.e., games played and won/lost). Write a test code, TestWorldCup, to simulate the following scenario: Test Scenario: • FortNite World Cup with 20 players. • The outcome of each game will be randomly determined. • At the end of the tournament, print the game results starting from the first round until the final game. • Print the competition history (i.e., games played at each round) of the Champion, one Semi-Finalist and one other randomly selected player.

Answer 1

Answer:

As per the given data, the following code would be helpful.

Building a binary tree ADT

A binary tree is a hierarchical data structure whose behavior is similar to a tree, as it contains root and leaves (a node that has no child). The root of a binary tree is the topmost node. Each node can have at most two children, which are referred to as the left child and the right child. A node that has at least one child becomes a parent of its child. A node that has no child is a leaf. Please take a look at the following binary tree:

2 4 5 6 7

Code:

import java.io.*;
import java.util.*;

// This class represents a directed graph using adjacency list  representation
class GraphTry
{
   private int V; // No. of vertices
   private LinkedList<Integer> adj[]; //Adjacency Lists

   // Constructor
   Graph(int v)
   {
       V = v;
       adj = new LinkedList[v];
       for (int i=0; i<v; ++i)
           adj[i] = new LinkedList();
   }

   // Function to add an edge into the graph
   void addEdge(int v,int w)
   {
       adj[v].add(w);
   }

   // prints BFS traversal from a given source s
   void BFS(int s)
   {
       // Mark all the vertices as not visited(By default set as false)
       boolean visited[] = new boolean[V];

       // Creating a queue for BFS
       LinkedList<Integer> queue = new LinkedList<Integer>();

       // Mark the current node as visited and enqueue it
       visited[s]=true;
       queue.add(s);

       while (queue.size() != 0)
       {
           // Dequeueing a vertex from queue and then printing it
           s = queue.poll();
           System.out.print(s+" ");

           /* Get all adjacent vertices of the dequeued vertex s, If a adjacent has not been visited, then mark it visited and enqueue it */
           Iterator<Integer> i = adj[s].listIterator();
           while (i.hasNext())
           {
               int n = i.next();
               if (!visited[n])
               {
                   visited[n] = true;
                   queue.add(n);
               }
           }
       }
   }

   // Main method
   public static void main(String args[])
   {
       GraphTry g = new GraphTry(4);

       g.addEdge(0, 1);
       g.addEdge(0, 2);
       g.addEdge(1, 2);
       g.addEdge(2, 0);
       g.addEdge(2, 3);
       g.addEdge(3, 3);

       System.out.println(" Breadth First "+ "(starting from vertex 2)");

       g.BFS(2);
   }
}

I hope it will be helpful, Please give ThumsUp

Thank you!!