1. Given a Vertex object x, give Java code to enumerate its outgoing edges. ("Enumerate" means "tolist"; your code does not need to do anything with the edges, but should be setup code that wouldmake it easy to do something with each edge if we wanted to add that in.)2. Given a VertexAndDist object x and a new distance d, give Java code to create an updated objectwith the same vertex as x but with distance d.3. For simplicity of implementation, we use HashMaps to map vertices to handles/parents and edges toweights. How could you modify the Vertex and/or Edge classes, as well as the maps themselves, toimplement the maps using ordinary arrays, with no hashing? Be sure to address both the vertex andedge mapsin your answer. (Hint: consider the Vertex's "id" field for inspiration.)

“Since you have asked multiple questions, we will solve the first question for you. If you want any specific question to be solved, then please specify the question number or post only that question.” To display the outgoing edge, we are using the approach of traversing the adjacency list. if the size of the adjacency list of node i is x then out degree for i=x .increment the in-degree of each node that has the incoming edge from i.Java code to enumerate its outgoing edges is shown below: CODE: // search in and out degrees of nodes of graphimport java.util.*; class Graph { // method to print the in and out degrees static void searchInOut(List<List<Integer> > AdjacencyL, int n) { int in[] = new int[n]; int out[] = new int[n]; for (int i = 0; i < AdjacencyL.size(); i++) { List<Integer> list = AdjacencyL.get(i); // Out degree for ith nodes is count // of direct paths from i to other nodes out[i] = list.size(); for (int j = 0; j < list.size(); j++) // Each nodes that has an incoming // edge from i in[list.get(j)]++; } System.out.println("nodes\tIn\tOut"); for (int k = 0; k < n; k++) { System.out.println(k + "\t" + in[k] + "\t" + out[k]); } } // main method public static void main(String args[]) { // Adjacency list List<List<Integer> > AdjacencyL = new ArrayList<>(); // nodes 1 and 2 have an incoming edge // from nodes 0 List<Integer> tmp = new ArrayList<Integer>(Arrays.asList(1, 2)); AdjacencyL.add(tmp); // nodes 3 has an incoming edge from nodes 1 tmp = new ArrayList<Integer>(Arrays.asList(3)); AdjacencyL.add(tmp); // nodes 0, 5 and 6 have an incoming // edge from nodes 2 tmp =new ArrayList<Integer>(Arrays.asList(0, 5, 6)); AdjacencyL.add(tmp); // nodes 1 and 4 have an incoming edge // from nodes 3 tmp = new ArrayList<Integer>(Arrays.asList(1, 4)); AdjacencyL.add(tmp); // nodes 2 and 3 have an incoming edge // from nodes 4 tmp = new ArrayList<Integer>(Arrays.asList(2, 3)); AdjacencyL.add(tmp); // nodes 4 and 6 have an incoming edge // from nodes 5 tmp = new ArrayList<Integer>(Arrays.asList(4, 6)); AdjacencyL.add(tmp); // nodes 5 has an incoming edge from nodes 6 tmp = new ArrayList<Integer>(Arrays.asList(5)); AdjacencyL.add(tmp); int n = AdjacencyL.size(); searchInOut(AdjacencyL, n); }} OUTPUT: In the given code, we are displaying nodes and their outgoing and incoming degrees. These will automatically tell the numbers of outgoing edges of the graph. In the given code, the programmer writes a function searchInOut() to print in and out degrees of a graph. In the main method, forming an adjacent list to hold the connected vertices of the current node. The output has 3 columns in it: Nodes, In, and out. Vertex 0 has 2 outgoing edges. vertex 1 has 1 outgoing edge and so on.

Engineering

Computer Science

1. Given a Vertex object x, give Java code to enumerate its outgoing edges. ("Enumerate" means "to list"; your code does not need to do anything with the edges, but should be setup code that would make it easy to do something with each edge if we wanted to add that in.)

1. Given a Vertex object x, give Java code to enumerate its outgoing edges. ("Enumerate" means "to list"; your code does not need to do anything with the edges, but should be setup code that would make it easy to do something with each edge if we wanted to add that in.)

Database System Concepts

7th Edition

ISBN:9780078022159

Author:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Publisher:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Chapter1: Introduction

Section: Chapter Questions

Problem 1PE

See similar textbooks

Similar questions

Java with screen shot please
In writing a general-purpose sort method in Java, the sort method needs to compareobjects. There are two ways to give the sort method the code to compare objects,implementing the interfaces Comparable and Comparator respectively. Extend Article class toimplement Comparable interface so that the default sorting of the Articles is by its volume
Write and test a Java method clshift() that performs a circular left shift on an array of nintegers.
Can you help me with this question?
Given the weightedGraph class below, implement the Bellman Ford and Dijkstra's algorithms following the instructions in the comments of the screenshots provided. This should be completed in python 3.10 or later please. class WeightedGraph(Graph) : """Weighted graph represented with adjacency lists.""" def __init__(self, v=10, edges=[], weights=[]) : """Initializes a weighted graph with a specified number of vertexes. Keyword arguments: v - number of vertexes edges - any iterable of ordered pairs indicating the edges weights - list of weights, same length as edges list """ super().__init__(v) for i, (u, v) in enumerate(edges): self.add_edge(u, v, weights[i]) def add_edge(self, a, b, w=1) : """Adds an edge to the graph. Keyword arguments: a - first end point b - second end point """ self._adj[a].add(b, w) self._adj[b].add(a, w) def…
There are three main operations on rectangles: intersection, union, and difference. Among them, only intersection is guaranteed to return another rectangle. In general, the union of two rectangles is... two rectangles, and the difference between two rectangles is ... a whole lot of rectangles, as we will see. We let you implement rectangle intersection. Of course, the intersection is defined only if the rectangles have the same number of dimensions. The intersection is computed by taking the intersection of the intervals of the two rectangles for corresponding dimensions. If one of the intervals is empty, you should return None. [] # @ title Rectangle intersection def rectangle_and(self, other): if self.ndims != other.ndims: raise TypeError("The rectangles have different dimensions: {} and {}".format( )) self.ndims, other.ndims ### YOUR SOLUTION HERE Rectangle. _and_ = rectangle_and [ ] r1 = Rectangle((2, 3), (0, 4)) r2 = Rectangle((0, 4), (1, 3)) draw rectangles (r1, r2) draw…