Reverse delete algorithm for minimum spanning tree

import java.util.ArrayList;
/*
    Java Program
    Reverse delete algorithm for minimum spanning tree
*/
class Edge
{
	// edge weight or cost  
	public int weight;
	public int u;
	public int v;
	public Edge next;
	public Edge(int weight, int u, int v)
	{
		this.weight = weight;
		this.u = u;
		this.v = v;
		this.next = null;
	}
}
public class Graph
{
	public int vertices;
	public ArrayList < ArrayList < Integer >> adgeList;
	public Edge edges;
	public int edgeCount;
	public Graph(int vertices)
	{
		this.vertices = vertices;
		this.adgeList = new ArrayList < ArrayList < Integer >> (vertices);
		this.edges = null;
		this.edgeCount = 0;
		for (int i = 0; i < this.vertices; ++i)
		{
			this.adgeList.add(new ArrayList < Integer > ());
		}
	}
	public void addEdge(int u, int v, int w)
	{
		if (u < 0 || u >= this.vertices || v < 0 || v >= this.vertices)
		{
			return;
		}
      	// add node edge
		adgeList.get(u).add(v);
		adgeList.get(v).add(u);
      	// Collect descending order sorted edges
		// Create new edge
		Edge e = new Edge(w, u, v);
		// Add edge in decreasing order
		if (this.edges == null)
		{
			// First edge
			this.edges = e;
		}
		else if (this.edges.weight <= e.weight)
		{
			// Add edges in front
			e.next = this.edges;
			this.edges = e;
		}
		else
		{
			Edge temp = this.edges;
			// Find position to add new edge
			while (temp.next != null && temp.next.weight > e.weight)
			{
				temp = temp.next;
			}
			e.next = temp.next;
			temp.next = e;
		}
		this.edgeCount = this.edgeCount + 1;
	}
	// Perform DFS
	public void findDFS(int v, boolean[] visited)
	{
		// Indicates the current vertex is visited
		visited[v] = true;
		// iterate edges of v node
		for (int i = 0; i < this.adgeList.get(v).size(); i++)
		{
			if (visited[this.adgeList.get(v).get(i)] == false)
			{
				findDFS(this.adgeList.get(v).get(i), visited);
			}
		}
	}
	// Check that graph start vertices are reach to all other vertices or not
	public boolean isConnected()
	{
		boolean[] visited = new boolean[this.vertices];
		// Set the initial visited vertices
		for (int i = 0; i < this.vertices; ++i)
		{
			visited[i] = false;
		}
		this.findDFS(0, visited);
		for (int i = 1; i < this.vertices; i++)
		{
			if (visited[i] == false)
			{
				// When [i] vertices are not visit
				return false;
			}
		}
		return true;
	}
	public void printGraph()
	{
      	System.out.print("\n Graph Adjacency List ");
		for (int i = 0; i < this.vertices; ++i)
		{
			System.out.print(" \n [" + i + "] :");
			// iterate edges of i node
			for (int j = 0; j < this.adgeList.get(i).size(); j++)
			{
				System.out.print("  " + this.adgeList.get(i).get(j));
			}
		}
	}
	public void reverseDeleteMST()
	{
		int result = 0;
		// Get first higher edge
		Edge point = this.edges;
		System.out.println("\n\nConnected node by Edges in MST");
		// iterates the edge from high to low order
		while (point != null)
		{
			// Remove the current weight edge of node from u to v and v to u
			adgeList.get(point.u).remove(new Integer(point.v));
			adgeList.get(point.v).remove(new Integer(point.u));
			if (isConnected() == false)
			{
				// When delete edge are create problems (). 
				// Then they are add back into graph
				adgeList.get(point.u).add(point.v);
				adgeList.get(point.v).add(point.u);
				// Update weight    
				result += point.weight;
				// Display edge
				System.out.print(" (" + point.u + ", " + point.v + ") \n");
			}
			// Visit next smaller weight edge
			point = point.next;
		}
		System.out.println("Calculated total weight of MST is " + result);
	}
	public static void main(String[] args)
	{
		Graph g = new Graph(8);
		g.addEdge(0, 1, 5);
		g.addEdge(0, 3, 3);
		g.addEdge(1, 2, 3);
		g.addEdge(1, 6, 7);
		g.addEdge(1, 7, 9);
		g.addEdge(2, 5, 9);
		g.addEdge(2, 7, 4);
		g.addEdge(3, 4, 11);
		g.addEdge(3, 7, 8);
		g.addEdge(4, 5, 8);
		g.addEdge(4, 6, 14);
		g.addEdge(4, 7, 10);
		g.addEdge(5, 6, 11);
		// Display graph element
		g.printGraph();
		// Find MST
		g.reverseDeleteMST();
	}
}

input

 Graph Adjacency List
 [0] :  1  3
 [1] :  0  2  6  7
 [2] :  1  5  7
 [3] :  0  4  7
 [4] :  3  5  6  7
 [5] :  2  4  6
 [6] :  1  4  5
 [7] :  1  2  3  4

Connected node by Edges in MST
 (2, 5)
 (4, 5)
 (1, 6)
 (0, 1)
 (2, 7)
 (1, 2)
 (0, 3)
Calculated total weight of MST is 39