SortingAlgorithm.java

// Implementation of Sorting algorithms

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.Rectangle2D;
import java.util.Random;

import javax.swing.JPanel;
import javax.swing.SwingWorker;

public class SortingAlgorithm extends JPanel {
 private final int WIDTH = 800, HEIGHT = WIDTH * 9 / 16;
 public int SIZE = 100; // the number if sorting elements
 public float BAR_WIDTH = (float)WIDTH / SIZE; // bar width
 private float[] bar_height = new float[SIZE]; // height of bars
 private SwingWorker<Void, Void> shuffler, sorter;
 private int current_index, traversing_index; // needed for following colloring the items

 SortingAlgorithm() {
 setBackground(Color.BLACK);
 setPreferredSize(new Dimension(WIDTH, HEIGHT));
 initBarHeight(); // initialize the height of each bar
 // initShuffler(); // shuffle each bar
 }

 // setter for SIZE
 public void setSIZE(int SIZE) {
 this.SIZE = SIZE;
 }

 // getter for SIZE
 int getSIZE() {
 return SIZE;
 }

 // repaint() will automaticly call this function
 // needed for coloring
 @Override
 public void paintComponent(Graphics g) {
 super.paintComponent(g);

 // Create randomizer
 Random random = new Random(); 

 // Drawing the rectangles
 Graphics2D g2d = (Graphics2D)g;
 g2d.setColor(Color.CYAN);
 Rectangle2D.Float bar;

 for(int i = 0; i < getSIZE(); i++ ) {
 // random colors
 // final float hue = random.nextFloat();
 // final float saturation = 0.9f; //1.0 for brilliant, 0.0 for dull
 // final float luminance = 1.0f; //1.0 for brighter, 0.0 for black

 // g2d.setColor(Color.getHSBColor(hue, saturation, luminance));
 bar = new Rectangle2D.Float(i * BAR_WIDTH, 0, BAR_WIDTH-1, bar_height[i]);
 g2d.fill(bar); // g2d.draw(bar);
 }

 // Color setter for the current object
 g2d.setColor(Color.RED);
 bar = new Rectangle2D.Float(current_index * BAR_WIDTH, 0, BAR_WIDTH, bar_height[current_index]);
 g2d.fill(bar);

 // Color setter for the traversing object
 g2d.setColor(Color.YELLOW);
 bar = new Rectangle2D.Float(traversing_index * BAR_WIDTH, 0, BAR_WIDTH, bar_height[traversing_index]);
 g2d.fill(bar);
 }

 public void insertionSort() {
 /*Insertion sort algorithm*/ 
 // Multithreading used for hadling the sorting
 sorter = new SwingWorker<>() {
 @Override
 public Void doInBackground() throws InterruptedException { // function for calling multithreading
 // Insertion sort algorithm starts
 for(current_index = 1; current_index < getSIZE(); current_index++) {
 traversing_index = current_index;
 while(traversing_index > 0 && bar_height[traversing_index] < bar_height[traversing_index - 1]) {
 swap(traversing_index, traversing_index - 1);
 traversing_index--;
 
 Thread.sleep(10); // controls the speed
 repaint(); // we need it because we ofter replace the contents of a JPanel
 }
 }
 current_index = 0;
 traversing_index = 0;

 return null;
 }
 };
 }

 public void bubbleSort() {
 /*Bubble sorting algorithm*/
 sorter = new SwingWorker<>() {
 @Override
 public Void doInBackground() throws InterruptedException {
 for(current_index = 0; current_index < getSIZE(); current_index++) {
 for(traversing_index = 1; traversing_index < (getSIZE() - current_index); traversing_index++) {
 if(bar_height[traversing_index - 1] > bar_height[traversing_index]) {
 swap(traversing_index, traversing_index - 1);
 traversing_index--; // just for annimation

 Thread.sleep(10); // controls the speed
 repaint(); // we need it because we ofter replace the contents of a JPanel
 }
 } 
 }
 current_index = 0;
 traversing_index = 0;

 return null;
 }
 };
 }

 public void mergeSort() {
 /*Merge sorting algorithm*/
 // Change code from bubbleSort to mergeSort
 // TODO

 sorter = new SwingWorker<>() {
 @Override
 public Void doInBackground() throws InterruptedException {
 for(current_index = 0; current_index < getSIZE(); current_index++) {
 for(traversing_index = 1; traversing_index < (getSIZE() - current_index); traversing_index++) {
 if(bar_height[traversing_index - 1] > bar_height[traversing_index]) {
 swap(traversing_index, traversing_index - 1);
 traversing_index--; // just for annimation

 Thread.sleep(10); // controls the speed
 repaint(); // we need it because we ofter replace the contents of a JPanel
 }
 } 
 }
 current_index = 0;
 traversing_index = 0;

 return null;
 }
 };
 }

 
 public void selectionSort() {
 /*Merge sorting algorithm*/
 // Change code from bubbleSort to mergeSort
 // TODO

 sorter = new SwingWorker<>() {
 @Override
 public Void doInBackground() throws InterruptedException {
 for(current_index = 0; current_index < getSIZE() - 1; current_index++) {
 int min_index = current_index;
 for(int traversing_index = current_index + 1; traversing_index < getSIZE(); traversing_index++) {
 if (bar_height[traversing_index] < bar_height[min_index]) {
 min_index = traversing_index;
 }
 }
 swap(current_index, min_index);
 Thread.sleep(10); // controls the speed
 repaint(); // we need it because we ofter replace the contents of a JPanel
 } 
 
 current_index = 0;
 traversing_index = 0;

 return null;
 }
 };
 }

 public void initShuffler() {
 /*Shuffles each bar*/
 shuffler = new SwingWorker<>() {
 @Override
 public Void doInBackground() throws InterruptedException {
 int middle = getSIZE() / 2;
 for (int i = 0, j = middle; i < middle; i++, j++) {
 int randow_index = new Random().nextInt(getSIZE());
 swap(i, randow_index);

 randow_index = new Random().nextInt(getSIZE());
 swap(j, randow_index);

 Thread.sleep(10); // controls the speed
 repaint(); // we need it because we ofter replace the contents of a JPanel
 }
 return null;
 }
 // after finishing the process
 @Override
			public void done() {
				super.done();
				sorter.execute(); 
			}
 };
 shuffler.execute();
 }
 
 public void initBarHeight() {
 /*Initialize the height of each bar*/
 float interval = (float)HEIGHT / getSIZE();
 for(int i = 0; i < getSIZE(); i++) {
 bar_height[i] = i * interval;
 }
 }

 public void swap(int indexA, int indexB) {
 /*Swaps the elements*/
 float temp = bar_height[indexA];
 bar_height[indexA] = bar_height[indexB];
 bar_height[indexB] = temp;
 }
}