Develop Reference

Insert method in Binary Search Tree

when I insert nodes into the binary tree and go test it out in the main by printing it in order the output is always wrong I have tried other solutions but it just keeps getting into bigger problems and in the output, it will be displayed in the wrong order I check the display its perfect but the problem is with the insert method (insert method insert non repeated keys).
class BSTNode<T> {
public int key;
public T data;
public BSTNode<T> left, right;
public BSTNode(int k, T val) {
key = k;
data = val;
left = right = null;
}
public BSTNode(int k, T val, BSTNode<T> l, BSTNode<T> r) {
key = k;
data = val;
left = l;
right = r;
}
}
public class BST<T> {
BSTNode<T> root, current;
public BST() {
root = current = null;
}
public boolean empty() {
return root == null;
}
public boolean full() {
return false;
}
public T retrieve() {
return current.data;
}
public boolean findkey(int tkey) {
BSTNode<T> p = root, q = root;
if (empty())
return false;
int nb = 0;
while (p != null) {
q = p;
nb++;
if (p.key == tkey) {
current = p;
return true;
} else if (tkey < p.key)
p = p.left;
else
p = p.right;
}
current = q;
return false;
}
public boolean insert(int key, T val) {
BSTNode<T> p = current, q = current;
while (p != null) {
q = p;
if (p.key == key) {
return false;
} else if (key < p.key)
p = p.left;
else
p = p.right;
}
p = new BSTNode<T>(key, val);
if (empty()) {
root = current = p;
return true;
} else {
// current is pointing to parent of the new key
if (key < current.key)
current.left = p;
else
current.right = p;
current = p;
return true;
}
}
public void display() {
if (root == null)
System.out.println("BST IS EMPTY");
else
displayin(root);
System.out.println();
}
private void displayin(BSTNode<T> p) {
if (p != null) {
displayin(p.left);
System.out.print(p.key + " " + p.data + " , ");
displayin(p.right);
}
}
}

In your insert method, the first code part:
while (p != null) {
q = p;
if (p.key == key) {
current = p;
return true;
} else if (key < p.key)
p = p.left;
else
p = p.right;
}
simply returns true when the key you want to write to is found. It does however not insert val here at all. You could have detected this by calling the insert method on some tree and then printing that tree, comparing the outcome that you had expected with the actual outcome. In automated form, you could do this with JUnit tests.

I think I know want you want (now). I have changed the "display"-Method to toString, rewrote insert and implemented a form of bfs for toString.
import java.util.ArrayList;
class BSTNode<T> {
public int key;
public T data;
public BSTNode<T> left, right;
public BSTNode(int k, T val) {
key = k;
data = val;
left = right = null;
}
public BSTNode(int k, T val, BSTNode<T> l, BSTNode<T> r) {
key = k;
data = val;
left = l;
right = r;
}
#Override
public String toString() {
return "[" + key + ":" + data + "]";
}
}
public class BST<T> {
BSTNode<T> root, current;
public BST() {
root = current = null;
}
public boolean empty() {
return root == null;
}
public T retrieve() {
return current.data;
}
public boolean findkey(int tkey) {
BSTNode<T> current = root;
while (current != null) {
if (current.key == tkey)
return true;
if (tkey < current.key)
current = current.left;
else
current = current.right;
}
return false;
}
public boolean insert(int key, T val) {
BSTNode<T> node = new BSTNode<>(key, val);
if (root == null) {
root = node;
} else {
BSTNode<T> current = root;
while (current != null) {
if (key == current.key)
return false;
if (key < current.key) {
if (current.left == null) {
current.left = node;
return true;
}
current = current.left;
} else {
if (current.right == null) {
current.right = node;
return true;
}
current = current.right;
}
}
}
return false;
}
public String toString() {
if (root == null)
return "BST IS EMPTY";
ArrayList<BSTNode<T>> visited = new ArrayList<>();
ArrayList<BSTNode<T>> queue = new ArrayList<>();
queue.add(root);
while (!queue.isEmpty()) {
BSTNode<T> vertex = queue.remove(0);
if (vertex != null) {
queue.add(vertex.left);
queue.add(vertex.right);
}
visited.add(vertex);
}
return visited.toString();
}
}

My setter is not setting

So I am trying to implement BST (Binary Search Tree) I have made an add method which adds TreeNodes to an tree[TreeNode] array
Here is the TreeNode class where I'm trying to set the parent as well as the left and right nodes, I inspected with a debugger and I'm not sure why but it is not setting the Parent var and also it only add one or the other in the leftChild and rightChild fields.
The setter in question is this one
//set parent
public void setParent(TreeNode t)
{
this.parent = t.parent;
}
I cant understand when i call it from the PAS43DEPQ class it does not set properly.
class TreeNode implements Comparable<TreeNode>
{
private Integer value;
private TreeNode leftChild;
private TreeNode rightChild;
private TreeNode parent;
//constructors
public TreeNode(){}
public TreeNode(Integer v){this.value = v;}
public TreeNode(TreeNode t){
this.value = t.value;
this.parent = t.parent;
this.leftChild = t.leftChild;
this.rightChild = t.rightChild;
}
public TreeNode (Comparable c){this.value = (int) c;}
//set parent
public void setParent(TreeNode t)
{
this.parent = t.parent;
}
//get parent
public TreeNode getParent()
{
return this.parent;
}
//get value
public int getValue(){return value;}
//set value
public void setValue(Integer i){ this.value = i;}
//get left node
public TreeNode getLeftChild(){return leftChild;}
//get right node
public TreeNode getRightChild(){return rightChild;}
//set left child
public void setLeftChild(TreeNode t) {this.leftChild = t;}
//set right child
public void setRightChild(TreeNode t) {this.rightChild = t;}
public TreeNode find(int n)
{
//this statement runs if the current node is == the value being searched.
if(this.value == n)
return this;
//this returns values left of the root then performs a recursive call if not found
if(value < this.value && leftChild != null)
return leftChild.find(n);
//this does the same as above except looks on the right side of the root
if(rightChild != null)
return rightChild.find(n);
//this returns if value is not found
return null;
}
#Override
public int compareTo(TreeNode o)
{
if (this.value == o.value)
{
return 0;// if value equal
}
if (this.value > o.value) //if value greater
{
return 1;
}
if (this.value < o.value)
{
return -1; //if value less
}
return 99;
}
}
Here is the class where I add from:
public class PAS43DEPQ implements DEPQ
{
private TreeNode[] tree = new TreeNode[100];
int index = 0;
#Override
public Comparable inspectLeast() {
return null;
}
#Override
public Comparable inspectMost() {
return null;
}
/*
right: (2 * n) + 2
left: (2 * n) + 1
parent: (1 - n) / 2
*/
public int right()
{
return (2 * index) + 2;
}
public int left()
{
return (2 * index) + 1;
}
public int parent()
{
return Math.round((index - 1) / 2);
}
#Override
public void add(Comparable c)
{
// Root node
if (tree[0] == null) {
tree[0] = new TreeNode(c);
return;
}
//this while loop is for tree traversal
while(tree[index] != null) {
if( c.compareTo(tree[index].getValue()) == 0) {
index += right() - index;
continue;
}
if( c.compareTo(tree[index].getValue()) > 0) {
index += right() - index;
continue;
}
if( c.compareTo(tree[index].getValue()) < 0) {
index += left() - index;
continue;
}
}
//this part is for place the new node
if(tree[index] == null) {
tree[index] = new TreeNode(c);
tree[index].setParent(tree[parent()]);
if( c.compareTo(tree[index].getValue()) == 0)
tree[parent()].setRightChild(tree[index]);
if( c.compareTo(tree[index].getValue()) > 0)
tree[parent()].setRightChild(tree[index]);
if( c.compareTo(tree[index].getValue()) < 0)
tree[parent()].setLeftChild(tree[index]);
index = 0;
}
return;
}
#Override
public Comparable getLeast() {
return null;
}
#Override
public Comparable getMost() {
return null;
}
#Override
public boolean isEmpty() {
return (tree[0] == null) ? true : false;
}
#Override
public int size() {
return tree.length;
}
}
I cant seam to work out why the parent isnt being set the the the line
"tree[index].setParent(tree[parent()])"
is being called? any ides on why this is happening?

The set method should be like this
//set parent
public void setParent(TreeNode t)
{
this.parent = t;
}
This method will make TreeNode t as the parent of the Current Node referenced by this.
The statement which you are using sets parent of TreeNode t as the parent of the current node.

AVL Tree gives me O(c^n) instead of O(log n)

I've created an AVLTree in java and the add method should be of O(log n)... However my add method seems to give me a graph of O(c^n) or an exponential graph instead of a logarithmic graph. Here is the graph of running time vs input size:
Can anyone help figure out as to why this happens?
Here is the code for my AVLTree:
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
import cw1.rs10.lib.IAVLTree;
public class AVLTree<K, V> implements IAVLTree<K, V>
{
public class Node {
private K key;
private ArrayList<V> values;
private Node left, right;
private int height;
public Node(K key, V value) {
this.key = key;
this.values = new ArrayList<V>();
this.left = null;
this.right = null;
this.height = 0;
values.add(value);
}
public K getKey() {
return key;
}
public void setKey(K key) {
this.key = key;
}
public ArrayList<V> getValues() {
return values;
}
public void addValue(V value) {
values.add(value);
}
public Node getLeft() {
return left;
}
public Node getRight() {
return right;
}
public void setLeft(Node left) {
this.left = left;
}
public void setRight(Node right) {
this.right = right;
}
public int getHeight() {
return height;
}
public void setHeight(int height) {
this.height = height;
}
}
private Node rootNode;
private Comparator<K> comparator;
//Unused
public AVLTree() {
}
public AVLTree(Comparator<K> comparator) {
this.rootNode = null;
this.comparator = comparator;
}
#Override
public V add(K k, V v) {
Node n = rootNode = add(k, v, rootNode);
if(n != null)
return v;
else
return null;
}
private Node add(K key, V value, Node node) {
if(node == null)
return new Node(key, value);
if(comparator.compare(key, node.getKey()) < 0) {
node.setLeft(add(key, value, node.getLeft()));
if(height(node.getLeft()) - height(node.getRight()) == 2) {
if(comparator.compare(key, node.getLeft().getKey()) < 0)
node = rotateLeft(node);
else
node = doubleRotateLeft(node);
}
} else if(comparator.compare(key, node.getKey()) > 0) {
node.setRight(add(key, value, node.getRight()));
if(height(node.getRight()) - height(node.getLeft()) == 2) {
if(comparator.compare(key, node.getRight().getKey()) > 0)
node = rotateRight(node);
else
node = doubleRotateRight(node);
}
} else {
//Handle duplicate
node.getValues().add(value);
}
node.setHeight( Math.max(height(node.getLeft()), height(node.getRight())) + 1 );
return node;
}
#Override
public V remove(K key, V value) throws Exception {
Node node = rootNode = remove(key, value, rootNode);
if(node != null)
return value;
else
return null;
}
private Node remove(K key, V value, Node node) {
//If node with key contains one or less values, remove the whole key
//Else remove value from node with key
if(node == null) return null;
else if(comparator.compare(key, node.getKey()) < 0) {
node.setLeft(remove(key, value, node.getLeft()));
if(height(node.getLeft()) - height(node.getRight()) == 2) {
if(comparator.compare(key, node.getLeft().key) < 0)
node = rotateLeft(node);
else
node = doubleRotateLeft(node);
}
} else if(comparator.compare(key, node.getKey()) > 0) {
node.setRight(remove(key, value, node.getRight()));
if(height(node.getRight()) - height(node.getLeft()) == 2) {
if(comparator.compare(key, node.getRight().key) < 0)
node = rotateRight(node);
else
node = doubleRotateRight(node);
}
} else {
if(node.getValues().size() > 1) {
node.getValues().remove(value);
return node;
} else {
if(node.getLeft() == null && node.getRight() == null)
return null;
if(node.getLeft() == null) return node.getRight();
if(node.getRight() == null) return node.getLeft();
Node smallestNode = smallestNode(node.getRight());
node = smallestNode;
node.setRight(remove(key, value, node.getRight()));
return node;
}
}
return node;
}
#Override
public Iterator<V> find(K key) {
Node n = search(key, rootNode);
if(n != null) {
ArrayList<V> values = n.getValues();
return values.iterator();
} else {
return new ArrayList<V>().iterator();
}
}
private Node search(K key, Node node) {
while(node != null) {
if(comparator.compare(key, node.getKey()) < 0)
node = node.getLeft();
else if(comparator.compare(key, node.getKey()) > 0)
node = node.getRight();
else
return node;
}
return null;
}
#Override
public Iterator<V> removeAll(K key) {
Node n = search(key, rootNode);
ArrayList<V> values = n.getValues();
try {
remove(n.getKey(), null);
} catch (Exception e) {
e.printStackTrace();
}
return values.iterator();
}
#Override
public Iterator<V> listAll() {
ArrayList<V> entries = new ArrayList<V>();
listAll(rootNode, entries);
return entries.iterator();
}
private void listAll(Node n, ArrayList<V> entries) {
if(n != null) {
listAll(n.getLeft(), entries);
entries.addAll(n.getValues());
listAll(n.getRight(), entries);
}
}
#Override
public int height() {
return height(rootNode);
}
//Custom Methods
/**
* A method to test if the tree is logically empty
*
* #return true if empty, false if not
*/
public boolean isEmpty() {
return rootNode == null;
}
/**
* Logically empties the tree by setting the rootNode to null
*/
public void empty() {
rootNode = null;
}
public void inOrderTraversal(Node node) {
if(node != null) {
inOrderTraversal(node.getLeft());
System.out.print(node.getKey() + ", ");
inOrderTraversal(node.getRight());
}
}
public int height(Node node) {
if(node == null) return -1;
else return node.height;
}
public Node getRootNode() {
return rootNode;
}
public Node smallestNode(Node node) {
if(node.getLeft() == null)
return node;
return smallestNode(node.getLeft());
}
private Node rotateLeft(Node node2) {
Node node1 = node2.getLeft();
node2.setLeft(node1.getRight());
node1.setRight(node2);
node2.setHeight(Math.max(height(node2.getLeft()), height(node2.getRight())) + 1);
node1.setHeight(Math.max(height(node1.getLeft()), node2.getHeight()) + 1);
return node1;
}
private Node rotateRight(Node node1) {
Node node2 = node1.getRight();
node1.setRight(node2.getLeft());
node2.setLeft(node1);
node1.setHeight(Math.max(height(node1.getLeft()), height(node1.getRight())) + 1);
node2.setHeight(Math.max(height(node2.getRight()), node1.getHeight()) + 1);
return node2;
}
private Node doubleRotateLeft(Node node3) {
node3.setLeft(rotateRight(node3.getLeft()));
return rotateLeft(node3);
}
private Node doubleRotateRight(Node node1) {
node1.setRight(rotateLeft(node1.getRight()));
return rotateRight(node1);
}
}
The interface for my AVLTree:
import java.util.Iterator;
public interface IAVLTree<K,V>
{
public V add(K k, V v);
public V remove(K k, V v);
public Iterator<V> removeAll(K k);
public Iterator<V> find(K k);
public Iterator<V> listAll();
public int height();
}
And finally, my testing code:
public class AVLTest
{
private static long startTime, endTime;
private static int amountOfCommands = 10000;
public static void main(String[] args) {
AVLTree<String, Integer> tree = new AVLTree<String, Integer>(String.CASE_INSENSITIVE_ORDER);
try {
startTime = System.currentTimeMillis();
for (int i = 1; i <= amountOfCommands; i++) {
String key = "K" + i;
tree.add(key, i);
}
endTime = System.currentTimeMillis();
} catch(Exception e) {
e.printStackTrace();
}
long runningTime = endTime - startTime;
System.out.println("Running Time: " + runningTime + "ms\nNo. of Commands: " + amountOfCommands);
}
}

You are measuring it wrong. Your test code measures the time to add all of the elements in the tree, instead of just one.
startTime = System.currentTimeMillis();
for (int i = 1; i <= amountOfCommands; i++) {
String key = "K" + i;
tree.add(key, i);
}
endTime = System.currentTimeMillis();
What you want to measure is the time it takes to add one node to the tree as a function of the number of nodes already in the tree.
for (int i = 1; i < amountOfCommands; i++) { // note the < instead of <=
String key = "K" + i;
tree.add(key, i);
}
String key = "K" + amountOfCommands;
startTime = System.currentTimeMillis();
tree.add(key, amountOfCommands);
endTime = System.currentTimeMillis();
Of course you can run your test more efficiently if you reuse the same tree for all measurements. I'll leave it to you.

QuickSort with Double Linked List

I am having trouble with my swap method in the Quick Sort program. I'm implementing it from a QuickSort method that sorts arrays. Here I take in a file with an integer on each line, it puts the number in a doubly linked list and then sorts the list and outputs to a new file. I need help with the swap method and what else I need to add or do to make it work properly. Any advise would help and examples are best. Thank you
//swap A[pos1] and A[pos2]
public static void swap(DList A, int pos1, int pos2){
int temp = A.get(pos1);
A[pos1] = A[pos2];
A[pos2] = temp;
}
My entire program for quicksort looks like this:
import java.util.*;
import java.io.*;
public class Test_QuickSort{
private static Scanner input = new Scanner(System.in);
private static DList list = new DList();
public static void main(String[] args) throws FileNotFoundException
{
input = new Scanner(new File("data.txt"));
while (input.hasNext())
{
String s = input.nextLine();
DNode g = new DNode(Integer.parseInt(s));
list.addLast(g);
}
//int[] A = {1,4,6,2};
QuickSort(list, 0, list.size()-1);
//for(int i = 0; i < A.length; i++)
// System.out.print(A[i] + " ");
}
public static void QuickSort(DList A, int left, int right){
if(left >= right)
return;
int pivot_index = partition(A, left, right);
QuickSort(A, left, pivot_index - 1);
QuickSort(A, pivot_index + 1, right);
}
public static int partition(DList A, int left, int right){
int pivot = A.get(right);
int index = left;
for(int i = left; i < right; i++){
if(A.get(i) <= pivot){
swap(A, index, i);
index ++;
}
}
swap(A, index, right);
return index;
}
//swap A[pos1] and A[pos2]
public static void swap(DList A, int pos1, int pos2){
int temp = A.get(pos1);
A[pos1] = A[pos2];
A[pos2] = temp;
}
}
My DList Method looks like this:
class DNode {
protected int element; // String element stored by a node
protected DNode next, prev; // Pointers to next and previous nodes
public DNode(int e)
{
element = e;
prev = null;
next = null;
}
public DNode()
{
element = 0;
next = null;
prev = null;
}
public DNode(int e, DNode p, DNode n) {
element = e;
prev = p;
next = n;
}
public int getElement() {
return element; }
public DNode getPrev() {
return prev; }
public DNode getNext() {
return next; }
public void setElement(int newElem) { element = newElem; }
public void setPrev(DNode newPrev) { prev = newPrev; }
public void setNext(DNode newNext) { next = newNext; }
}
public class DList {
protected int size;
protected DNode header, trailer;
public DList() {
size = 0;
header = new DNode(0, null, null);
trailer = new DNode(0, header, null);
header.setNext(trailer);
}
public int size() {
return size; }
public boolean isEmpty() {
return (size == 0); }
public DNode getFirst() throws IllegalStateException {
if (isEmpty()) throw new IllegalStateException("List is empty");
return header.getNext();
}
public DNode getLast() throws IllegalStateException {
if (isEmpty()) throw new IllegalStateException("List is empty");
return trailer.getPrev();
}
public DNode getPrev(DNode v) throws IllegalArgumentException {
if (v == header) throw new IllegalArgumentException
("Cannot move back past the header of the list");
return v.getPrev();
}
public int get(int pos)
{
DNode current = new DNode();
for(int i = 0; i <= pos && current != null; i++)
{
if(pos == 0){
current = header;
}
else{
current = current.next;
break;
}
}
return current.element;
}
public DNode getNext(DNode v) throws IllegalArgumentException {
if (v == trailer) throw new IllegalArgumentException
("Cannot move forward past the trailer of the list");
return v.getNext();
}
public void addBefore(DNode v, DNode z) throws IllegalArgumentException {
DNode u = getPrev(v); // may throw an IllegalArgumentException
z.setPrev(u);
z.setNext(v);
v.setPrev(z);
u.setNext(z);
size++;
}
public void addAfter(DNode v, DNode z) {
DNode w = getNext(v); // may throw an IllegalArgumentException
z.setPrev(v);
z.setNext(w);
w.setPrev(z);
v.setNext(z);
size++;
}
public void addFirst(DNode v) {
addAfter(header, v);
}
public void addLast(DNode v) {
addBefore(trailer, v);
}
public boolean hasPrev(DNode v) {
return v != header; }
public boolean hasNext(DNode v) {
return v != trailer; }
public String toString() {
String s = "[";
DNode v = header.getNext();
while (v != trailer) {
s += v.getElement();
v = v.getNext();
if (v != trailer)
s += ",";
}
s += "]";
return s;
}
}

The reason you are always retrieving the same element in DList.get is that you stop looping after the first iteration. Simply remove the break-statement, and the loop should work as intended.
public int get(int pos)
{
DNode current = new DNode();
for(int i = 0; i <= pos && current != null; i++)
{
if(pos == 0){
current = header;
}
else{
current = current.next;
// break; <-- remove this
}
}
return current.element;
}
Side note: You could get rid of the if-statement, if you would initialize current to header:
public int get(int pos)
{
DNode current = header;
for(int i = 1; i <= pos && current != null; i++)
{
current = current.next;
}
return current.element;
}
Now regarding your swap-method: As already stated, you try to treat the instance of DList as an array by trying to dereference an element using square-brackets. Instead, you should implement a method in DList that allows setting an element at a certain position. For example:
public void setAt(int pos, int value){
DNode current = header;
for(int i = 1; i <= pos && current != null; i++){
current = current.next;
}
if(current != null)
current.setElement(value);
else
throw new IndexOutOfBoundsException();
}
Now you can change your swap-method to:
public static void swap(DList a, int pos1, int pos2){
int temp = a.get(pos1);
a.setAt(pos1, a.get(pos2));
a.setAt(pos2, temp);
}

depth first search algorithm working

The depth first search does not function properly. Honestly I am not sure if this is the current way of implementation. I am new to implementing graph and want to be a pro at it.
Where am I going wrong and I do not understand how do I print the elements either in the dfs() function so I can know how dfs should be like.
Would getter & setter method for child elements is recommended?
Here is my code:
package graphs;
public enum State {
Unvisited,Visiting,Visited;
}
package graphs;
public class Node {
public Node[] adjacent;
public int adjacentCount;
private String vertex;
public graphs.State state;
public Node(String vertex)
{
this.vertex = vertex;
}
public Node(String vertex, int adjacentlen)
{
this.vertex = vertex;
adjacentCount = 0;
adjacent = new Node[adjacentlen];
}
public void addAdjacent(Node adj)
{
if(adjacentCount < 30)
{
this.adjacent[adjacentCount] = adj;
adjacentCount++;
}
}
public Node[] getAdjacent()
{
return adjacent;
}
public String getVertex()
{
return vertex;
}
}
public class Graph {
public int count; // num of vertices
private Node vertices[];
public Graph()
{
vertices = new Node[8];
count = 0;
}
public void addNode(Node n)
{
if(count < 10)
{
vertices[count] = n;
count++;
}
else
{
System.out.println("graph full");
}
}
public Node[] getNode()
{
return vertices;
}
}
package graphs;
import java.util.Stack;
import graphs.State;
public class Dfs {
/**
* #param args
*/
static boolean visited[];
public void dfs(Node root)
{
if(root == null) return;
Stack<Node> s = new Stack<Node>();
s.push(root);
root.state = State.Visited;
System.out.println("root:"+root.getVertex() + "\t");
while(!s.isEmpty())
{
Node u = s.pop();
for(Node n: u.getAdjacent())
{
if(n.state != State.Visited)
{
dfs(n);
}
}
}
}
public static Graph createNewGraph()
{
Graph g = new Graph();
Node[] temp = new Node[8];
temp[0] = new Node("A", 3);
temp[1] = new Node("B", 3);
temp[2] = new Node("C", 1);
temp[3] = new Node("D", 1);
temp[4] = new Node("E", 1);
temp[5] = new Node("F", 1);
temp[0].addAdjacent(temp[1]);
temp[0].addAdjacent(temp[2]);
temp[0].addAdjacent(temp[3]);
temp[1].addAdjacent(temp[0]);
temp[1].addAdjacent(temp[4]);
temp[1].addAdjacent(temp[5]);
temp[2].addAdjacent(temp[0]);
temp[3].addAdjacent(temp[0]);
temp[4].addAdjacent(temp[1]);
temp[5].addAdjacent(temp[1]);
for (int i = 0; i < 7; i++)
{
g.addNode(temp[i]);
}
return g;
}
public static void main(String[] args) {
Graph g = createNewGraph();
Dfs s = new Dfs();
//Node[] n = g.getNode();
s.dfs(g.getNode()[0]);
}
}

You don't need stack here. Only recursion:
public void dfs(Node node) {
if (node == null) {
return;
}
System.out.println("Node: " + node.getVertex());
node.state = State.Visited;
for (Node n : node.getAdjacent()) {
if (n.state != State.Visited) {
dfs(n);
}
}
}
UPDATE
To check path existence:
public boolean isPath(Graph graph, Node start, Node target) {
for (Node node : graph.getNode()) {
if (node != null) {
node.state = State.Unvisited;
}
}
dfs(start);
return target.state == State.Visited;
}