Sortings

package com.lnn.sort;

import java.util.Random;

public class Sorting {

      private int array[];

      private int size;

      public Sorting(int size) {

            this.size = size;

            array = new int[10];

      }

      public void generate() {

            Random random = new Random();

            for (int i = 0; i < size; i++) {

                  array[i] = random.nextInt(10) + 10;

            }

      }

      public void display() {

            for (int i = 0; i < size; i++) {

                  System.out.println("| " + i + " | " + array[i] + " |");

            }

      }

      public void bubbleSort() {

            for (int i = size - 1; i > 0; i--) {

                  for (int j = 0; j < i; j++) {

                        if (array[j] > array[j + 1]) {

                              swap(j, j + 1);

                        }

                  }

            }

      }

      public void selectionSort() {

            for (int i = 0; i < size; i++) {

                  int min = i;

                  for (int j = i; j < size; j++) {

                        if (array[min] > array[j]) {

                              min = j;

                        }

                  }

                  swap(i, min);

            }

      }

      public void insertSort() {

            for (int i = 1; i < size; i++) {

                  int j = i;

                  int insert = array[i];

                  while ((j > 0) && (array[j - 1] > insert)) {

                        array[j] = array[j - 1];

                        j--;

                  }

                  array[j] = insert;

            }

      }

      public void shellSort() {

            int inner, outer, temp;

            int interval = 1;

            while (interval <= size / 3) {

                  interval = interval * 3 + 1;

            }

            while (interval > 0) {

                  for (outer = interval; outer < size; outer++) {

                        temp = array[outer];

                        inner = outer;

                        while (inner > interval - 1 && array[inner - interval] >= temp) {

                              array[inner] = array[inner - interval];

                              inner -= interval;

                        }

                        array[inner] = temp;

                  }

                  interval = (interval - 1) / 3;

            }

      }

      public void mergeSort(int min, int max) {

            int less = min;

            int high = max;

            if (less >= high) {

                  return;

            }

            int middle = (less + high) / 2;

            mergeSort(less, middle);

            mergeSort(middle + 1, high);

            int lessEnd = middle;

            int highStart = middle + 1;

            while ((min <= lessEnd) && (highStart <= high)) {

                  if (array[less] < array[highStart]) {

                        less++;

                  } else {

                        int Temp = array[highStart];

                        for (int k = highStart - 1; k >= less; k--) {

                              array[k + 1] = array[k];

                        }

                        array[less] = Temp;

                        less++;

                        lessEnd++;

                        highStart++;

                  }

            }

      }

      public void quickSort(int left, int right) {

            if (right - left <= 0) {

                  return;

            } else {

                  int pivot = array[right];

                  int pivotIndex = partition(left, right, pivot);

                  quickSort(left, pivotIndex - 1);

                  quickSort(pivotIndex + 1, right);

            }

      }

      private int partition(int left, int right, int pivot) {

            int leftPointer = left - 1;

            int rightPointer = right;

            while (true) {

                  while (leftPointer < size - 1 && array[++leftPointer] < pivot)

                        ;

                  while (rightPointer > 0 && array[--rightPointer] > pivot)

                        ;

                  if (leftPointer >= rightPointer) {

                        break;

                  } else {

                        swap(leftPointer, rightPointer);

                  }

            }

            swap(leftPointer, right);

            return leftPointer;

      }

      public void swap(int indexOne, int indexTwo) {

            int temp = array[indexOne];

            array[indexOne] = array[indexTwo];

            array[indexTwo] = temp;

      }

      public static void main(String[] args) {

            Sorting sort = new Sorting(10);

            sort.generate();

            sort.mergeSort(0, 9);

            sort.display();

      }

}