mirror of
https://github.com/TheAlgorithms/Java.git
synced 2026-03-13 08:40:43 +08:00
Improved files and folders name conventions and moved lost files to Misc folder
This commit is contained in:
DESKTOP-0VAEMFL\joaom
62
Data Structures/Graphs/BFS.java
Normal file
62
Data Structures/Graphs/BFS.java
Normal file
@@ -0,0 +1,62 @@
|
||||
import java.util.*;
|
||||
|
||||
/**
|
||||
* Implementation of a Breadth First Search
|
||||
*
|
||||
* @author Unknown
|
||||
*
|
||||
*/
|
||||
public class bfs{
|
||||
|
||||
/**
|
||||
* The BFS implemented in code to use.
|
||||
*
|
||||
* @param a Structure to perform the search on a graph, adjacency matrix etc.
|
||||
* @param vertices The vertices to use
|
||||
* @param source The Source
|
||||
*/
|
||||
public static void bfsImplement(byte [][] a,int vertices,int source){ //passing adjacency matrix and no of vertices
|
||||
byte []b=new byte[vertices]; //flag container containing status of each vertices
|
||||
Arrays.fill(b,(byte)-1); //status initialization
|
||||
/* code status
|
||||
-1 = ready
|
||||
0 = waiting
|
||||
1 = processed */
|
||||
|
||||
Stack st = new Stack(vertices); //operational stack
|
||||
st.push(source); //assigning source
|
||||
while(!st.isEmpty()){
|
||||
b[st.peek()]=(byte)0; //assigning waiting status
|
||||
System.out.println(st.peek());
|
||||
int pop=st.peek();
|
||||
b[pop]=(byte)1; //assigning processed status
|
||||
st.pop(); //removing head of the queue
|
||||
for(int i=0;i<vertices;i++){
|
||||
if(a[pop][i]!=0 && b[i]!=(byte)0 && b[i]!=(byte)1 ){
|
||||
st.push(i);
|
||||
b[i]=(byte)0; //assigning waiting status
|
||||
}}}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* The main method
|
||||
*
|
||||
* @param args Command line arguments
|
||||
*/
|
||||
public static void main(String args[]){
|
||||
Scanner in=new Scanner(System.in);
|
||||
int vertices=in.nextInt(),source=in.nextInt();
|
||||
byte [][]a=new byte [vertices][vertices];
|
||||
//initially all elements of a are initialized with value zero
|
||||
|
||||
for(int i=0;i<vertices;i++){
|
||||
int size =in.nextInt();
|
||||
for(int j=0;j<size;j++){
|
||||
a[i][in.nextInt()]=1; //taking adjacency entries by assigning 1
|
||||
}
|
||||
}
|
||||
bfsImplement(a,vertices,source); //function call
|
||||
in.close();
|
||||
}
|
||||
}
|
||||
63
Data Structures/Graphs/DFS.java
Normal file
63
Data Structures/Graphs/DFS.java
Normal file
@@ -0,0 +1,63 @@
|
||||
import java.util.*;
|
||||
|
||||
/**
|
||||
* Implementation of a Depth First Search
|
||||
*
|
||||
* @author Unknown
|
||||
*
|
||||
*/
|
||||
|
||||
public class dfs{
|
||||
|
||||
/**
|
||||
* Implementation in code of a DFS
|
||||
*
|
||||
* @param a structure to be DFS'ed
|
||||
* @param vertices The vertices
|
||||
* @param source The source
|
||||
*/
|
||||
public static void dfsImplement(byte [][] a,int vertices,int source){ //passing adjacency matrix and no of vertices
|
||||
byte []b=new byte[vertices]; //flag container containing status of each vertices
|
||||
Arrays.fill(b,(byte)-1); //status initialization
|
||||
/* code status
|
||||
-1 = ready
|
||||
0 = waiting
|
||||
1 = processed */
|
||||
|
||||
|
||||
Stack st=new Stack(vertices); //operational stack
|
||||
st.push(source); //assigning source
|
||||
while(!st.isEmpty()){
|
||||
b[st.peek()]=(byte)0; //assigning waiting status
|
||||
System.out.println(st.peek());
|
||||
int pop=st.pop();
|
||||
b[pop]=(byte)1; //assigning processed status
|
||||
for(int i=0;i<vertices;i++){
|
||||
if(a[pop][i]!=0 && b[i]!=(byte)0 && b[i]!=(byte)1 ){
|
||||
st.push(i);
|
||||
b[i]=(byte)0; //assigning waiting status
|
||||
}}}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* The main method
|
||||
*
|
||||
* @param args Command line arguments
|
||||
*/
|
||||
public static void main(String args[]){
|
||||
Scanner in=new Scanner(System.in);
|
||||
int vertices=in.nextInt(),source=in.nextInt();
|
||||
byte [][]a=new byte [vertices][vertices];
|
||||
//initially all elements of a are initialized with value zero
|
||||
|
||||
for(int i=0;i<vertices;i++){
|
||||
int size =in.nextInt();
|
||||
for(int j=0;j<size;j++){
|
||||
a[i][in.nextInt()]=1; //taking adjacency entries by assigning 1
|
||||
}
|
||||
}
|
||||
dfsImplement(a,vertices,source); //function call
|
||||
in.close();
|
||||
}
|
||||
}
|
||||
129
Data Structures/Graphs/Graphs.java
Normal file
129
Data Structures/Graphs/Graphs.java
Normal file
@@ -0,0 +1,129 @@
|
||||
import java.util.ArrayList;
|
||||
import java.lang.StringBuilder;
|
||||
|
||||
class AdjacencyListGraph<E extends Comparable<E>> {
|
||||
|
||||
ArrayList<Vertex> verticies;
|
||||
|
||||
public AdjacencyListGraph() {
|
||||
verticies = new ArrayList<>();
|
||||
}
|
||||
|
||||
private class Vertex {
|
||||
E data;
|
||||
ArrayList<Vertex> adjacentVerticies;
|
||||
|
||||
public Vertex(E data) {
|
||||
adjacentVerticies = new ArrayList<>();
|
||||
this.data = data;
|
||||
}
|
||||
|
||||
public boolean addAdjacentVertex(Vertex to) {
|
||||
for (Vertex v: adjacentVerticies) {
|
||||
if (v.data.compareTo(to.data) == 0) {
|
||||
return false; // the edge already exists
|
||||
}
|
||||
}
|
||||
return adjacentVerticies.add(to); // this will return true;
|
||||
}
|
||||
|
||||
public boolean removeAdjacentVertex(E to) {
|
||||
// use indexes here so it is possible to
|
||||
// remove easily without implementing
|
||||
// equals method that ArrayList.remove(Object o) uses
|
||||
for (int i = 0; i < adjacentVerticies.size(); i++) {
|
||||
if (adjacentVerticies.get(i).data.compareTo(to) == 0) {
|
||||
adjacentVerticies.remove(i);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* this method removes an edge from the graph between two specified
|
||||
* verticies
|
||||
*
|
||||
* @param from the data of the vertex the edge is from
|
||||
* @param to the data of the vertex the edge is going to
|
||||
* @return returns false if the edge doesn't exist, returns true if the edge exists and is removed
|
||||
*/
|
||||
public boolean removeEdge(E from, E to) {
|
||||
Vertex fromV = null;
|
||||
for (Vertex v: verticies) {
|
||||
if (from.compareTo(v.data) == 0) {
|
||||
fromV = v;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (fromV == null) return false;
|
||||
return fromV.removeAdjacentVertex(to);
|
||||
}
|
||||
/**
|
||||
* this method adds an edge to the graph between two specified
|
||||
* verticies
|
||||
*
|
||||
* @param from the data of the vertex the edge is from
|
||||
* @param to the data of the vertex the edge is going to
|
||||
* @return returns true if the edge did not exist, return false if it already did
|
||||
*/
|
||||
public boolean addEdge(E from, E to) {
|
||||
Vertex fromV = null, toV = null;
|
||||
for (Vertex v: verticies) {
|
||||
if (from.compareTo(v.data) == 0) { // see if from vertex already exists
|
||||
fromV = v;
|
||||
} else if (to.compareTo(v.data) == 0) { // see if to vertex already exists
|
||||
toV = v;
|
||||
}
|
||||
if (fromV != null && toV != null) break; // both nodes exist so stop searching
|
||||
}
|
||||
if (fromV == null) {
|
||||
fromV = new Vertex(from);
|
||||
verticies.add(fromV);
|
||||
}
|
||||
if (toV == null) {
|
||||
toV = new Vertex(to);
|
||||
verticies.add(toV);
|
||||
}
|
||||
return fromV.addAdjacentVertex(toV);
|
||||
}
|
||||
|
||||
/**
|
||||
* this gives a list of verticies in the graph and their adjacencies
|
||||
*
|
||||
* @return returns a string describing this graph
|
||||
*/
|
||||
public String toString() {
|
||||
StringBuilder sb = new StringBuilder();
|
||||
for (Vertex v: verticies) {
|
||||
sb.append("Vertex: ");
|
||||
sb.append(v.data);
|
||||
sb.append("\n");
|
||||
sb.append("Adjacent verticies: ");
|
||||
for (Vertex v2: v.adjacentVerticies) {
|
||||
sb.append(v2.data);
|
||||
sb.append(" ");
|
||||
}
|
||||
sb.append("\n");
|
||||
}
|
||||
return sb.toString();
|
||||
}
|
||||
}
|
||||
|
||||
public class Graphs {
|
||||
|
||||
public static void main(String args[]) {
|
||||
AdjacencyListGraph<Integer> graph = new AdjacencyListGraph<>();
|
||||
assert graph.addEdge(1, 2);
|
||||
assert graph.addEdge(1, 5);
|
||||
assert graph.addEdge(2, 5);
|
||||
assert !graph.addEdge(1, 2);
|
||||
assert graph.addEdge(2, 3);
|
||||
assert graph.addEdge(3, 4);
|
||||
assert graph.addEdge(4, 1);
|
||||
assert !graph.addEdge(2, 3);
|
||||
System.out.println(graph);
|
||||
}
|
||||
|
||||
}
|
||||
141
Data Structures/HashMap/HashMap.java
Normal file
141
Data Structures/HashMap/HashMap.java
Normal file
@@ -0,0 +1,141 @@
|
||||
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.LinkedList;
|
||||
|
||||
public class HashMap<K,V> {
|
||||
public class hmnodes{ //HashMap nodes
|
||||
K key;
|
||||
V value;
|
||||
}
|
||||
|
||||
private int size=0; //size of hashmap
|
||||
private LinkedList<hmnodes> buckets[]; //array of addresses of list
|
||||
|
||||
public HashMap(){
|
||||
buckets=new LinkedList[4]; //initially create bucket of any size
|
||||
for(int i=0;i<4;i++)
|
||||
buckets[i]=new LinkedList<>();
|
||||
}
|
||||
|
||||
public void put(K key,V value) throws Exception{
|
||||
int bi=bucketIndex(key); //find the index,the new key will be inserted in linklist at that index
|
||||
int fountAt=find(bi,key); //check if key already exists or not
|
||||
if(fountAt==-1){
|
||||
hmnodes temp=new hmnodes(); //if doesn't exist create new node and insert
|
||||
temp.key=key;
|
||||
temp.value=value;
|
||||
buckets[bi].addLast(temp);
|
||||
this.size++;
|
||||
}else{
|
||||
buckets[bi].get(fountAt).value=value;//if already exist modify the value
|
||||
}
|
||||
|
||||
double lambda = (this.size*1.0)/this.buckets.length;
|
||||
if(lambda>2.0){
|
||||
rehash(); //rehashing function which will increase the size of bucket as soon as lambda exceeds 2.0
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
public V get(K key) throws Exception{
|
||||
int bi=bucketIndex(key);
|
||||
int fountAt=find(bi,key);
|
||||
if(fountAt==-1){
|
||||
return null;
|
||||
}else{
|
||||
return buckets[bi].get(fountAt).value;
|
||||
}
|
||||
}
|
||||
|
||||
public V remove(K key) throws Exception{
|
||||
int bi=bucketIndex(key);
|
||||
int fountAt=find(bi,key);
|
||||
if(fountAt==-1){
|
||||
return null;
|
||||
}else{
|
||||
this.size--;
|
||||
return buckets[bi].remove(fountAt).value;
|
||||
}
|
||||
}
|
||||
|
||||
public boolean containskey(K key) throws Exception{
|
||||
int bi=bucketIndex(key);
|
||||
int fountAt=find(bi,key);
|
||||
if(fountAt==-1){
|
||||
return false;
|
||||
}else{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
public int size(){
|
||||
return this.size;
|
||||
}
|
||||
|
||||
|
||||
public boolean isempty(){
|
||||
return this.size==0;
|
||||
}
|
||||
|
||||
public ArrayList<K> keyset() throws Exception{
|
||||
ArrayList<K> arr=new ArrayList<>();
|
||||
for(int i=0;i<buckets.length;i++){
|
||||
for(int j=0;j<buckets[i].size();j++){
|
||||
arr.add(buckets[i].get(j).key);
|
||||
}
|
||||
}
|
||||
return arr;
|
||||
}
|
||||
|
||||
public ArrayList<V> valueset() throws Exception{
|
||||
ArrayList<V> arr=new ArrayList<>();
|
||||
for(int i=0;i<buckets.length;i++){
|
||||
for(int j=0;j<buckets[i].size();j++){
|
||||
arr.add(buckets[i].get(j).value);
|
||||
}
|
||||
}
|
||||
return arr;
|
||||
}
|
||||
|
||||
public void display() throws Exception{
|
||||
for(int i=0;i<buckets.length;i++){
|
||||
System.out.print("Bucket: "+i+" ");
|
||||
for(int j=0;j<buckets[i].size();j++){
|
||||
hmnodes temp=buckets[i].get(j);
|
||||
System.out.print("["+temp.key+"->"+temp.value+"]");
|
||||
}
|
||||
System.out.println();
|
||||
}
|
||||
}
|
||||
|
||||
public int find(int bi,K key) throws Exception{
|
||||
for(int i=0;i<buckets[bi].size();i++){
|
||||
if(key.equals(buckets[bi].get(i).key))
|
||||
return i;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
public int bucketIndex(K key) throws Exception{
|
||||
int bi=key.hashCode();
|
||||
return Math.abs(bi%buckets.length);
|
||||
}
|
||||
|
||||
private void rehash() throws Exception{
|
||||
LinkedList<hmnodes> ob[]= buckets;
|
||||
buckets=new LinkedList[ob.length*2];
|
||||
for(int i=0;i<ob.length*2;i++)
|
||||
buckets[i]=new LinkedList<>();
|
||||
|
||||
size = 0;
|
||||
for(int i=0;i<ob.length;i++){
|
||||
for(int j=0;j<ob[i].size();j++){
|
||||
put(ob[i].get(j).key,ob[i].get(j).value);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
18
Data Structures/Heaps/EmptyHeapException.java
Normal file
18
Data Structures/Heaps/EmptyHeapException.java
Normal file
@@ -0,0 +1,18 @@
|
||||
/**
|
||||
*
|
||||
*/
|
||||
package heaps;
|
||||
|
||||
/**
|
||||
* @author Nicolas Renard
|
||||
* Exception to be thrown if the getElement method is used on an empty heap.
|
||||
*
|
||||
*/
|
||||
@SuppressWarnings("serial")
|
||||
public class EmptyHeapException extends Exception {
|
||||
|
||||
public EmptyHeapException(String message) {
|
||||
super(message);
|
||||
}
|
||||
|
||||
}
|
||||
41
Data Structures/Heaps/Heap.java
Normal file
41
Data Structures/Heaps/Heap.java
Normal file
@@ -0,0 +1,41 @@
|
||||
package heaps;
|
||||
|
||||
/**
|
||||
* Interface common to heap data structures.<br>
|
||||
* <p>Heaps are tree-like data structures that allow storing elements in a specific
|
||||
* way. Each node corresponds to an element and has one parent node (except for the root) and
|
||||
* at most two children nodes. Every element contains a key, and those keys
|
||||
* indicate how the tree shall be built. For instance, for a min-heap, the key of a node shall
|
||||
* be greater than or equal to its parent's and lower than or equal to its children's (the opposite rule applies to a
|
||||
* max-heap).</p>
|
||||
* <p>All heap-related operations (inserting or deleting an element, extracting the min or max) are performed in
|
||||
* O(log n) time.</p>
|
||||
* @author Nicolas Renard
|
||||
*
|
||||
*
|
||||
*/
|
||||
public interface Heap {
|
||||
|
||||
/**
|
||||
*
|
||||
* @return the top element in the heap, the one with lowest key for min-heap or with
|
||||
* the highest key for max-heap
|
||||
* @throws Exception if heap is empty
|
||||
*/
|
||||
public abstract HeapElement getElement() throws EmptyHeapException;
|
||||
/**
|
||||
* Inserts an element in the heap. Adds it to then end and toggle it until it finds its
|
||||
* right position.
|
||||
*
|
||||
* @param element an instance of the HeapElement class.
|
||||
*/
|
||||
public abstract void insertElement(HeapElement element);
|
||||
|
||||
/**
|
||||
* Delete an element in the heap.
|
||||
*
|
||||
* @param elementIndex int containing the position in the heap of the element to be deleted.
|
||||
*/
|
||||
public abstract void deleteElement(int elementIndex);
|
||||
|
||||
}
|
||||
132
Data Structures/Heaps/HeapElement.java
Normal file
132
Data Structures/Heaps/HeapElement.java
Normal file
@@ -0,0 +1,132 @@
|
||||
/**
|
||||
*
|
||||
*/
|
||||
package heaps;
|
||||
|
||||
import java.lang.Double;
|
||||
import java.lang.Object;
|
||||
|
||||
/**
|
||||
* Class for heap elements.<br>
|
||||
* <p>A heap element contains two attributes: a key which will be used to build the tree (int
|
||||
* or double, either primitive type or object) and any kind of IMMUTABLE object the user sees fit
|
||||
* to carry any information he/she likes. Be aware that the use of a mutable object might
|
||||
* jeopardize the integrity of this information. </p>
|
||||
* @author Nicolas Renard
|
||||
*
|
||||
*/
|
||||
public class HeapElement {
|
||||
private final double key;
|
||||
private final Object additionalInfo;
|
||||
|
||||
// Constructors
|
||||
|
||||
/**
|
||||
*
|
||||
* @param key : a number of primitive type 'double'
|
||||
* @param info : any kind of IMMUTABLE object. May be null, since the purpose is only to carry
|
||||
* additional information of use for the user
|
||||
*/
|
||||
public HeapElement(double key, Object info) {
|
||||
this.key = key;
|
||||
this.additionalInfo = info;
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @param key : a number of primitive type 'int'
|
||||
* @param info : any kind of IMMUTABLE object. May be null, since the purpose is only to carry
|
||||
* additional information of use for the user
|
||||
*/
|
||||
public HeapElement(int key, Object info) {
|
||||
this.key = key;
|
||||
this.additionalInfo = info;
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @param key : a number of object type 'Integer'
|
||||
* @param info : any kind of IMMUTABLE object. May be null, since the purpose is only to carry
|
||||
* additional information of use for the user
|
||||
*/
|
||||
public HeapElement(Integer key, Object info) {
|
||||
this.key = key;
|
||||
this.additionalInfo = info;
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @param key : a number of object type 'Double'
|
||||
* @param info : any kind of IMMUTABLE object. May be null, since the purpose is only to carry
|
||||
* additional information of use for the user
|
||||
*/
|
||||
public HeapElement(Double key, Object info) {
|
||||
this.key = key;
|
||||
this.additionalInfo = info;
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @param key : a number of primitive type 'double'
|
||||
*/
|
||||
public HeapElement(double key) {
|
||||
this.key = key;
|
||||
this.additionalInfo = null;
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @param key : a number of primitive type 'int'
|
||||
*/
|
||||
public HeapElement(int key) {
|
||||
this.key = key;
|
||||
this.additionalInfo = null;
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @param key : a number of object type 'Integer'
|
||||
*/
|
||||
public HeapElement(Integer key) {
|
||||
this.key = key;
|
||||
this.additionalInfo = null;
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @param key : a number of object type 'Double'
|
||||
*/
|
||||
public HeapElement(Double key) {
|
||||
this.key = key;
|
||||
this.additionalInfo = null;
|
||||
}
|
||||
|
||||
// Getters
|
||||
/**
|
||||
* @return the object containing the additional info provided by the user.
|
||||
*/
|
||||
public Object getInfo() {
|
||||
return additionalInfo;
|
||||
}
|
||||
/**
|
||||
* @return the key value of the element
|
||||
*/
|
||||
public double getKey() {
|
||||
return key;
|
||||
}
|
||||
|
||||
// Overridden object methods
|
||||
|
||||
public String toString() {
|
||||
return "Key: " + key + " - " +additionalInfo.toString();
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param otherHeapElement
|
||||
* @return true if the keys on both elements are identical and the additional info objects
|
||||
* are identical.
|
||||
*/
|
||||
public boolean equals(HeapElement otherHeapElement) {
|
||||
return (this.key == otherHeapElement.key) && (this.additionalInfo.equals(otherHeapElement.additionalInfo));
|
||||
}
|
||||
}
|
||||
115
Data Structures/Heaps/MaxHeap.java
Normal file
115
Data Structures/Heaps/MaxHeap.java
Normal file
@@ -0,0 +1,115 @@
|
||||
package heaps;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Heap tree where a node's key is higher than or equal to its parent's and lower than or equal
|
||||
* to its children's.
|
||||
* @author Nicolas Renard
|
||||
*
|
||||
*/
|
||||
public class MaxHeap implements Heap {
|
||||
|
||||
private final List<HeapElement> maxHeap;
|
||||
|
||||
public MaxHeap(List<HeapElement> listElements) throws Exception {
|
||||
maxHeap = new ArrayList<HeapElement>();
|
||||
for (HeapElement heapElement : listElements) {
|
||||
if (heapElement != null) insertElement(heapElement);
|
||||
else System.out.println("Null element. Not added to heap");
|
||||
}
|
||||
if (maxHeap.size() == 0) System.out.println("No element has been added, empty heap.");
|
||||
}
|
||||
|
||||
// Get the element at a given index. The key for the list is equal to index value - 1
|
||||
public HeapElement getElement(int elementIndex) {
|
||||
if ((elementIndex <= 0) && (elementIndex > maxHeap.size())) throw new IndexOutOfBoundsException("Index out of heap range");
|
||||
return maxHeap.get(elementIndex - 1);
|
||||
}
|
||||
|
||||
// Get the key of the element at a given index
|
||||
private double getElementKey(int elementIndex) {
|
||||
return maxHeap.get(elementIndex - 1).getKey();
|
||||
}
|
||||
|
||||
// Swaps two elements in the heap
|
||||
private void swap(int index1, int index2) {
|
||||
HeapElement temporaryElement = maxHeap.get(index1 - 1);
|
||||
maxHeap.set(index1 - 1, maxHeap.get(index2 - 1));
|
||||
maxHeap.set(index2 - 1, temporaryElement);
|
||||
}
|
||||
|
||||
// Toggle an element up to its right place as long as its key is lower than its parent's
|
||||
private void toggleUp(int elementIndex) {
|
||||
double key = maxHeap.get(elementIndex - 1).getKey();
|
||||
while (getElementKey((int) Math.floor(elementIndex/2)) < key) {
|
||||
swap(elementIndex, (int) Math.floor(elementIndex/2));
|
||||
elementIndex = (int) Math.floor(elementIndex/2);
|
||||
}
|
||||
}
|
||||
|
||||
// Toggle an element down to its right place as long as its key is higher
|
||||
// than any of its children's
|
||||
private void toggleDown(int elementIndex) {
|
||||
double key = maxHeap.get(elementIndex - 1).getKey();
|
||||
boolean wrongOrder = (key < getElementKey(elementIndex*2)) || (key < getElementKey(Math.min(elementIndex*2, maxHeap.size())));
|
||||
while ((2*elementIndex <= maxHeap.size()) && wrongOrder) {
|
||||
// Check whether it shall swap the element with its left child or its right one if any.
|
||||
if ((2*elementIndex < maxHeap.size()) && (getElementKey(elementIndex*2 + 1) > getElementKey(elementIndex*2))) {
|
||||
swap(elementIndex, 2*elementIndex + 1);
|
||||
elementIndex = 2*elementIndex + 1;
|
||||
}
|
||||
else {
|
||||
swap(elementIndex, 2*elementIndex);
|
||||
elementIndex = 2*elementIndex;
|
||||
}
|
||||
wrongOrder = (key < getElementKey(elementIndex*2)) || (key < getElementKey(Math.min(elementIndex*2, maxHeap.size())));
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
private HeapElement extractMax() {
|
||||
HeapElement result = maxHeap.get(0);
|
||||
deleteElement(0);
|
||||
return result;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void insertElement(HeapElement element) {
|
||||
maxHeap.add(element);
|
||||
toggleUp(maxHeap.size());
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void deleteElement(int elementIndex) {
|
||||
if (maxHeap.isEmpty())
|
||||
try {
|
||||
throw new EmptyHeapException("Attempt to delete an element from an empty heap");
|
||||
} catch (EmptyHeapException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
if ((elementIndex > maxHeap.size()) && (elementIndex <= 0)) throw new IndexOutOfBoundsException("Index out of heap range");
|
||||
// The last element in heap replaces the one to be deleted
|
||||
maxHeap.set(elementIndex - 1, getElement(maxHeap.size()));
|
||||
maxHeap.remove(maxHeap.size());
|
||||
// Shall the new element be moved up...
|
||||
if (getElementKey(elementIndex) > getElementKey((int) Math.floor(elementIndex/2))) toggleUp(elementIndex);
|
||||
// ... or down ?
|
||||
else if (((2*elementIndex <= maxHeap.size()) && (getElementKey(elementIndex) < getElementKey(elementIndex*2))) ||
|
||||
((2*elementIndex < maxHeap.size()) && (getElementKey(elementIndex) < getElementKey(elementIndex*2)))) toggleDown(elementIndex);
|
||||
}
|
||||
|
||||
@Override
|
||||
public HeapElement getElement() throws EmptyHeapException {
|
||||
try {
|
||||
return extractMax();
|
||||
} catch (Exception e) {
|
||||
throw new EmptyHeapException("Heap is empty. Error retrieving element");
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
115
Data Structures/Heaps/MinHeap.java
Normal file
115
Data Structures/Heaps/MinHeap.java
Normal file
@@ -0,0 +1,115 @@
|
||||
/**
|
||||
*
|
||||
*/
|
||||
package heaps;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Heap tree where a node's key is higher than or equal to its parent's and lower than or equal
|
||||
* to its children's.
|
||||
* @author Nicolas Renard
|
||||
*
|
||||
*/
|
||||
public class MinHeap implements Heap {
|
||||
|
||||
private final List<HeapElement> minHeap;
|
||||
|
||||
public MinHeap(List<HeapElement> listElements) throws Exception {
|
||||
minHeap = new ArrayList<HeapElement>();
|
||||
for (HeapElement heapElement : listElements) {
|
||||
if (heapElement != null) insertElement(heapElement);
|
||||
else System.out.println("Null element. Not added to heap");
|
||||
}
|
||||
if (minHeap.size() == 0) System.out.println("No element has been added, empty heap.");
|
||||
}
|
||||
|
||||
// Get the element at a given index. The key for the list is equal to index value - 1
|
||||
public HeapElement getElement(int elementIndex) {
|
||||
if ((elementIndex <= 0) && (elementIndex > minHeap.size())) throw new IndexOutOfBoundsException("Index out of heap range");
|
||||
return minHeap.get(elementIndex - 1);
|
||||
}
|
||||
|
||||
// Get the key of the element at a given index
|
||||
private double getElementKey(int elementIndex) {
|
||||
return minHeap.get(elementIndex - 1).getKey();
|
||||
}
|
||||
|
||||
// Swaps two elements in the heap
|
||||
private void swap(int index1, int index2) {
|
||||
HeapElement temporaryElement = minHeap.get(index1 - 1);
|
||||
minHeap.set(index1 - 1, minHeap.get(index2 - 1));
|
||||
minHeap.set(index2 - 1, temporaryElement);
|
||||
}
|
||||
|
||||
// Toggle an element up to its right place as long as its key is lower than its parent's
|
||||
private void toggleUp(int elementIndex) {
|
||||
double key = minHeap.get(elementIndex - 1).getKey();
|
||||
while (getElementKey((int) Math.floor(elementIndex/2)) > key) {
|
||||
swap(elementIndex, (int) Math.floor(elementIndex/2));
|
||||
elementIndex = (int) Math.floor(elementIndex/2);
|
||||
}
|
||||
}
|
||||
|
||||
// Toggle an element down to its right place as long as its key is higher
|
||||
// than any of its children's
|
||||
private void toggleDown(int elementIndex) {
|
||||
double key = minHeap.get(elementIndex - 1).getKey();
|
||||
boolean wrongOrder = (key > getElementKey(elementIndex*2)) || (key > getElementKey(Math.min(elementIndex*2, minHeap.size())));
|
||||
while ((2*elementIndex <= minHeap.size()) && wrongOrder) {
|
||||
// Check whether it shall swap the element with its left child or its right one if any.
|
||||
if ((2*elementIndex < minHeap.size()) && (getElementKey(elementIndex*2 + 1) < getElementKey(elementIndex*2))) {
|
||||
swap(elementIndex, 2*elementIndex + 1);
|
||||
elementIndex = 2*elementIndex + 1;
|
||||
}
|
||||
else {
|
||||
swap(elementIndex, 2*elementIndex);
|
||||
elementIndex = 2*elementIndex;
|
||||
}
|
||||
wrongOrder = (key > getElementKey(elementIndex*2)) || (key > getElementKey(Math.min(elementIndex*2, minHeap.size())));
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
private HeapElement extractMin() {
|
||||
HeapElement result = minHeap.get(0);
|
||||
deleteElement(0);
|
||||
return result;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void insertElement(HeapElement element) {
|
||||
minHeap.add(element);
|
||||
toggleUp(minHeap.size());
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void deleteElement(int elementIndex) {
|
||||
if (minHeap.isEmpty())
|
||||
try {
|
||||
throw new EmptyHeapException("Attempt to delete an element from an empty heap");
|
||||
} catch (EmptyHeapException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
if ((elementIndex > minHeap.size()) && (elementIndex <= 0)) throw new IndexOutOfBoundsException("Index out of heap range");
|
||||
// The last element in heap replaces the one to be deleted
|
||||
minHeap.set(elementIndex - 1, getElement(minHeap.size()));
|
||||
minHeap.remove(minHeap.size());
|
||||
// Shall the new element be moved up...
|
||||
if (getElementKey(elementIndex) < getElementKey((int) Math.floor(elementIndex/2))) toggleUp(elementIndex);
|
||||
// ... or down ?
|
||||
else if (((2*elementIndex <= minHeap.size()) && (getElementKey(elementIndex) > getElementKey(elementIndex*2))) ||
|
||||
((2*elementIndex < minHeap.size()) && (getElementKey(elementIndex) > getElementKey(elementIndex*2)))) toggleDown(elementIndex);
|
||||
}
|
||||
|
||||
@Override
|
||||
public HeapElement getElement() throws EmptyHeapException {
|
||||
try {
|
||||
return extractMin();
|
||||
} catch (Exception e) {
|
||||
throw new EmptyHeapException("Heap is empty. Error retrieving element");
|
||||
}
|
||||
}
|
||||
}
|
||||
42
Data Structures/Lists/CircleLinkedList.java
Normal file
42
Data Structures/Lists/CircleLinkedList.java
Normal file
@@ -0,0 +1,42 @@
|
||||
public class CircleLinkedList<E>{
|
||||
private static class Node<E>{
|
||||
Node<E> next;
|
||||
E value;
|
||||
private Node(E value, Node<E> next){
|
||||
this.value = value;
|
||||
this.next = next;
|
||||
}
|
||||
}
|
||||
private int size; //For better O.O design this should be private allows for better black box design
|
||||
private Node<E> head; //this will point to dummy node;
|
||||
public CircleLinkedList(){ //constructer for class.. here we will make a dummy node for circly linked list implementation with reduced error catching as our list will never be empty;
|
||||
head = new Node<E>(null,head); //creation of the dummy node
|
||||
size = 0;
|
||||
}
|
||||
public int getSize(){ return size;} // getter for the size... needed because size is private.
|
||||
public void append(E value){ // for the sake of simplistiy this class will only contain the append function or addLast other add functions can be implemented however this is the basses of them all really.
|
||||
if(value == null){
|
||||
throw new NullPointerException("Cannot add null element to the list"); // we do not want to add null elements to the list.
|
||||
}
|
||||
head.next = new Node<E>(value,head); //head.next points to the last element;
|
||||
size++;}
|
||||
public E remove(int pos){
|
||||
if(pos>size || pos< 0){
|
||||
throw new IndexOutOfBoundsException("position cannot be greater than size or negative"); //catching errors
|
||||
}
|
||||
Node<E> iterator = head.next;
|
||||
Node<E> before = head; //we need to keep track of the element before the element we want to remove we can see why bellow.
|
||||
for(int i = 1; i<=pos; i++){
|
||||
iterator = iterator.next;
|
||||
before = before.next;
|
||||
}
|
||||
E saved = iterator.value;
|
||||
before.next = iterator.next; // assigning the next referance to the the element following the element we want to remove... the last element will be assigned to the head.
|
||||
iterator.next = null; // scrubbing
|
||||
iterator.value = null;
|
||||
return saved;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
214
Data Structures/Lists/DoublyLinkedList.java
Normal file
214
Data Structures/Lists/DoublyLinkedList.java
Normal file
@@ -0,0 +1,214 @@
|
||||
/**
|
||||
* This class implements a DoublyLinkedList. This is done using the classes
|
||||
* LinkedList and Link.
|
||||
*
|
||||
* A linked list is simplar to an array, it holds values. However,
|
||||
* links in a linked list do not have indees. With a linked list
|
||||
* you do not need to predetermine it's size as it grows and shrinks
|
||||
* as it is edited. This is an example of a double ended, doubly
|
||||
* linked list. Each link references the next link and the previous
|
||||
* one.
|
||||
*
|
||||
* @author Unknown
|
||||
*
|
||||
*/
|
||||
|
||||
class DoublyLinkedList{
|
||||
/** Head refers to the front of the list */
|
||||
private Link head;
|
||||
/** Tail refers to the back of the list */
|
||||
private Link tail;
|
||||
|
||||
/**
|
||||
* Constructor
|
||||
*/
|
||||
public DoublyLinkedList(){
|
||||
head = null;
|
||||
tail = null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Insert an element at the head
|
||||
*
|
||||
* @param x Element to be inserted
|
||||
*/
|
||||
public void insertHead(int x){
|
||||
Link newLink = new Link(x); //Create a new link with a value attached to it
|
||||
if(isEmpty()) //Set the first element added to be the tail
|
||||
tail = newLink;
|
||||
else
|
||||
head.previous = newLink; // newLink <-- currenthead(head)
|
||||
newLink.next = head; // newLink <--> currenthead(head)
|
||||
head = newLink; // newLink(head) <--> oldhead
|
||||
}
|
||||
|
||||
/**
|
||||
* Insert an element at the tail
|
||||
*
|
||||
* @param x Element to be inserted
|
||||
*/
|
||||
public void insertTail(int x){
|
||||
Link newLink = new Link(x);
|
||||
newLink.next = null; // currentTail(tail) newlink -->
|
||||
tail.next = newLink; // currentTail(tail) --> newLink -->
|
||||
newLink.previous = tail; // currentTail(tail) <--> newLink -->
|
||||
tail = newLink; // oldTail <--> newLink(tail) -->
|
||||
}
|
||||
|
||||
/**
|
||||
* Delete the element at the head
|
||||
*
|
||||
* @return The new head
|
||||
*/
|
||||
public Link deleteHead(){
|
||||
Link temp = head;
|
||||
head = head.next; // oldHead <--> 2ndElement(head)
|
||||
head.previous = null; // oldHead --> 2ndElement(head) nothing pointing at old head so will be removed
|
||||
if(head == null)
|
||||
tail = null;
|
||||
return temp;
|
||||
}
|
||||
|
||||
/**
|
||||
* Delete the element at the tail
|
||||
*
|
||||
* @return The new tail
|
||||
*/
|
||||
public Link deleteTail(){
|
||||
Link temp = tail;
|
||||
tail = tail.previous; // 2ndLast(tail) <--> oldTail --> null
|
||||
tail.next = null; // 2ndLast(tail) --> null
|
||||
return temp;
|
||||
}
|
||||
|
||||
/**
|
||||
* Delete the element from somewhere in the list
|
||||
*
|
||||
* @param x element to be deleted
|
||||
* @return Link deleted
|
||||
*/
|
||||
public Link delete(int x){
|
||||
Link current = head;
|
||||
|
||||
while(current.value != x) //Find the position to delete
|
||||
current = current.next;
|
||||
|
||||
if(current == head)
|
||||
deleteHead();
|
||||
|
||||
else if(current == tail)
|
||||
deleteTail();
|
||||
|
||||
else{ //Before: 1 <--> 2(current) <--> 3
|
||||
current.previous.next = current.next; // 1 --> 3
|
||||
current.next.previous = current.previous; // 1 <--> 3
|
||||
}
|
||||
return current;
|
||||
}
|
||||
|
||||
/**
|
||||
* Inserts element and reorders
|
||||
*
|
||||
* @param x Element to be added
|
||||
*/
|
||||
public void insertOrdered(int x){
|
||||
Link newLink = new Link(x);
|
||||
Link current = head;
|
||||
while(current != null && x > current.value) //Find the position to insert
|
||||
current = current.next;
|
||||
|
||||
if(current == head)
|
||||
insertHead(x);
|
||||
|
||||
else if(current == null)
|
||||
insertTail(x);
|
||||
|
||||
else{ //Before: 1 <--> 2(current) <--> 3
|
||||
newLink.previous = current.previous; // 1 <-- newLink
|
||||
current.previous.next = newLink; // 1 <--> newLink
|
||||
newLink.next = current; // 1 <--> newLink --> 2(current) <--> 3
|
||||
current.previous = newLink; // 1 <--> newLink <--> 2(current) <--> 3
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if list is empty
|
||||
*
|
||||
* @return true if list is empty
|
||||
*/
|
||||
public boolean isEmpty(){
|
||||
return(head == null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Prints contents of the list
|
||||
*/
|
||||
public void display(){ //Prints contents of the list
|
||||
Link current = head;
|
||||
while(current!=null){
|
||||
current.displayLink();
|
||||
current = current.next;
|
||||
}
|
||||
System.out.println();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* This class is used to implement the nodes of the
|
||||
* linked list.
|
||||
*
|
||||
* @author Unknown
|
||||
*
|
||||
*/
|
||||
class Link{
|
||||
/** Value of node */
|
||||
public int value;
|
||||
/** This points to the link in front of the new link */
|
||||
public Link next;
|
||||
/** This points to the link behind the new link */
|
||||
public Link previous;
|
||||
|
||||
/**
|
||||
* Constructor
|
||||
*
|
||||
* @param value Value of node
|
||||
*/
|
||||
public Link(int value){
|
||||
this.value = value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Displays the node
|
||||
*/
|
||||
public void displayLink(){
|
||||
System.out.print(value+" ");
|
||||
}
|
||||
|
||||
/**
|
||||
* Main Method
|
||||
*
|
||||
* @param args Command line arguments
|
||||
*/
|
||||
public static void main(String args[]){
|
||||
DoublyLinkedList myList = new DoublyLinkedList();
|
||||
|
||||
myList.insertHead(13);
|
||||
myList.insertHead(7);
|
||||
myList.insertHead(10);
|
||||
myList.display(); // <-- 10(head) <--> 7 <--> 13(tail) -->
|
||||
|
||||
myList.insertTail(11);
|
||||
myList.display(); // <-- 10(head) <--> 7 <--> 13 <--> 11(tail) -->
|
||||
|
||||
myList.deleteTail();
|
||||
myList.display(); // <-- 10(head) <--> 7 <--> 13(tail) -->
|
||||
|
||||
myList.delete(7);
|
||||
myList.display(); // <-- 10(head) <--> 13(tail) -->
|
||||
|
||||
myList.insertOrdered(23);
|
||||
myList.insertOrdered(67);
|
||||
myList.insertOrdered(3);
|
||||
myList.display(); // <-- 3(head) <--> 10 <--> 13 <--> 23 <--> 67(tail) -->
|
||||
}
|
||||
}
|
||||
151
Data Structures/Lists/SinglyLinkedList.java
Normal file
151
Data Structures/Lists/SinglyLinkedList.java
Normal file
@@ -0,0 +1,151 @@
|
||||
/**
|
||||
* This class implements a SinglyLinked List. This is done
|
||||
* using SinglyLinkedList class and a LinkForLinkedList Class.
|
||||
*
|
||||
* A linked list is implar to an array, it hold values.
|
||||
* However, links in a linked list do not have indexes. With
|
||||
* a linked list you do not need to predetermine it's size as
|
||||
* it gorws and shrinks as it is edited. This is an example of
|
||||
* a singly linked list. Elements can only be added/removed
|
||||
* at the head/front of the list.
|
||||
*
|
||||
* @author Unknown
|
||||
*
|
||||
*/
|
||||
class SinglyLinkedList{
|
||||
/**Head refered to the front of the list */
|
||||
private Node head;
|
||||
|
||||
/**
|
||||
* Constructor of SinglyLinkedList
|
||||
*/
|
||||
public SinglyLinkedList(){
|
||||
head = null;
|
||||
}
|
||||
|
||||
/**
|
||||
* This method inserts an element at the head
|
||||
*
|
||||
* @param x Element to be added
|
||||
*/
|
||||
public void insertHead(int x){
|
||||
Node newNode = new Node(x); //Create a new link with a value attached to it
|
||||
newNode.next = head; //Set the new link to point to the current head
|
||||
head = newNode; //Now set the new link to be the head
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Inserts a new node at a specified position
|
||||
* @param head head node of the linked list
|
||||
* @param data data to be stored in a new node
|
||||
* @param position position at which a new node is to be inserted
|
||||
* @return reference of the head of the linked list
|
||||
*/
|
||||
|
||||
Node InsertNth(Node head, int data, int position) {
|
||||
|
||||
Node newNode = new Node();
|
||||
newNode.data = data;
|
||||
|
||||
if (position == 0) {
|
||||
newNode.next = head;
|
||||
return newNode;
|
||||
}
|
||||
|
||||
Node current = head;
|
||||
|
||||
while (--position > 0) {
|
||||
current = current.next;
|
||||
}
|
||||
|
||||
newNode.next = current.next;
|
||||
current.next = newNode;
|
||||
return head;
|
||||
}
|
||||
|
||||
/**
|
||||
* This method deletes an element at the head
|
||||
*
|
||||
* @return The element deleted
|
||||
*/
|
||||
public Node deleteHead(){
|
||||
Node temp = head;
|
||||
head = head.next; //Make the second element in the list the new head, the Java garbage collector will later remove the old head
|
||||
return temp;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the list is empty
|
||||
*
|
||||
* @return true is list is empty
|
||||
*/
|
||||
public boolean isEmpty(){
|
||||
return(head == null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Prints contents of the list
|
||||
*/
|
||||
public void display(){
|
||||
Node current = head;
|
||||
while(current!=null){
|
||||
System.out.print(current.getValue()+" ");
|
||||
current = current.next;
|
||||
}
|
||||
System.out.println();
|
||||
}
|
||||
|
||||
/**
|
||||
* Main method
|
||||
*
|
||||
* @param args Command line arguments
|
||||
*/
|
||||
public static void main(String args[]){
|
||||
SinglyLinkedList myList = new SinglyLinkedList();
|
||||
|
||||
System.out.println(myList.isEmpty()); //Will print true
|
||||
|
||||
myList.insertHead(5);
|
||||
myList.insertHead(7);
|
||||
myList.insertHead(10);
|
||||
|
||||
myList.display(); // 10(head) --> 7 --> 5
|
||||
|
||||
myList.deleteHead();
|
||||
|
||||
myList.display(); // 7(head) --> 5
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* This class is the nodes of the SinglyLinked List.
|
||||
* They consist of a vlue and a pointer to the node
|
||||
* after them.
|
||||
*
|
||||
* @author Unknown
|
||||
*
|
||||
*/
|
||||
class Node{
|
||||
/** The value of the node */
|
||||
public int value;
|
||||
/** Point to the next node */
|
||||
public Node next; //This is what the link will point to
|
||||
|
||||
/**
|
||||
* Constructor
|
||||
*
|
||||
* @param valuein Value to be put in the node
|
||||
*/
|
||||
public Node(int valuein){
|
||||
value = valuein;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns value of the node
|
||||
*/
|
||||
public int getValue(){
|
||||
return value;
|
||||
}
|
||||
|
||||
}
|
||||
197
Data Structures/Matrix/Matrix.java
Normal file
197
Data Structures/Matrix/Matrix.java
Normal file
@@ -0,0 +1,197 @@
|
||||
/**
|
||||
* Matrix data-type.
|
||||
*
|
||||
* @author Kyler Smith, 2017
|
||||
*/
|
||||
|
||||
|
||||
public class Matrix {
|
||||
|
||||
public static void main(String[] args) {
|
||||
|
||||
int[][] data1 = new int[0][0];
|
||||
int[][] data2 = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
|
||||
int[][] data3 = {{1, 4, 7}, {2, 5, 8}, {3, 6, 9}};
|
||||
|
||||
Matrix m1 = new Matrix(data1);
|
||||
Matrix m2 = new Matrix(data2);
|
||||
Matrix m3 = new Matrix(data3);
|
||||
|
||||
System.out.println("m1 --> Rows: " + m1.getRows() + " Columns: " + m1.getColumns());
|
||||
System.out.println("m2 --> Rows: " + m2.getRows() + " Columns: " + m2.getColumns());
|
||||
System.out.println("m3 --> Rows: " + m3.getRows() + " Columns: " + m3.getColumns());
|
||||
|
||||
//check for reference issues
|
||||
System.out.println("m2 -->\n" + m2);
|
||||
data2[1][1] = 101;
|
||||
System.out.println("m2 -->\n" + m2);
|
||||
|
||||
//test equals
|
||||
System.out.println("m2==null: " + m2.equals(null)); //false
|
||||
System.out.println("m3==\"MATRIX\": " + m2.equals("MATRIX")); //false
|
||||
System.out.println("m2==m1: " + m2.equals(m1)); //false
|
||||
System.out.println("m2==m2: " + m2.equals(m2)); //true
|
||||
System.out.println("m2==m3: " + m2.equals(m3)); //false
|
||||
|
||||
//test operations (valid)
|
||||
System.out.println("2 * m2:\n" + m2.scale(2));
|
||||
System.out.println("m2 + m3:\n" + m2.plus(m3));
|
||||
System.out.println("m2 - m3:\n" + m2.minus(m3));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Data needs to be a deep copy as not to change the original state.
|
||||
*/
|
||||
private int[][] data;
|
||||
|
||||
/**
|
||||
* Constructor for the matrix takes in a 2D array
|
||||
*
|
||||
* @param pData
|
||||
*/
|
||||
public Matrix(int[][] pData) {
|
||||
|
||||
/** Make a deep copy of the data */
|
||||
if(pData.length != 0) {
|
||||
int[][] newData = new int[pData.length][pData[0].length];
|
||||
|
||||
for(int i = 0; i < pData.length; i++)
|
||||
for(int j = 0; j < pData[0].length; j++)
|
||||
newData[i][j] = pData[i][j];
|
||||
|
||||
this.data = newData;
|
||||
} else {
|
||||
this.data = null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the element specified by the given location
|
||||
*
|
||||
* @param x : x cooridinate
|
||||
* @param y : y cooridinate
|
||||
* @return int : value at location
|
||||
*/
|
||||
public int getElement(int x, int y) {
|
||||
return data[x][y];
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the number of rows in the Matrix
|
||||
*
|
||||
* @return rows
|
||||
*/
|
||||
public int getRows() {
|
||||
if(this.data == null)
|
||||
return 0;
|
||||
|
||||
return data.length;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the number of rows in the Matrix
|
||||
*
|
||||
* @return columns
|
||||
*/
|
||||
public int getColumns() {
|
||||
if(this.data == null)
|
||||
return 0;
|
||||
return data[0].length;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns this matrix scaled by a factor. That is, computes sA where s is a
|
||||
* constant and A is a matrix (this object).
|
||||
*
|
||||
* @param scalar : value to scale by
|
||||
* @return A new matrix scaled by the scalar value
|
||||
*/
|
||||
public Matrix scale(int scalar) {
|
||||
|
||||
int[][] newData = new int[this.data.length][this.data[0].length];
|
||||
|
||||
for (int i = 0; i < this.getRows(); ++i)
|
||||
for(int j = 0; j < this.getColumns(); ++j)
|
||||
newData[i][j] = this.data[i][j] * scalar;
|
||||
|
||||
return new Matrix(newData);
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds this matrix to another matrix.
|
||||
*
|
||||
* @param other : Matrix to be added
|
||||
* @return addend
|
||||
*/
|
||||
public Matrix plus(Matrix other) throws RuntimeException {
|
||||
|
||||
int[][] newData = new int[this.data.length][this.data[0].length];
|
||||
|
||||
if(this.getRows() != other.getRows() || this.getColumns() != other.getColumns())
|
||||
throw new RuntimeException("Not the same size matrix.");
|
||||
|
||||
for (int i = 0; i < this.getRows(); ++i)
|
||||
for(int j = 0; j < this.getColumns(); ++j)
|
||||
newData[i][j] = this.data[i][j] + other.getElement(i, j);
|
||||
|
||||
return new Matrix(newData);
|
||||
}
|
||||
|
||||
/**
|
||||
* Subtracts this matrix from another matrix.
|
||||
*
|
||||
* @param other : Matrix to be subtracted
|
||||
* @return difference
|
||||
*/
|
||||
public Matrix minus(Matrix other) throws RuntimeException {
|
||||
|
||||
int[][] newData = new int[this.data.length][this.data[0].length];
|
||||
|
||||
if(this.getRows() != other.getRows() || this.getColumns() != other.getColumns())
|
||||
throw new RuntimeException("Not the same size matrix.");
|
||||
|
||||
for (int i = 0; i < this.getRows(); ++i)
|
||||
for(int j = 0; j < this.getColumns(); ++j)
|
||||
newData[i][j] = this.data[i][j] - other.getElement(i, j);
|
||||
|
||||
return new Matrix(newData);
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the matrix passed is equal to this matrix
|
||||
*
|
||||
* @param other : the other matrix
|
||||
* @return boolean
|
||||
*/
|
||||
public boolean equals(Matrix other) {
|
||||
return this == other;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the Matrix as a String in the following format
|
||||
*
|
||||
* [ a b c ] ...
|
||||
* [ x y z ] ...
|
||||
* [ i j k ] ...
|
||||
* ...
|
||||
*
|
||||
* @return Matrix as String
|
||||
* TODO: Work formatting for different digit sizes
|
||||
*/
|
||||
public String toString() {
|
||||
String str = "";
|
||||
|
||||
for(int i = 0; i < this.data.length; i++) {
|
||||
str += "[ ";
|
||||
for(int j = 0; j < this.data[0].length; j++) {
|
||||
str += data[i][j];
|
||||
str += " ";
|
||||
}
|
||||
str += "]";
|
||||
str += "\n";
|
||||
}
|
||||
|
||||
return str;
|
||||
}
|
||||
}
|
||||
123
Data Structures/Queues/PriorityQueues.java
Normal file
123
Data Structures/Queues/PriorityQueues.java
Normal file
@@ -0,0 +1,123 @@
|
||||
/**
|
||||
* This class implements a PriorityQueue.
|
||||
*
|
||||
* A priority queue adds elements into positions based on their priority.
|
||||
* So the most important elements are placed at the front/on the top.
|
||||
* In this example I give numbers that are bigger, a higher priority.
|
||||
* Queues in theory have no fixed size but when using an array
|
||||
* implementation it does.
|
||||
*
|
||||
* @author Unknown
|
||||
*
|
||||
*/
|
||||
class PriorityQueue{
|
||||
/** The max size of the queue */
|
||||
private int maxSize;
|
||||
/** The array for the queue */
|
||||
private int[] queueArray;
|
||||
/** How many items are in the queue */
|
||||
private int nItems;
|
||||
|
||||
/**
|
||||
* Constructor
|
||||
*
|
||||
* @param size Size of the queue
|
||||
*/
|
||||
public PriorityQueue(int size){
|
||||
maxSize = size;
|
||||
queueArray = new int[size];
|
||||
nItems = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Inserts an element in it's appropriate place
|
||||
*
|
||||
* @param value Value to be inserted
|
||||
*/
|
||||
public void insert(int value){
|
||||
if(nItems == 0){
|
||||
queueArray[0] = value;
|
||||
}
|
||||
else{
|
||||
int j = nItems;
|
||||
while(j > 0 && queueArray[j-1] > value){
|
||||
queueArray[j] = queueArray[j-1]; //Shifts every element up to make room for insertion
|
||||
j--;
|
||||
}
|
||||
queueArray[j] = value; //Once the correct position is found the value is inserted
|
||||
}
|
||||
nItems++;
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove the element from the front of the queue
|
||||
*
|
||||
* @return The element removed
|
||||
*/
|
||||
public int remove(){
|
||||
return queueArray[--nItems];
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks what's at the front of the queue
|
||||
*
|
||||
* @return element at the front of the queue
|
||||
*/
|
||||
public int peek(){
|
||||
return queueArray[nItems-1];
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if the queue is empty
|
||||
*
|
||||
* @return true if the queue is empty
|
||||
*/
|
||||
public boolean isEmpty(){
|
||||
return(nItems == 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if the queue is full
|
||||
*
|
||||
* @return true if the queue is full
|
||||
*/
|
||||
public boolean isFull(){
|
||||
return(nItems == maxSize);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the number of elements in the queue
|
||||
*
|
||||
* @return number of elements in the queue
|
||||
*/
|
||||
public int getSize(){
|
||||
return nItems;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* This class implements the PriorityQueue class above.
|
||||
*
|
||||
* @author Unknown
|
||||
*
|
||||
*/
|
||||
public class PriorityQueues{
|
||||
/**
|
||||
* Main method
|
||||
*
|
||||
* @param args Command Line Arguments
|
||||
*/
|
||||
public static void main(String args[]){
|
||||
PriorityQueue myQueue = new PriorityQueue(4);
|
||||
myQueue.insert(10);
|
||||
myQueue.insert(2);
|
||||
myQueue.insert(5);
|
||||
myQueue.insert(3);
|
||||
//[2, 3, 5, 10] Here higher numbers have higher priority, so they are on the top
|
||||
|
||||
for(int i = 3; i>=0; i--)
|
||||
System.out.print(myQueue.remove() + " "); //will print the queue in reverse order [10, 5, 3, 2]
|
||||
|
||||
//As you can see, a Priority Queue can be used as a sorting algotithm
|
||||
}
|
||||
}
|
||||
148
Data Structures/Queues/Queues.java
Normal file
148
Data Structures/Queues/Queues.java
Normal file
@@ -0,0 +1,148 @@
|
||||
/**
|
||||
* This implements Queues by using the class Queue.
|
||||
*
|
||||
* A queue data structure functions the same as a real world queue.
|
||||
* The elements that are added first are the first to be removed.
|
||||
* New elements are added to the back/rear of the queue.
|
||||
*
|
||||
* @author Unknown
|
||||
*
|
||||
*/
|
||||
class Queue{
|
||||
/** Max size of the queue */
|
||||
private int maxSize;
|
||||
/** The array representing the queue */
|
||||
private int[] queueArray;
|
||||
/** Front of the queue */
|
||||
private int front;
|
||||
/** Rear of the queue */
|
||||
private int rear;
|
||||
/** How many items are in the queue */
|
||||
private int nItems;
|
||||
|
||||
/**
|
||||
* Constructor
|
||||
*
|
||||
* @param size Size of the new queue
|
||||
*/
|
||||
public Queue(int size){
|
||||
maxSize = size;
|
||||
queueArray = new int[size];
|
||||
front = 0;
|
||||
rear = -1;
|
||||
nItems = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Inserts an element at the rear of the queue
|
||||
*
|
||||
* @param x element to be added
|
||||
* @return True if the element was added successfully
|
||||
*/
|
||||
public boolean insert(int x){
|
||||
if(isFull())
|
||||
return false;
|
||||
if(rear == maxSize-1) //If the back of the queue is the end of the array wrap around to the front
|
||||
rear = -1;
|
||||
rear++;
|
||||
queueArray[rear] = x;
|
||||
nItems++;
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove an element from the front of the queue
|
||||
*
|
||||
* @return the new front of the queue
|
||||
*/
|
||||
public int remove(){ //Remove an element from the front of the queue
|
||||
if(isEmpty()){
|
||||
System.out.println("Queue is empty");
|
||||
return -1;
|
||||
}
|
||||
int temp = queueArray[front];
|
||||
front++;
|
||||
if(front == maxSize) //Dealing with wrap-around again
|
||||
front = 0;
|
||||
nItems--;
|
||||
return temp;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks what's at the front of the queue
|
||||
*
|
||||
* @return element at the front of the queue
|
||||
*/
|
||||
public int peekFront(){
|
||||
return queueArray[front];
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks what's at the rear of the queue
|
||||
*
|
||||
* @return element at the rear of the queue
|
||||
*/
|
||||
public int peekRear(){
|
||||
return queueArray[rear];
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if the queue is empty
|
||||
*
|
||||
* @return true if the queue is empty
|
||||
*/
|
||||
public boolean isEmpty(){
|
||||
return(nItems == 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if the queue is full
|
||||
*
|
||||
* @return true if the queue is full
|
||||
*/
|
||||
public boolean isFull(){
|
||||
return(nItems == maxSize);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the number of elements in the queue
|
||||
*
|
||||
* @return number of elements in the queue
|
||||
*/
|
||||
public int getSize(){
|
||||
return nItems;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* This class is the example for the Queue class
|
||||
*
|
||||
* @author Unknown
|
||||
*
|
||||
*/
|
||||
public class Queues{
|
||||
/**
|
||||
* Main method
|
||||
*
|
||||
* @param args Command line arguments
|
||||
*/
|
||||
public static void main(String args[]){
|
||||
Queue myQueue = new Queue(4);
|
||||
myQueue.insert(10);
|
||||
myQueue.insert(2);
|
||||
myQueue.insert(5);
|
||||
myQueue.insert(3);
|
||||
//[10(front), 2, 5, 3(rear)]
|
||||
|
||||
System.out.println(myQueue.isFull()); //Will print true
|
||||
|
||||
myQueue.remove(); //Will make 2 the new front, making 10 no longer part of the queue
|
||||
//[10, 2(front), 5, 3(rear)]
|
||||
|
||||
myQueue.insert(7); //Insert 7 at the rear which will be index 0 because of wrap around
|
||||
// [7(rear), 2(front), 5, 3]
|
||||
|
||||
System.out.println(myQueue.peekFront()); //Will print 2
|
||||
System.out.println(myQueue.peekRear()); //Will print 7
|
||||
}
|
||||
}
|
||||
183
Data Structures/Stacks/NodeStack.java
Normal file
183
Data Structures/Stacks/NodeStack.java
Normal file
@@ -0,0 +1,183 @@
|
||||
/**
|
||||
* Implementation of a stack using nodes.
|
||||
* Unlimited size, no arraylist.
|
||||
*
|
||||
* @author Kyler Smith, 2017
|
||||
*/
|
||||
|
||||
|
||||
public class NodeStack<Item> {
|
||||
|
||||
/**
|
||||
* Entry point for the program.
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
NodeStack<Integer> Stack = new NodeStack<Integer>();
|
||||
|
||||
Stack.push(3);
|
||||
Stack.push(4);
|
||||
Stack.push(5);
|
||||
System.out.println("Testing :");
|
||||
Stack.print(); // prints : 5 4 3
|
||||
|
||||
Integer x = Stack.pop(); // x = 5
|
||||
Stack.push(1);
|
||||
Stack.push(8);
|
||||
Integer y = Stack.peek(); // y = 8
|
||||
System.out.println("Testing :");
|
||||
Stack.print(); // prints : 8 1 4 3
|
||||
|
||||
System.out.println("Testing :");
|
||||
System.out.println("x : " + x);
|
||||
System.out.println("y : " + y);
|
||||
}
|
||||
|
||||
/**
|
||||
* Information each node should contain.
|
||||
* @value data : information of the value in the node
|
||||
* @value head : the head of the stack
|
||||
* @value next : the next value from this node
|
||||
* @value previous : the last value from this node
|
||||
* @value size : size of the stack
|
||||
*/
|
||||
private Item data;
|
||||
private static NodeStack<?> head;
|
||||
private NodeStack<?> next;
|
||||
private NodeStack<?> previous;
|
||||
private static int size = 0;
|
||||
|
||||
|
||||
/**
|
||||
* Constructors for the NodeStack.
|
||||
*/
|
||||
public NodeStack() {
|
||||
}
|
||||
|
||||
private NodeStack(Item item) {
|
||||
this.data = item;
|
||||
}
|
||||
|
||||
/**
|
||||
* Put a value onto the stack.
|
||||
*
|
||||
* @param item : value to be put on the stack.
|
||||
*/
|
||||
public void push(Item item) {
|
||||
|
||||
NodeStack<Item> newNs = new NodeStack<Item>(item);
|
||||
|
||||
if(this.isEmpty()) {
|
||||
NodeStack.setHead(new NodeStack<>(item));
|
||||
newNs.setNext(null);
|
||||
newNs.setPrevious(null);
|
||||
} else {
|
||||
newNs.setPrevious(NodeStack.head);
|
||||
NodeStack.head.setNext(newNs);
|
||||
NodeStack.head = newNs;
|
||||
}
|
||||
|
||||
NodeStack.setSize(NodeStack.getSize() + 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Value to be taken off the stack.
|
||||
*
|
||||
* @return item : value that is returned.
|
||||
*/
|
||||
public Item pop() {
|
||||
|
||||
Item item = (Item) NodeStack.head.getData();
|
||||
|
||||
NodeStack.head = NodeStack.head.getPrevious();
|
||||
NodeStack.head.setNext(null);
|
||||
|
||||
NodeStack.setSize(NodeStack.getSize() - 1);
|
||||
|
||||
return item;
|
||||
}
|
||||
|
||||
/**
|
||||
* Value that is next to be taken off the stack.
|
||||
*
|
||||
* @return item : the next value that would be popped off the stack.
|
||||
*/
|
||||
public Item peek() {
|
||||
return (Item) NodeStack.head.getData();
|
||||
}
|
||||
|
||||
/**
|
||||
* If the stack is empty or there is a value in.
|
||||
*
|
||||
* @return boolean : whether or not the stack has anything in it.
|
||||
*/
|
||||
public boolean isEmpty() {
|
||||
return NodeStack.getSize() == 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the size of the stack.
|
||||
*
|
||||
* @return int : number of values in the stack.
|
||||
*/
|
||||
public int size() {
|
||||
return NodeStack.getSize();
|
||||
}
|
||||
|
||||
/**
|
||||
* Print the contents of the stack in the following format.
|
||||
*
|
||||
* x <- head (next out)
|
||||
* y
|
||||
* z <- tail (first in)
|
||||
* .
|
||||
* .
|
||||
* .
|
||||
*
|
||||
*/
|
||||
public void print() {
|
||||
for(NodeStack<?> n = NodeStack.head; n != null; n = n.previous) {
|
||||
System.out.println(n.getData().toString());
|
||||
}
|
||||
}
|
||||
|
||||
/** Getters and setters (private) */
|
||||
private NodeStack<?> getHead() {
|
||||
return NodeStack.head;
|
||||
}
|
||||
|
||||
private static void setHead(NodeStack<?> ns) {
|
||||
NodeStack.head = ns;
|
||||
}
|
||||
|
||||
private NodeStack<?> getNext() {
|
||||
return next;
|
||||
}
|
||||
|
||||
private void setNext(NodeStack<?> next) {
|
||||
this.next = next;
|
||||
}
|
||||
|
||||
private NodeStack<?> getPrevious() {
|
||||
return previous;
|
||||
}
|
||||
|
||||
private void setPrevious(NodeStack<?> previous) {
|
||||
this.previous = previous;
|
||||
}
|
||||
|
||||
private static int getSize() {
|
||||
return size;
|
||||
}
|
||||
|
||||
private static void setSize(int size) {
|
||||
NodeStack.size = size;
|
||||
}
|
||||
|
||||
private Item getData() {
|
||||
return this.data;
|
||||
}
|
||||
|
||||
private void setData(Item item) {
|
||||
this.data = item;
|
||||
}
|
||||
}
|
||||
221
Data Structures/Stacks/Stacks.java
Normal file
221
Data Structures/Stacks/Stacks.java
Normal file
@@ -0,0 +1,221 @@
|
||||
import java.util.ArrayList;
|
||||
|
||||
/**
|
||||
* This class implements a Stack using two different implementations.
|
||||
* Stack is used with a regular array and Stack2 uses an ArrayList.
|
||||
*
|
||||
* A stack is exactly what it sounds like. An element gets added to the top of
|
||||
* the stack and only the element on the top may be removed. This is an example
|
||||
* of an array implementation of a Stack. So an element can only be added/removed
|
||||
* from the end of the array. In theory stack have no fixed size, but with an
|
||||
* array implementation it does.
|
||||
*
|
||||
* @author Unknown
|
||||
*
|
||||
*/
|
||||
class Stack{
|
||||
/** The max size of the Stack */
|
||||
private int maxSize;
|
||||
/** The array representation of the Stack */
|
||||
private int[] stackArray;
|
||||
/** The top of the stack */
|
||||
private int top;
|
||||
|
||||
/**
|
||||
* Constructor
|
||||
*
|
||||
* @param size Size of the Stack
|
||||
*/
|
||||
public Stack(int size){
|
||||
maxSize = size;
|
||||
stackArray = new int[maxSize];
|
||||
top = -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds an element to the top of the stack
|
||||
*
|
||||
* @param value The element added
|
||||
*/
|
||||
public void push(int value){
|
||||
if(!isFull()){ //Checks for a full stack
|
||||
top++;
|
||||
stackArray[top] = value;
|
||||
}else{
|
||||
System.out.println("The stack is full, can't insert value");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes the top element of the stack and returns the value you've removed
|
||||
*
|
||||
* @return value popped off the Stack
|
||||
*/
|
||||
public int pop(){
|
||||
if(!isEmpty()){ //Checks for an empty stack
|
||||
return stackArray[top--];
|
||||
}else{
|
||||
System.out.println("The stack is already empty");
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the element at the top of the stack
|
||||
*
|
||||
* @return element at the top of the stack
|
||||
*/
|
||||
public int peek(){
|
||||
if(!isEmpty()){ //Checks for an empty stack
|
||||
return stackArray[top];
|
||||
}else{
|
||||
System.out.println("The stack is empty, cant peek");
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if the stack is empty
|
||||
*
|
||||
* @return true if the stack is empty
|
||||
*/
|
||||
public boolean isEmpty(){
|
||||
return(top == -1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if the stack is full
|
||||
*
|
||||
* @return true if the stack is full
|
||||
*/
|
||||
public boolean isFull(){
|
||||
return(top+1 == maxSize);
|
||||
}
|
||||
|
||||
/**
|
||||
* Deletes everything in the Stack
|
||||
*
|
||||
* Doesn't delete elements in the array
|
||||
* but if you call push method after calling
|
||||
* makeEmpty it will overwrite previous
|
||||
* values
|
||||
*/
|
||||
public void makeEmpty(){ //Doesn't delete elements in the array but if you call
|
||||
top = -1; //push method after calling makeEmpty it will overwrite previous values
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* This is an ArrayList Implementation of stack, Where size is not
|
||||
* a problem we can extend the stack as much as we want.
|
||||
*
|
||||
* @author Unknown
|
||||
*
|
||||
*/
|
||||
class Stack2{
|
||||
/** ArrayList representation of the stack */
|
||||
ArrayList<Integer> stackList;
|
||||
|
||||
/**
|
||||
* Constructor
|
||||
*/
|
||||
Stack2(){
|
||||
stackList=new ArrayList<>();
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds value to the end of list which
|
||||
* is the top for stack
|
||||
*
|
||||
* @param value value to be added
|
||||
*/
|
||||
void push(int value){
|
||||
stackList.add(value);
|
||||
}
|
||||
|
||||
/**
|
||||
* Pops last element of list which is indeed
|
||||
* the top for Stack
|
||||
*
|
||||
* @return Element popped
|
||||
*/
|
||||
int pop(){
|
||||
|
||||
if(!isEmpty()){ // checks for an empty Stack
|
||||
|
||||
int popValue=stackList.get(stackList.size()-1);
|
||||
stackList.remove(stackList.size()-1); //removes the poped element from the list
|
||||
return popValue;
|
||||
}
|
||||
else{
|
||||
System.out.print("The stack is already empty ");
|
||||
return -1;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks for empty Stack
|
||||
*
|
||||
* @return true if stack is empty
|
||||
*/
|
||||
boolean isEmpty(){
|
||||
if(stackList.isEmpty())
|
||||
return true;
|
||||
|
||||
else return false;
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Top element of stack
|
||||
*
|
||||
* @return top element of stack
|
||||
*/
|
||||
int peek(){
|
||||
return stackList.get(stackList.size()-1);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* This class implements the Stack and Stack2 created above
|
||||
*
|
||||
* @author Unknown
|
||||
*
|
||||
*/
|
||||
public class Stacks{
|
||||
/**
|
||||
* Main method
|
||||
*
|
||||
* @param args Command line arguments
|
||||
*/
|
||||
public static void main(String args[]){
|
||||
Stack myStack = new Stack(4); //Declare a stack of maximum size 4
|
||||
//Populate the stack
|
||||
myStack.push(5);
|
||||
myStack.push(8);
|
||||
myStack.push(2);
|
||||
myStack.push(9);
|
||||
|
||||
System.out.println("*********************Stack Array Implementation*********************");
|
||||
System.out.println(myStack.isEmpty()); //will print false
|
||||
System.out.println(myStack.isFull()); //will print true
|
||||
System.out.println(myStack.peek()); //will print 9
|
||||
System.out.println(myStack.pop()); //will print 9
|
||||
System.out.println(myStack.peek()); // will print 2
|
||||
|
||||
Stack2 myStack2 = new Stack2(); //Declare a stack of maximum size 4
|
||||
//Populate the stack
|
||||
myStack2.push(5);
|
||||
myStack2.push(8);
|
||||
myStack2.push(2);
|
||||
myStack2.push(9);
|
||||
|
||||
System.out.println("*********************Stack List Implementation*********************");
|
||||
System.out.println(myStack2.isEmpty()); //will print false
|
||||
System.out.println(myStack2.peek()); //will print 9
|
||||
System.out.println(myStack2.pop()); //will print 9
|
||||
System.out.println(myStack2.peek()); // will print 2
|
||||
System.out.println(myStack2.pop()); //will print 2
|
||||
}
|
||||
}
|
||||
212
Data Structures/Trees/AVLTree.java
Normal file
212
Data Structures/Trees/AVLTree.java
Normal file
@@ -0,0 +1,212 @@
|
||||
public class AVLtree {
|
||||
|
||||
private Node root;
|
||||
|
||||
private class Node {
|
||||
private int key;
|
||||
private int balance;
|
||||
private int height;
|
||||
private Node left, right, parent;
|
||||
|
||||
Node(int k, Node p) {
|
||||
key = k;
|
||||
parent = p;
|
||||
}
|
||||
}
|
||||
|
||||
public boolean insert(int key) {
|
||||
if (root == null)
|
||||
root = new Node(key, null);
|
||||
else {
|
||||
Node n = root;
|
||||
Node parent;
|
||||
while (true) {
|
||||
if (n.key == key)
|
||||
return false;
|
||||
|
||||
parent = n;
|
||||
|
||||
boolean goLeft = n.key > key;
|
||||
n = goLeft ? n.left : n.right;
|
||||
|
||||
if (n == null) {
|
||||
if (goLeft) {
|
||||
parent.left = new Node(key, parent);
|
||||
} else {
|
||||
parent.right = new Node(key, parent);
|
||||
}
|
||||
rebalance(parent);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
private void delete(Node node){
|
||||
if(node.left == null && node.right == null){
|
||||
if(node.parent == null) root = null;
|
||||
else{
|
||||
Node parent = node.parent;
|
||||
if(parent.left == node){
|
||||
parent.left = null;
|
||||
}else parent.right = null;
|
||||
rebalance(parent);
|
||||
}
|
||||
return;
|
||||
}
|
||||
if(node.left!=null){
|
||||
Node child = node.left;
|
||||
while (child.right!=null) child = child.right;
|
||||
node.key = child.key;
|
||||
delete(child);
|
||||
}else{
|
||||
Node child = node.right;
|
||||
while (child.left!=null) child = child.left;
|
||||
node.key = child.key;
|
||||
delete(child);
|
||||
}
|
||||
}
|
||||
|
||||
public void delete(int delKey) {
|
||||
if (root == null)
|
||||
return;
|
||||
Node node = root;
|
||||
Node child = root;
|
||||
|
||||
while (child != null) {
|
||||
node = child;
|
||||
child = delKey >= node.key ? node.right : node.left;
|
||||
if (delKey == node.key) {
|
||||
delete(node);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void rebalance(Node n) {
|
||||
setBalance(n);
|
||||
|
||||
if (n.balance == -2) {
|
||||
if (height(n.left.left) >= height(n.left.right))
|
||||
n = rotateRight(n);
|
||||
else
|
||||
n = rotateLeftThenRight(n);
|
||||
|
||||
} else if (n.balance == 2) {
|
||||
if (height(n.right.right) >= height(n.right.left))
|
||||
n = rotateLeft(n);
|
||||
else
|
||||
n = rotateRightThenLeft(n);
|
||||
}
|
||||
|
||||
if (n.parent != null) {
|
||||
rebalance(n.parent);
|
||||
} else {
|
||||
root = n;
|
||||
}
|
||||
}
|
||||
|
||||
private Node rotateLeft(Node a) {
|
||||
|
||||
Node b = a.right;
|
||||
b.parent = a.parent;
|
||||
|
||||
a.right = b.left;
|
||||
|
||||
if (a.right != null)
|
||||
a.right.parent = a;
|
||||
|
||||
b.left = a;
|
||||
a.parent = b;
|
||||
|
||||
if (b.parent != null) {
|
||||
if (b.parent.right == a) {
|
||||
b.parent.right = b;
|
||||
} else {
|
||||
b.parent.left = b;
|
||||
}
|
||||
}
|
||||
|
||||
setBalance(a, b);
|
||||
|
||||
return b;
|
||||
}
|
||||
|
||||
private Node rotateRight(Node a) {
|
||||
|
||||
Node b = a.left;
|
||||
b.parent = a.parent;
|
||||
|
||||
a.left = b.right;
|
||||
|
||||
if (a.left != null)
|
||||
a.left.parent = a;
|
||||
|
||||
b.right = a;
|
||||
a.parent = b;
|
||||
|
||||
if (b.parent != null) {
|
||||
if (b.parent.right == a) {
|
||||
b.parent.right = b;
|
||||
} else {
|
||||
b.parent.left = b;
|
||||
}
|
||||
}
|
||||
|
||||
setBalance(a, b);
|
||||
|
||||
return b;
|
||||
}
|
||||
|
||||
private Node rotateLeftThenRight(Node n) {
|
||||
n.left = rotateLeft(n.left);
|
||||
return rotateRight(n);
|
||||
}
|
||||
|
||||
private Node rotateRightThenLeft(Node n) {
|
||||
n.right = rotateRight(n.right);
|
||||
return rotateLeft(n);
|
||||
}
|
||||
|
||||
private int height(Node n) {
|
||||
if (n == null)
|
||||
return -1;
|
||||
return n.height;
|
||||
}
|
||||
|
||||
private void setBalance(Node... nodes) {
|
||||
for (Node n : nodes)
|
||||
reheight(n);
|
||||
n.balance = height(n.right) - height(n.left);
|
||||
}
|
||||
|
||||
public void printBalance() {
|
||||
printBalance(root);
|
||||
}
|
||||
|
||||
private void printBalance(Node n) {
|
||||
if (n != null) {
|
||||
printBalance(n.left);
|
||||
System.out.printf("%s ", n.balance);
|
||||
printBalance(n.right);
|
||||
}
|
||||
}
|
||||
|
||||
private void reheight(Node node){
|
||||
if(node!=null){
|
||||
node.height=1 + Math.max(height(node.left), height(node.right));
|
||||
}
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
AVLtree tree = new AVLtree();
|
||||
|
||||
System.out.println("Inserting values 1 to 10");
|
||||
for (int i = 1; i < 10; i++)
|
||||
tree.insert(i);
|
||||
|
||||
System.out.print("Printing balance: ");
|
||||
tree.printBalance();
|
||||
}
|
||||
}
|
||||
268
Data Structures/Trees/BinaryTree.java
Normal file
268
Data Structures/Trees/BinaryTree.java
Normal file
@@ -0,0 +1,268 @@
|
||||
/**
|
||||
* This entire class is used to build a Binary Tree data structure.
|
||||
* There is the Node Class and the Tree Class, both explained below.
|
||||
*
|
||||
* @author Unknown
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* This class implements the nodes that will go on the Binary Tree.
|
||||
* They consist of the data in them, the node to the left, the node
|
||||
* to the right, and the parent from which they came from.
|
||||
*
|
||||
* @author Unknown
|
||||
*
|
||||
*/
|
||||
class Node{
|
||||
/** Data for the node */
|
||||
public int data;
|
||||
/** The Node to the left of this one */
|
||||
public Node left;
|
||||
/** The Node to the right of this one */
|
||||
public Node right;
|
||||
/** The parent of this node */
|
||||
public Node parent;
|
||||
|
||||
/**
|
||||
* Constructor of Node
|
||||
*
|
||||
* @param value Value to put in the node
|
||||
*/
|
||||
public Node(int value){
|
||||
data = value;
|
||||
left = null;
|
||||
right = null;
|
||||
parent = null;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* A binary tree is a data structure in which an element
|
||||
* has two successors(children). The left child is usually
|
||||
* smaller than the parent, and the right child is usually
|
||||
* bigger.
|
||||
*
|
||||
* @author Unknown
|
||||
*
|
||||
*/
|
||||
class Tree{
|
||||
/** The root of the Binary Tree */
|
||||
private Node root;
|
||||
|
||||
/**
|
||||
* Constructor
|
||||
*/
|
||||
public Tree(){
|
||||
root = null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Method to find a Node with a certain value
|
||||
*
|
||||
* @param key Value being looked for
|
||||
* @return The node if it finds it, otherwise returns the parent
|
||||
*/
|
||||
public Node find(int key) {
|
||||
Node current = root;
|
||||
while (current != null) {
|
||||
if(key < current.data) {
|
||||
current = current.left;
|
||||
} else if(key > current.data) {
|
||||
current = current.right;
|
||||
} else { // If you find the value return it
|
||||
return current;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Inserts certain value into the Binary Tree
|
||||
*
|
||||
* @param value Value to be inserted
|
||||
*/
|
||||
public void put(int value){
|
||||
Node newNode = new Node(value);
|
||||
if(root == null)
|
||||
root = newNode;
|
||||
else{
|
||||
//This will return the soon to be parent of the value you're inserting
|
||||
Node parent = find(value);
|
||||
|
||||
//This if/else assigns the new node to be either the left or right child of the parent
|
||||
if(value < parent.data){
|
||||
parent.left = newNode;
|
||||
parent.left.parent = parent;
|
||||
return;
|
||||
}
|
||||
else{
|
||||
parent.right = newNode;
|
||||
parent.right.parent = parent;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Deletes a given value from the Binary Tree
|
||||
*
|
||||
* @param value Value to be deleted
|
||||
* @return If the value was deleted
|
||||
*/
|
||||
public boolean remove(int value){
|
||||
//temp is the node to be deleted
|
||||
Node temp = find(value);
|
||||
|
||||
//If the value doesn't exist
|
||||
if(temp.data != value)
|
||||
return false;
|
||||
|
||||
//No children
|
||||
if(temp.right == null && temp.left == null){
|
||||
if(temp == root)
|
||||
root = null;
|
||||
|
||||
//This if/else assigns the new node to be either the left or right child of the parent
|
||||
else if(temp.parent.data < temp.data)
|
||||
temp.parent.right = null;
|
||||
else
|
||||
temp.parent.left = null;
|
||||
return true;
|
||||
}
|
||||
|
||||
//Two children
|
||||
else if(temp.left != null && temp.right != null){
|
||||
Node successor = findSuccessor(temp);
|
||||
|
||||
//The left tree of temp is made the left tree of the successor
|
||||
successor.left = temp.left;
|
||||
successor.left.parent = successor;
|
||||
|
||||
//If the successor has a right child, the child's grandparent is it's new parent
|
||||
if(successor.right != null && successor.parent != temp){
|
||||
successor.right.parent = successor.parent;
|
||||
successor.parent.left = successor.right;
|
||||
successor.right = temp.right;
|
||||
successor.right.parent = successor;
|
||||
}
|
||||
if(temp == root){
|
||||
successor.parent = null;
|
||||
root = successor;
|
||||
return true;
|
||||
}
|
||||
|
||||
//If you're not deleting the root
|
||||
else{
|
||||
successor.parent = temp.parent;
|
||||
|
||||
//This if/else assigns the new node to be either the left or right child of the parent
|
||||
if(temp.parent.data < temp.data)
|
||||
temp.parent.right = successor;
|
||||
else
|
||||
temp.parent.left = successor;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
//One child
|
||||
else{
|
||||
//If it has a right child
|
||||
if(temp.right != null){
|
||||
if(temp == root){
|
||||
root = temp.right; return true;}
|
||||
|
||||
temp.right.parent = temp.parent;
|
||||
|
||||
//Assigns temp to left or right child
|
||||
if(temp.data < temp.parent.data)
|
||||
temp.parent.left = temp.right;
|
||||
else
|
||||
temp.parent.right = temp.right;
|
||||
return true;
|
||||
}
|
||||
//If it has a left child
|
||||
else{
|
||||
if(temp == root){
|
||||
root = temp.left; return true;}
|
||||
|
||||
temp.left.parent = temp.parent;
|
||||
|
||||
//Assigns temp to left or right side
|
||||
if(temp.data < temp.parent.data)
|
||||
temp.parent.left = temp.left;
|
||||
else
|
||||
temp.parent.right = temp.left;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* This method finds the Successor to the Node given.
|
||||
* Move right once and go left down the tree as far as you can
|
||||
*
|
||||
* @param n Node that you want to find the Successor of
|
||||
* @return The Successor of the node
|
||||
*/
|
||||
public Node findSuccessor(Node n){
|
||||
if(n.right == null)
|
||||
return n;
|
||||
Node current = n.right;
|
||||
Node parent = n.right;
|
||||
while(current != null){
|
||||
parent = current;
|
||||
current = current.left;
|
||||
}
|
||||
return parent;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the root of the Binary Tree
|
||||
*
|
||||
* @return the root of the Binary Tree
|
||||
*/
|
||||
public Node getRoot(){
|
||||
return root;
|
||||
}
|
||||
|
||||
/**
|
||||
* Prints leftChild - root - rightChild
|
||||
*
|
||||
* @param localRoot The local root of the binary tree
|
||||
*/
|
||||
public void inOrder(Node localRoot){
|
||||
if(localRoot != null){
|
||||
inOrder(localRoot.left);
|
||||
System.out.print(localRoot.data + " ");
|
||||
inOrder(localRoot.right);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Prints root - leftChild - rightChild
|
||||
*
|
||||
* @param localRoot The local root of the binary tree
|
||||
*/
|
||||
public void preOrder(Node localRoot){
|
||||
if(localRoot != null){
|
||||
System.out.print(localRoot.data + " ");
|
||||
preOrder(localRoot.left);
|
||||
preOrder(localRoot.right);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Prints rightChild - leftChild - root
|
||||
*
|
||||
* @param localRoot The local root of the binary tree
|
||||
*/
|
||||
public void postOrder(Node localRoot){
|
||||
if(localRoot != null){
|
||||
postOrder(localRoot.left);
|
||||
postOrder(localRoot.right);
|
||||
System.out.print(localRoot.data + " ");
|
||||
}
|
||||
}
|
||||
}
|
||||
226
Data Structures/Trees/GenericTree.Java
Normal file
226
Data Structures/Trees/GenericTree.Java
Normal file
@@ -0,0 +1,226 @@
|
||||
import java.util.ArrayList;
|
||||
import java.util.LinkedList;
|
||||
import java.util.Scanner;
|
||||
|
||||
public class treeclass {
|
||||
private class Node {
|
||||
int data;
|
||||
ArrayList<Node> child = new ArrayList<>();
|
||||
}
|
||||
|
||||
private Node root;
|
||||
private int size;
|
||||
|
||||
/*
|
||||
A generic tree is a tree which can have as many children as it can be
|
||||
It might be possible that every node present is directly connected to
|
||||
root node.
|
||||
|
||||
In this code
|
||||
Every function has two copies: one function is helper function which can be called from
|
||||
main and from that function a private function is called which will do the actual work.
|
||||
I have done this, while calling from main one have to give minimum parameters.
|
||||
|
||||
*/
|
||||
public treeclass() { //Constructor
|
||||
Scanner scn = new Scanner(System.in);
|
||||
root = create_treeG(null, 0, scn);
|
||||
}
|
||||
|
||||
private Node create_treeG(Node node, int childindx, Scanner scn) {
|
||||
// display
|
||||
if (node == null) {
|
||||
System.out.println("Enter root's data");
|
||||
} else {
|
||||
System.out.println("Enter data of parent of index " + node.data + " " + childindx);
|
||||
}
|
||||
// input
|
||||
node = new Node();
|
||||
node.data = scn.nextInt();
|
||||
System.out.println("number of children");
|
||||
int number = scn.nextInt();
|
||||
for (int i = 0; i < number; i++) {
|
||||
Node childd = create_treeG(node, i, scn);
|
||||
size++;
|
||||
node.child.add(childd);
|
||||
}
|
||||
return node;
|
||||
}
|
||||
|
||||
/*
|
||||
Function to display the generic tree
|
||||
*/
|
||||
public void display() { //Helper function
|
||||
display_1(root);
|
||||
return;
|
||||
}
|
||||
|
||||
private void display_1(Node parent) {
|
||||
System.out.print(parent.data + "=>");
|
||||
for (int i = 0; i < parent.child.size(); i++) {
|
||||
System.out.print(parent.child.get(i).data + " ");
|
||||
}
|
||||
System.out.println(".");
|
||||
for (int i = 0; i < parent.child.size(); i++) {
|
||||
display_1(parent.child.get(i));
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
One call store the size directly but if you are asked compute size this function to calcuate
|
||||
size goes as follows
|
||||
*/
|
||||
|
||||
public int size2call() {
|
||||
return size2(root);
|
||||
}
|
||||
|
||||
public int size2(Node roott) {
|
||||
int sz = 0;
|
||||
for (int i = 0; i < roott.child.size(); i++) {
|
||||
sz += size2(roott.child.get(i));
|
||||
}
|
||||
return sz + 1;
|
||||
}
|
||||
|
||||
/*
|
||||
Function to compute maximum value in the generic tree
|
||||
*/
|
||||
public int maxcall() {
|
||||
int maxi = root.data;
|
||||
return max(root, maxi);
|
||||
}
|
||||
|
||||
private int max(Node roott, int maxi) {
|
||||
if (maxi < roott.data)
|
||||
maxi = roott.data;
|
||||
for (int i = 0; i < roott.child.size(); i++) {
|
||||
maxi = max(roott.child.get(i), maxi);
|
||||
}
|
||||
|
||||
return maxi;
|
||||
}
|
||||
|
||||
/*
|
||||
Function to compute HEIGHT of the generic tree
|
||||
*/
|
||||
|
||||
public int heightcall() {
|
||||
return height(root) - 1;
|
||||
}
|
||||
|
||||
private int height(Node node) {
|
||||
int h = 0;
|
||||
for (int i = 0; i < node.child.size(); i++) {
|
||||
int k = height(node.child.get(i));
|
||||
if (k > h)
|
||||
h = k;
|
||||
}
|
||||
return h + 1;
|
||||
}
|
||||
|
||||
/*
|
||||
Function to find whether a number is present in the generic tree or not
|
||||
*/
|
||||
|
||||
public boolean findcall(int info) {
|
||||
return find(root, info);
|
||||
}
|
||||
|
||||
private boolean find(Node node, int info) {
|
||||
if (node.data == info)
|
||||
return true;
|
||||
for (int i = 0; i < node.child.size(); i++) {
|
||||
if (find(node.child.get(i), info))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
Function to calculate depth of generic tree
|
||||
*/
|
||||
public void depthcaller(int dep) {
|
||||
depth(root, dep);
|
||||
}
|
||||
|
||||
public void depth(Node node, int dep) {
|
||||
if (dep == 0) {
|
||||
System.out.println(node.data);
|
||||
return;
|
||||
}
|
||||
for (int i = 0; i < node.child.size(); i++)
|
||||
depth(node.child.get(i), dep - 1);
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
Function to print generic tree in pre-order
|
||||
*/
|
||||
public void preordercall() {
|
||||
preorder(root);
|
||||
System.out.println(".");
|
||||
}
|
||||
|
||||
private void preorder(Node node) {
|
||||
System.out.print(node.data + " ");
|
||||
for (int i = 0; i < node.child.size(); i++)
|
||||
preorder(node.child.get(i));
|
||||
}
|
||||
|
||||
/*
|
||||
Function to print generic tree in post-order
|
||||
*/
|
||||
public void postordercall() {
|
||||
postorder(root);
|
||||
System.out.println(".");
|
||||
}
|
||||
|
||||
private void postorder(Node node) {
|
||||
for (int i = 0; i < node.child.size(); i++)
|
||||
postorder(node.child.get(i));
|
||||
System.out.print(node.data + " ");
|
||||
}
|
||||
|
||||
/*
|
||||
Function to print generic tree in level-order
|
||||
*/
|
||||
|
||||
public void levelorder() {
|
||||
LinkedList<Node> q = new LinkedList<>();
|
||||
q.addLast(root);
|
||||
while (!q.isEmpty()) {
|
||||
int k = q.getFirst().data;
|
||||
System.out.print(k + " ");
|
||||
|
||||
for (int i = 0; i < q.getFirst().child.size(); i++) {
|
||||
q.addLast(q.getFirst().child.get(i));
|
||||
}
|
||||
q.removeFirst();
|
||||
}
|
||||
System.out.println(".");
|
||||
}
|
||||
|
||||
/*
|
||||
Function to remove all leaves of generic tree
|
||||
*/
|
||||
public void removeleavescall() {
|
||||
removeleaves(root);
|
||||
}
|
||||
|
||||
private void removeleaves(Node node) {
|
||||
ArrayList<Integer> arr = new ArrayList<>();
|
||||
for (int i = 0; i < node.child.size(); i++) {
|
||||
if (node.child.get(i).child.size() == 0) {
|
||||
arr.add(i);
|
||||
// node.child.remove(i);
|
||||
// i--;
|
||||
} else
|
||||
removeleaves(node.child.get(i));
|
||||
}
|
||||
for (int i = arr.size() - 1; i >= 0; i--) {
|
||||
node.child.remove(arr.get(i) + 0);
|
||||
}
|
||||
}
|
||||
|
||||
92
Data Structures/Trees/TreeTraversal.java
Normal file
92
Data Structures/Trees/TreeTraversal.java
Normal file
@@ -0,0 +1,92 @@
|
||||
/**
|
||||
*
|
||||
* @author Varun Upadhyay (https://github.com/varunu28)
|
||||
*
|
||||
*/
|
||||
|
||||
// Driver Program
|
||||
public class TreeTraversal {
|
||||
public static void main(String[] args) {
|
||||
Node tree = new Node(5);
|
||||
tree.insert(3);
|
||||
tree.insert(7);
|
||||
|
||||
// Prints 3 5 7
|
||||
tree.printInOrder();
|
||||
System.out.println();
|
||||
|
||||
// Prints 5 3 7
|
||||
tree.printPreOrder();
|
||||
System.out.println();
|
||||
|
||||
// Prints 3 7 5
|
||||
tree.printPostOrder();
|
||||
System.out.println();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The Node class which initializes a Node of a tree
|
||||
* Consists of all 3 traversal methods: printInOrder, printPostOrder & printPreOrder
|
||||
* printInOrder: LEFT -> ROOT -> RIGHT
|
||||
* printPreOrder: ROOT -> LEFT -> RIGHT
|
||||
* printPostOrder: LEFT -> RIGHT -> ROOT
|
||||
*/
|
||||
class Node {
|
||||
Node left, right;
|
||||
int data;
|
||||
|
||||
public Node(int data) {
|
||||
this.data = data;
|
||||
}
|
||||
|
||||
public void insert (int value) {
|
||||
if (value < data) {
|
||||
if (left == null) {
|
||||
left = new Node(value);
|
||||
}
|
||||
else {
|
||||
left.insert(value);
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (right == null) {
|
||||
right = new Node(value);
|
||||
}
|
||||
else {
|
||||
right.insert(value);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void printInOrder() {
|
||||
if (left != null) {
|
||||
left.printInOrder();
|
||||
}
|
||||
System.out.print(data + " ");
|
||||
if (right != null) {
|
||||
right.printInOrder();
|
||||
}
|
||||
}
|
||||
|
||||
public void printPreOrder() {
|
||||
System.out.print(data + " ");
|
||||
if (left != null) {
|
||||
left.printPreOrder();
|
||||
}
|
||||
if (right != null) {
|
||||
right.printPreOrder();
|
||||
}
|
||||
}
|
||||
|
||||
public void printPostOrder() {
|
||||
if (left != null) {
|
||||
left.printPostOrder();
|
||||
}
|
||||
if (right != null) {
|
||||
right.printPostOrder();
|
||||
}
|
||||
System.out.print(data + " ");
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user