We Keep Coding

Using Depth-First Search in JAVA program instead of Breadth-First Search

I have a JAVA program where I am creating graphs and I have a Breadth-First Search but I would like to change it to Depth First Search. What changes should I make in a code? Thanks for help in advance.
public class ConnectedComponents
{
static final int MAXV = 100;
static boolean processed[] = new boolean[MAXV];
static boolean discovered[] = new boolean[MAXV];
static int parent[] = new int[MAXV];
static void bfs(CCGraph g, int start)
{
Queue<Integer> q = new LinkedList<Integer>();
int i, v;
q.offer(start);
discovered[start] = true;
while (!q.isEmpty())
{
v = q.remove();
process_vertex(v);
processed[v] = true;
for (i = g.degree[v] - 1; i >= 0; i--)
{
if (!discovered[g.edges[v][i]])
{
q.offer(g.edges[v][i]);
discovered[g.edges[v][i]] = true;
parent[g.edges[v][i]] = v;
}
}
}
}

I think you should understand the difference between depth first search and breadth first search. The code for depth first search goes as follows:
public class ConnectedComponents
{
static final int MAXV = 100;
static boolean processed[] = new boolean[MAXV];
static boolean discovered[] = new boolean[MAXV];
static int parent[] = new int[MAXV];
static void dfs(CCGraph g, int vertex)
{
discovered[vertex] = true;
for (i = g.degree[vertex] - 1; i >= 0; i--)
{
if (!discovered[g.edges[vertex][i]])
{
parent[g.edges[v][i]]=vertex;
dfs(g.edges[v][i]]);
}
}
}
}

The basic difference is the order by which vertexes are tested. While BFS uses queue (FIFO: First In First Out), DFS use stack (LIFO: Last In First Out).
You could implement stack using LinkedList:
LinkedList<Integer> stack = new LinkedList<Integer>();
stack.pop(); //returns the top of the stack
For more information please post mcve including test data.

Full code of the program. The goal is to change bfs to dfs.
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
class CCGraph
{
static final int MAXV = 100;
static final int MAXDEGREE = 50;
public int edges[][] = new int[MAXV + 1][MAXDEGREE];
public int degree[] = new int[MAXV + 1];
public int nvertices;
public int nedges;
CCGraph()
{
nvertices = nedges = 0;
for (int i = 1; i <= MAXV; i++)
degree[i] = 0;
}
void read_CCGraph(boolean directed)
{
int x, y;
Scanner sc = new Scanner(System.in);
System.out.println("Enter the number of vertices: ");
nvertices = sc.nextInt();
System.out.println("Enter the number of edges: ");
int m = sc.nextInt();
System.out.println("Enter the edges: <from> <to>");
for (int i = 1; i <= m; i++)
{
x = sc.nextInt();
y = sc.nextInt();
insert_edge(x, y, directed);
}
sc.close();
}
void insert_edge(int x, int y, boolean directed)
{
if (degree[x] > MAXDEGREE)
System.out.printf(
"Warning: insertion (%d, %d) exceeds max degree\n", x, y);
edges[x][degree[x]] = y;
degree[x]++;
if (!directed)
insert_edge(y, x, true);
else
nedges++;
}
void print_CCGraph()
{
for (int i = 1; i <= nvertices; i++)
{
System.out.printf("%d: ", i);
for (int j = degree[i] - 1; j >= 0; j--)
System.out.printf(" %d", edges[i][j]);
System.out.printf("\n");
}
}
}
public class ConnectedComponents
{
static final int MAXV = 100;
static boolean processed[] = new boolean[MAXV];
static boolean discovered[] = new boolean[MAXV];
static int parent[] = new int[MAXV];
static void bfs(CCGraph g, int start)
{
LinkedList<Integer> q = new LinkedList<Integer>();
int i, v;
q.offer(start);
discovered[start] = true;
while (!q.isEmpty())
{
v = q.remove();
process_vertex(v);
processed[v] = true;
for (i = g.degree[v] - 1; i >= 0; i--)
{
if (!discovered[g.edges[v][i]])
{
q.offer(g.edges[v][i]);
discovered[g.edges[v][i]] = true;
parent[g.edges[v][i]] = v;
}
}
}
}
static void initialize_search(CCGraph g)
{
for (int i = 1; i <= g.nvertices; i++)
{
processed[i] = discovered[i] = false;
parent[i] = -1;
}
}
static void process_vertex(int v)
{
System.out.printf(" %d", v);
}
static void connected_components(CCGraph g)
{
int c;
initialize_search(g);
c = 0;
for (int i = 1; i <= g.nvertices; i++)
{
if (!discovered[i])
{
c++;
System.out.printf("Component %d:", c);
bfs(g, i);
System.out.printf("\n");
}
}
}
static public void main(String[] args)
{
CCGraph g = new CCGraph();
g.read_CCGraph(false);
g.print_CCGraph();
connected_components(g);
}
}

How do i not override an array when i iterate on it the second time

How can I make the second iteration use the first array "poqet" to switch their positions from true to false, but without changing their state when the first iteration made them all true?
public class Dhoma {
public static void main(String[] args) {
boolean poqet[] = new boolean[100];
int njerezit[] = new int[100];
int count = 0;
int nrRendorP = 0;
int nrRendorN = 0;
for (int i = 0; i < njerezit.length; i++) {
nrRendorN++;
for (int k = 0; k < poqet.length; k++) {
nrRendorP++;
if (nrRendorP == 100) {
nrRendorP = 0;
}
poqet[i] = Switch(nrRendorN, nrRendorP);
System.out.println(k + " " + poqet[i]);
}
}
// System.out.println("Jane te ndezura "+ count);
}
private static boolean Switch(int nr, int n) {
if (n % nr == 0) {
return true;
}
return false;
}
}

How can I rewrite this code to use object oriented programming?

public class stackOverflow
{
public static void main (String args[])
{
int maxNumbers = 100;
int numbers[] = new int[maxNumbers];
for (int k = 0; k < numbers.length; k++)
numbers[k] = getRandom(10,99);
for (int k = 0; k < numbers.length; k++)
System.out.print(numbers[k] + " ");
System.out.println();
}
public static int getRandom(int min, int max)
{
int range = max - min + 1;
double rndDouble = Math.random() * range;
int rndInt = (int) rndDouble + min;
return rndInt;
}
}
The provided program works correctly, but I didn't write it very neatly/professionally. Can anyone give me some guidance on how I could rewrite this to implement Object Oriented Programming under a List class?

This can be an alternative...
class Numbers {
int maxNumbers;
int numbers[];
public Numbers(int maxNumbers) {
// TODO Auto-generated constructor stub
this.maxNumbers = maxNumbers;
this.numbers = new int[maxNumbers];
}
public int getRandom(int min, int max) {
int range = max - min + 1;
double rndDouble = Math.random() * range;
int rndInt = (int) rndDouble + min;
return rndInt;
}
}
public class StackOverflow {
public static void main(String [] args) {
Numbers numbers = new Numbers(100);
for (int k = 0; k < numbers.numbers.length; k++)
numbers.numbers[k] = numbers.getRandom(10,99);
for (int k = 0; k < numbers.numbers.length; k++)
System.out.print(numbers.numbers[k] + " ");
}
}
Or something like this...
public class StackOverflow {
static int maxNumbers = 100;
static int numbers[] = new int[maxNumbers];
public static void main (String args[]) {
StackOverflow stackOverflow = new StackOverflow();
for (int k = 0; k < numbers.length; k++)
numbers[k] = stackOverflow.getRandom(10,99);
for (int k = 0; k < numbers.length; k++)
System.out.print(numbers[k] + " ");
System.out.println();
}
public int getRandom(int min, int max) {
int range = max - min + 1;
double rndDouble = Math.random() * range;
int rndInt = (int) rndDouble + min;
return rndInt;
}
}
Friend, There are a numbers of alternatives.

import java.util.ArrayList;
import java.util.List;
int maxNumbers = 100;
List<Integer> numbers = new ArrayList<Integer>();
for (int k = 0; k < maxNumbers; k++)
numbers.add( getRandom(10,99) );
System.out.println(numbers.toString());
is this kind of what you wanted?

A Number of ways to write this structured linear program in oops. Here is my version..
public class stackOverflow
{
int numbers[];
public stackOverflow(){ //assuming default constructor will provide a 100 length array
int maxNumbers = 100;
this.numbers[] = new int[maxNumbers];
}
public stackOverflow(int length){ //Provide a length according to your need.
this.numbers[] = new int[length];
}
private void fillNumberArrayWithRandomNumber(){
for (int k = 0; k < this.numbers.length; k++)
numbers[k] = this.getRandom(10,99);
}
private void printAllNumbersInArray(){
for (int k = 0; k < this.numbers.length; k++)
System.out.print(numbers[k] + " ");
System.out.println();
}
public static void main (String args[])
{
stackOverflow obj1 = new stackOverflow(); //default Constructor will call with array lenth 100
obj1.fillNumberArrayWithRandomNumber();
obj1.printAllNumbersInArray();
stackOverflow obj2 = new stackOverflow(50); //overloaded Constructor will Call with array length 50
obj2.fillNumberArrayWithRandomNumber();
obj2.printAllNumbersInArray();
}
public int getRandom(int min, int max)
{
int range = max - min + 1;
double rndDouble = Math.random() * range;
int rndInt = (int) rndDouble + min;
return rndInt;
}
}
Another Way to separate the business logic to the other class. and calling it From Others.
public class GenerateRandomNumbers
{
int numbers[];
public GenerateRandomNumbers(){ //assuming default constructor will provide a 100 length array
int maxNumbers = 100;
this.numbers[] = new int[maxNumbers];
}
public GenerateRandomNumbers(int length){ //Provide a length according to your need.
this.numbers[] = new int[length];
}
public void fillNumberArrayWithRandomNumber(){
for (int k = 0; k < this.numbers.length; k++)
numbers[k] = this.getRandom(10,99);
}
public void printAllNumbersInArray(){
for (int k = 0; k < this.numbers.length; k++)
System.out.print(numbers[k] + " ");
System.out.println();
}
private int getRandom(int min, int max)
{
int range = max - min + 1;
double rndDouble = Math.random() * range;
int rndInt = (int) rndDouble + min;
return rndInt;
}
}
class stackOverflow {
public static void main (String args[])
{
GenerateRandomNumbers obj1 = new GenerateRandomNumbers(); //default Constructor will call with array lenth 100
obj1.fillNumberArrayWithRandomNumber();
obj1.printAllNumbersInArray();
GenerateRandomNumbers obj2 = new GenerateRandomNumbers(50); //overloaded Constructor will Call with array length 50
obj2.fillNumberArrayWithRandomNumber();
obj2.printAllNumbersInArray();
}
}

You could do it with Random (and nextInt(int)), and in Java 8+ a lambda expression. That might look something like
int maxNumbers = 100;
int min = 10;
int max = 99;
Random rand = new Random();
List<Integer> al = new ArrayList<>();
IntStream.range(0, maxNumbers).forEach(x -> {
al.add(rand.nextInt(max - min) + min);
});
al.stream().forEach(x -> {
System.out.printf("%d%n", x);
});

Using a list:
The following is an example class that utilizes an object list to hold each number. You can either declare a max size with the parameterized constructor or you could use the default constructor which sets it to 100.
The setNumbers method will never execute more than once (by checking the size to the max size) so that the list never gets larger than the max size. Also, you could add parameters to the setNumbers method so that you could choose the range that each random number would be between rather than just 10-99. The getNumbers method will return the list object which contains all of the numbers.
import java.util.ArrayList;
import java.util.List;
public class Example {
int maxNumbers;
List<Object> list = new ArrayList<Object>();
public Example(){
this.maxNumbers = 100;
}
public Example( int max){
this.maxNumbers = max;
}
private int getRandom(int min, int max)
{
int range = max - min + 1;
double rndDouble = Math.random() * range;
int rndInt = (int) rndDouble + min;
return rndInt;
}
public List<Object> getNumbers(){
return this.list;
}
public void setNumbers(){
if (list.size() >= maxNumbers){
return;
}
for (int k = 0; k < this.maxNumbers; k++)
this.list.add(getRandom(10,99));
}
}
Here is an example for a driver class.
public class ExampleDriver
{
public static void main (String args[])
{
//Instantiates the object using the default constructor.
Example test = new Example();
//Generates the numbers within the list.
test.setNumbers();
//Stores the returned list from getNumbers() to exampleList
List<Object> exampleList = test.getNumbers();
}
}

You can create your own RandomList which extends ArrayList<Integer>:
public class RandomList extends ArrayList<Integer> {
private int size;
private int min;
private int max;
public RandomList(int size, int min, int max) {
super(size);
this.size = size;
this.min = min;
this.max = max;
}
/**
* Populate list with entries between min and max
*/
public void populate() {
Random rand = new Random();
for (int t = 0; t < size; t++) {
this.add(rand.nextInt(max - min) + min);
}
}
public String toString() {
StringBuilder sb = new StringBuilder();
for (Integer i:this) {
sb.append(i).append(" ");
}
return sb.toString();
}
public static void main (String [] args) {
RandomList randomList = new RandomList(100, 10, 99);
randomList.populate();
System.out.println(randomList);
}
}

You could implement your own List class. For that you should define a Node, a List class (which will contain nodes) and a Service that will be responsible to create the random numbers.
This service will be represented in a singleton (a class that cannot be instantiated by any other class).
public class MyRandom {
private static MyRandom rdn = new MyRandom();
private MyRandom() {}
public static MyRandom getInstance() {
return rdn;
}
public int getRandom(int min, int max) {
int range = max - min + 1;
double rndDouble = Math.random() * range;
int rndInt = (int) rndDouble + min;
return rndInt;
}
}
The Node will only contain a value (the random number) and a reference to the next node. This is the Node class
public class MyNode {
private final int value;
private MyNode next;
public MyNode(int value) {
this.value = value;
next = null;
}
public void setNext(MyNode next) {
this.next = next;
}
public int getValue() {
return value;
}
public MyNode getNext() {
return next;
}
}
The List class will contain a reference to the root node, which will also be responsible to add new nodes to the list.
Keep in mind that you could use Generics as well.
public final class MyList {
private MyNode root;
public MyList(int maxNumber) {
for (int i = 0; i < maxNumber; i++) {
addNode(MyRandom.getInstance().getRandom(0, 99));
}
}
public boolean isEmpty() {
return root == null;
}
public void addNode(int value) {
if (isEmpty()) {
root = new MyNode(value);
} else {
MyNode aux = root;
while (aux.getNext() != null)
aux = aux.getNext();
aux.setNext(new MyNode(value));
}
}
public void printList() {
if (!isEmpty()) {
MyNode aux = root;
while (aux.getNext() != null) {
System.out.println(aux.getValue());
aux = aux.getNext();
}
System.out.println(aux.getValue());
}
}
}
And the Main must only instantiate the MyList class and call the printList to show the list.
public class Main {
public static void main(String[] args) {
MyList lista = new MyList(10);
lista.printList();
}
}
Hope this helps you.

I need help linking my stack Class into my TestBed class

import java.util.Random;
public class TestBed {
public static void main(String a[]) {
// creating the array
int[] array = new int[100];
Random random = new Random();
// changing the variable of my clone array for reference
int[] arr = cloneArray(array);
for (int i1 = 0; i1 < 100; i1++)
array[i1] = random.nextInt(100) + 1;
// print out of bubble sort before and after the sort
System.out
.println("***********************Bubble Sort ****************************");
arr = cloneArray(array);
System.out.println("Values Before the sort:\n");
printArray(arr);
System.out.println();
bubble_srt(arr);
System.out.print("Values after the sort:\n");
printArray(arr);
// print out of selection sort before and after the sort
System.out.println();
System.out
.println("********************Selection Sort*****************************");
System.out.println(" Selection Sort\n\n");
arr = cloneArray(array);
System.out.println("Values Before the sort:\n");
printArray(arr);
System.out.println();
selection_srt(arr);
System.out.print("Values after the sort:\n");
printArray(arr);
System.out.println();
Stack stack = new Stack();
}
public static int[] buildArray(int bound) {
return null;
}
// clone array as a data type
public static int[] cloneArray(int[] data) {
return (int[]) data.clone();
}
// print array as a data type
public static void printArray(int[] data) {
// while there are still numbers left in the array print out the next
// value
for (int i = 0; i < data.length; i++)
System.out.print(data[i] + " ");
}
// bubble syntax
public static void bubble_srt(int a[]) {
int t = 0;
for (int i = 0; i < a.length; i++) {
for (int j = 1; j < (a.length - i); j++) {
if (a[j - 1] > a[j]) {
t = a[j - 1];
a[j - 1] = a[j];
a[j] = t;
}
}
}
}
// selection syntax
public static void selection_srt(int array[]) {
for (int x = 0; x < array.length; x++) {
int index_of_min = x;
for (int y = x; y < array.length; y++) {
if (array[index_of_min] > array[y]) {
index_of_min = y;
}
}
int temp = array[x];
array[x] = array[index_of_min];
array[index_of_min] = temp;
}
}
}
From here i have to link my stack class but i don't know how to get the 2 classes together correctly im new to programming and my school threw me into a java class that was to high for me and now im stuck 5 weeks in.
public class Stack {
Node top;
int size;
public Stack() {
top = null;
size = 0;
}
public int pop() {
if (top != null) {
int item = top.data;
top = top.next;
size--;
return item;
}
return -1;
}
public void push(int data) {
Node t = new Node(data);
t.next = this.top;
this.top = t;
size++;
}
public boolean isEmpty() {
return size <= 0;
}
public int getSize() {
return size;
}
public int peek() {
return top.data;
}
public void printStack() {
Node n = this.top;
int pos = this.getSize();
while (pos > 0) {
System.out.println("Position: " + pos + " Element: " + n.data);
if (pos > 0) {
n = n.next;
}
pos--;
}
}
}
class Node {
public int data;
public Node next;
Node(int d) {
data = d;
next = null;
}
public int getData() {
return data;`enter code here`
}`enter code here`
{
Stack s = new Stack();
s.push(9);
s.push(2);
s.push(7);
s.push(3);
s.push(6);
s.push(4);
s.push(5);
System.out.println("Size is: " + s.getSize());
// s.printStack();
int size = s.getSize();
for (int i = 0; i < size; i++) {
System.out.print(s.pop() + " ");
}
}
}

At the beginning of Stack class file, create a package name, eg:
package com.example.testcode;
Then in your TestBed class file, import your Stack class from the package, eg:
import com.example.testcode.Stack;

Inheritance problems in Java

I have some problems with getting inheritance to work. In the parent class, the array Coefficients is private. I have some access methods but I still can't get it to work.
import java.util.ArrayList;
public class Poly {
private float[] coefficients;
public static void main (String[] args){
float[] fa = {3, 2, 4};
Poly test = new Poly(fa);
}
public Poly() {
coefficients = new float[1];
coefficients[0] = 0;
}
public Poly(int degree) {
coefficients = new float[degree+1];
for (int i = 0; i <= degree; i++)
coefficients[i] = 0;
}
public Poly(float[] a) {
coefficients = new float[a.length];
for (int i = 0; i < a.length; i++)
coefficients[i] = a[i];
}
public int getDegree() {
return coefficients.length-1;
}
public float getCoefficient(int i) {
return coefficients[i];
}
public void setCoefficient(int i, float value) {
coefficients[i] = value;
}
public Poly add(Poly p) {
int n = getDegree();
int m = p.getDegree();
Poly result = new Poly(Poly.max(n, m));
int i;
for (i = 0; i <= Poly.min(n, m); i++)
result.setCoefficient(i, coefficients[i] + p.getCoefficient(i));
if (i <= n) {
//we have to copy the remaining coefficients from this object
for ( ; i <= n; i++)
result.setCoefficient(i, coefficients[i]);
} else {
// we have to copy the remaining coefficients from p
for ( ; i <= m; i++)
result.setCoefficient(i, p.getCoefficient(i));
}
return result;
}
public void displayPoly () {
for (int i=0; i < coefficients.length; i++)
System.out.print(" "+coefficients[i]);
System.out.println();
}
private static int max (int n, int m) {
if (n > m)
return n;
return m;
}
private static int min (int n, int m) {
if (n > m)
return m;
return n;
}
public Poly multiplyCon (double c){
int n = getDegree();
Poly results = new Poly(n);
for (int i =0; i <= n; i++){ // can work when multiplying only 1 coefficient
results.setCoefficient(i, (float)(coefficients[i] * c)); // errors ArrayIndexOutOfBounds for setCoefficient
}
return results;
}
public Poly multiplyPoly (Poly p){
int n = getDegree();
int m = p.getDegree();
Poly result = null;
for (int i = 0; i <= n; i++){
Poly tmpResult = p.multiByConstantWithDegree(coefficients[i], i); //Calls new method
if (result == null){
result = tmpResult;
} else {
result = result.add(tmpResult);
}
}
return result;
}
public void leadingZero() {
int degree = getDegree();
if ( degree == 0 ) return;
if ( coefficients[degree] != 0 ) return;
// find the last highest degree with non-zero cofficient
int highestDegree = degree;
for ( int i = degree; i <= 0; i--) {
if ( coefficients[i] == 0 ) {
highestDegree = i -1;
} else {
// if the value is non-zero
break;
}
}
float[] newCoefficients = new float[highestDegree + 1];
for ( int i=0; i<= highestDegree; i++ ) {
newCoefficients[i] = coefficients[i];
}
coefficients = newCoefficients;
}
public Poly differentiate(){
int n = getDegree();
Poly newResult = new Poly(n);
if (n>0){ //checking if it has a degree
for (int i = 1; i<= n; i++){
newResult.coefficients[i-1]= coefficients[i] * (i); // shift degree by 1 and multiplies
}
return newResult;
} else {
return new Poly(); //empty
}
}
public Poly multiByConstantWithDegree(double c, int degree){ //used specifically for multiply poly
int oldPolyDegree = this.getDegree();
int newPolyDegree = oldPolyDegree + degree;
Poly newResult = new Poly(newPolyDegree);
//set all coeff to zero
for (int i = 0; i<= newPolyDegree; i++){
newResult.coefficients[i] = 0;
}
//shift by n degree
for (int j = 0; j <= oldPolyDegree; j++){
newResult.coefficients[j+degree] = coefficients[j] * (float)c;
}
return newResult;
}
}
Can anyone help me fix my Second class that inherits from the one above? I cant seem to get my multiply and add methods for the second class to work properly.
public class QuadPoly extends Poly
{
private float [] quadcoefficients;
public QuadPoly() {
super(2);
}
public QuadPoly(int degree) {
super(2);
}
public QuadPoly(float [] f) {
super(f);
if (getDegree() > 2){
throw new IllegalArgumentException ("Must be Quadratic");
}
}
public QuadPoly(Poly p){
super(p.coefficients);
for (int i = 0; i < coefficients.length; i++){
if (coefficients[i] < 0){
throw new Exception("Expecting positive coefficients!");
}
}
}
// public QuadPoly(Poly p){
// super(p.coefficients);
//}
public QuadPoly addQuad (QuadPoly p){
return new QuadPoly(super.add(p));
}
public QuadPoly multiplyQuadPoly (QuadPoly f){
if (quadcoefficients.length > 2){
throw new IllegalArgumentException ("Must be Quadratic");
}
return new QuadPoly(super.multiplyPoly(f));
}

I would make the coefficients protected or use an accessor method.
I wouldn't throw a plain checked Exception. An IllegalArgumentException would be a better choice.
What is quadcoefficients? They don't appear to be set anywhere.

You put coefficients private. I wouldn't change this but I would add a getter method into Poly class:
public class Poly {
//somecode here
public float[] getCoefficients(){
return this.coefficients;
}
}
Then I would use it by the getter method in other code;
public QuadPoly(Poly p){
super(p.getCoefficients);
//some more code here
}
Even if you make coefficient protected, you are trying to reach coefficients field of another Object, which is a parameter. So it is not related to inheritance and the problem.