Basic Sort Algorithm

package pkg.infostuido.algorithmdb.basicalgm;
/**
* Following concepts of sort algorithm come from wikipedia
* source: https://en.wikipedia.org/wiki/Sorting_algorithm
*/

public class SortingAlgm {

		/**
		 * Quick Sort
		 * Quicksort first divides a large array into two smaller sub-arrays: the low elements and the high elements. Quicksort can then recursively sort the sub-arrays.
		 * O(nlogn) 
		 */
		public void quicksort (double[] queue, int begin, int end){
				if(begin<end){
					double key = queue[begin];
					int i = begin;
					int j = end;
					while(i<j){
						while(i<j && queue[j]>key){
							j--;
						}
						if(i<j){
							queue[i] = queue[j];
							i++;
						}
						while(i<j && queue[i] < key){
							i++;
						}
						if(i<j){
							queue[j] = queue[i];
							j--;
						}
					}
					queue[i] = key;
					quicksort(queue,begin, i-1);
					quicksort(queue, i+1, end);
				}
		}
		
		
		/**
		 * Merge Sort
		 * Divide the unsorted list into n sublists, each containing 1 element (a list of 1 element is considered sorted).
		 * Repeatedly merge sublists to produce new sorted sublists until there is only 1 sublist remaining. This will be the sorted list.
		 *  O(nlogn)
		 */
		public void mergesort(double queue[],double temp[],int m,int n){
			if (m == n) return;  
	        int mid = (m+n)/2;  
	        mergesort(queue, temp, m, mid);  
	        mergesort(queue, temp, mid+1, n);  
	        for (int i = m; i <= n; i++) {  
	            temp[i] = queue[i];  
	        }  
	        int index1 = m;  
	        int index2 = mid + 1;  
	        int index = m;  
	        while (index1 <= mid && index2 <= n) {  
	            if (temp[index1] < temp[index2]) {  
	                queue[index++] = temp[index1++];  
	            } else {  
	                queue[index++] = temp[index2++];  
	            }  
	        }  
	        while(index1 <= mid) {  
	            queue[index++] = temp[index1++];  
	        }  
	        while(index2 <= n) {  
	            queue[index++] = temp[index2++];  
	        }  
		}
		
		/**
		 * Selection Sort
		 * O(n2)
		 */
		public void selectionsort(double[] queue){
			for(int i = 0; i < queue.length; i++){
	            for(int j = i+1; j < queue.length; j++){
	                if(queue[i] > queue[j]){
	                    double temp = queue[i];
	                    queue[i] = queue[j];
	                    queue[j] = temp;
	                }
	            }
	        }
	       
		}
		

		/**
		 * Bubble Sort
		 * repeatedly steps through the list to be sorted, compares each pair of adjacent items and swaps them if they are in the wrong order.
		 * O(n2)
		 */
		public void bubblesort(double[] queue){
			for (int i = 0; i < queue.length; i++) {
				 for (int j = queue.length - 1; j > i; j--) {
					 if (queue[j - 1] > queue[j]) {
						 queue[j - 1] = queue[j - 1] + queue[j];
						 queue[j] = queue[j - 1] - queue[j];
						 queue[j - 1] -= queue[j];
				 	}
				 }
			}
		}
		
       /**
        * Heap Sort
        * 1st: In the first step, a heap is built out of the data. The heap is often placed in an array with the layout of a complete binary tree. 
        * a sorted array is created by repeatedly removing the largest element from the heap (the root of the heap), and inserting it into the array. The heap is updated after each removal to maintain the heap. Once all objects have been removed from the heap, the result is a sorted array.
        * worst-case O(nlogn) 
        */
		public void heapsort(double[] queue){
			for(int i = 1; i < queue.length; i++){
				
			}
		}
		
		/**
		 * Insertion Sort
		 * Insertion sort iterates, consuming one input element each repetition, and growing a sorted output list. Each iteration, insertion sort removes one element from the input data, finds the location it belongs within the sorted list, and inserts it there. It repeats until no input elements remain.
		 * О(n2)
		 */
		public void insertionsort(double[] queue){
			    for (int j = 1; j < queue.length; j++) {
			         int i = j - 1;
			         double key = queue[j];
			         while (i >= 0 && queue[i] > key) {
			            queue[i + 1] = queue[i];
			            queue[i] = key;
			            i -= 1;
			        } 
			   } 
		}
		
		/**
		 * Shell Sort
		 * 
		 * Average case: depends on gap 
		 */
		public void shellsort(double[] queue){
			double key;
			for(int k=queue.length/2; k>0; k/=2){
				for(int i = k; i< queue.length; i++){
					for(int j = i; j>=k ; j-=k){
						if(queue[j-k] > queue[j]){
							key = queue[j-k];
							queue[j-k] = queue[j];
							queue[j]=key;
						}
					}
				}
			}
		}
		

	public static void main(String[] args) {
		double[] queue = {3,60,50,1,-4,99,30};
		//double[] temp = new double[queue.length];
		SortingAlgm sort = new SortingAlgm();
		//sort.bubblesort(queue);
		//sort.insertionsort(queue);
		//sort.quicksort(queue, 0, 6);
		//sort.shellsort(queue);
		//sort.mergesort(queue, temp, 0, queue.length-1);
		sort.selectionsort(queue);
		for(int i=0; i<queue.length; i++){
			System.out.println(queue[i]);
		}
		
	}

}