import java.awt.Dimension;import java.awt.Graphics;import java.awt.event.ActionEvent;import java.util.Arrays;import java.util.Random;import javax.swing.*;/** * A class containing a number of classic sorting algorithms, * implemented from scratch. The algorithms each operate on arrays * of ints only, and are animated. */public class Sorter extends JPanel { private static Random randomizer = new Random(); private static final int ARRAY_LENGTH = 600; private static final int MAX_VALUE = 400; private final int[] array = new int[ARRAY_LENGTH]; private transient boolean shouldStop = false; /** * Swaps a[i] and a[j]. */ private void swap(int[] a, int i, int j) { int old = a[i]; a[i] = a[j]; a[j] = old; } /** * Fills an array with random values between 0 and MAX_VALUE. */ private void reload(int[] a) { for (int i = 0; i < a.length; i++) { a[i] = randomizer.nextInt(MAX_VALUE); } } /** * Sorts an array using Selection Sort. The algorithm is to first * put the smallest item in the first position, then the next * smallest in the second position, and so on. */ public void selectionSort(int[] a) { for (int i = 0; i < a.length - 1; i++) { int small = i; for (int j = i + 1; j < a.length; j++) { if (a[j] < a[small]) small = j; PAUSE(); } swap(a, i, small); } } /** * Sorts an array using Insertion Sort. The algorithm is to first * slide the second element back as far as it should go, then slide * the third back, and so on. */ public void insertionSort(int[] a) { for (int i = 1; i < a.length; i++) { int current = a[i]; int j = i; for (; j > 0 && current < a[j-1]; j--) { a[j] = a[j-1]; PAUSE(); } a[j] = current; } } /** * Sorts an array using Bubble Sort. */ public void bubbleSort(int[] a) { for (int i = a.length - 1; i > 0; i--) { for (int j = 0; j < i; j++) { if (a[j] > a[j + 1]) swap(a, j, j + 1); PAUSE(); } } } /** * Sorts an array using Gnome Sort. */ public void gnomeSort(int[] a) { for (int i = 0; i < a.length;) { PAUSE(); if (i == 0 || a[i-1] <= a[i]) { i++; } else { swap(a, i, i - 1); i--; } } } /** * Sorts an array using Shell Sort. This is a lousy Shell Sort. * I need to make a new one. */ public void shellSort(int[] a) { int distance = a.length / 2; while (distance > 0) { boolean changed = false; for (int i = 0; i < a.length - distance; i++) { if (a[i] > a[i + distance]) { swap(a, i, i + distance); changed = true; } PAUSE(); } if (!changed) distance /= 2; } } /** * Sorts an array using Quick Sort. This version of quicksort uses * the leftmost item as the pivot, but since this gives disastrous * performance on sorted and nearly sorted arrays, we scramble the * array first. */ public void quickSort(int[] a) { // First shuffle (permute) the array for (int i = 0; i < a.length; i++) { swap(a, i, randomizer.nextInt(ARRAY_LENGTH)); } // Call the recursive helper quickSort(a, 0, a.length - 1); } private void quickSort(int[] a, int left, int right) { if (left < right) { int i = left; int j = right; while (i < j) { while (a[j] > a[left]) {j--; PAUSE();} while (i < j && a[i] <= a[left]) {i++; PAUSE();} if (i < j) swap(a, i, j); } swap(a, left, j); quickSort(a, left, j-1); quickSort(a, j+1, right); } } /** * Sorts an array using Heap Sort. */ public void heapSort(int[] a) { // Phase 1: make a heap by sifting down all non-leaf // elements, one after another, starting with the last // non-leaf element and going backwards. for (int i = a.length / 2 - 1; i >= 0; i--) { for (int j = i; j * 2 + 1 < a.length;) { PAUSE(); int k = j * 2 + 1; if (k + 1 < a.length && a[k] < a[k + 1]) k++; if (a[j] < a[k]) swap(a, j, k); else break; j = k; } } // Phase 2: Successively place the biggest, then next biggest // items at the end of the array. each time reconstructing the // heap in the slots of the array not yet sorted. for (int i = a.length - 1; i > 0; i--) { swap(a, 0, i); for (int j = 0; j * 2 + 1 < i;) { PAUSE(); int k = j * 2 + 1; if (k + 1 < i && a[k] < a[k + 1]) k++; if (a[j] < a[k]) swap(a, j, k); else break; j = k; } } } /** * Sorts an array using merge sort, the classic version with * the extra storage. */ public void mergeSort(int[] a) { int[] scratch = new int[a.length]; mergeSort(a, 0, a.length - 1, scratch); } private void mergeSort(int[] a, int lo, int hi, int[] scratch) { if (lo >= hi) return; int mid = (lo + hi) / 2; mergeSort(a, lo, mid, scratch); mergeSort(a, mid + 1, hi, scratch); // Merge sorted sublists into temporary storage for (int i = lo, j = mid + 1, k = lo; k <= hi; k++) { if ((i <= mid) && ((j > hi) || (a[i] < a[j]))) { scratch[k] = a[i++]; PAUSE(); } else { scratch[k] = a[j++]; PAUSE(); } } // Copy back from temporary storage for (int k = lo; k <= hi; k++) { a[k] = scratch[k]; PAUSE(); } } /** * Sorts an array using counting sort, provided all values in the * array are non-negative. If there are negative values in the array, * the method will not sort but rather leave the array undefined. * Furthermore, the method will likely throw an OutOfMemoryError * if there are large integers in the array. */ public void countingSort(int[] a) { int max = 0; for (int i = 0; i < a.length; i++) { max = Math.max(max, a[i]); PAUSE(); } System.out.println(max); int[] counts = new int[max + 1]; Arrays.fill(counts, 0); for (int i = 0; i < a.length; i++) { counts[a[i]]++; PAUSE(); } for (int i = 0, j = 0; j < counts.length; j++) { for (int k = 0; k < counts[j]; k++) { a[i++] = j; PAUSE(); } } } public static void main(String[] args) { Sorter sorter = new Sorter(); JFrame frame = new JFrame("Sorting"); frame.getContentPane().add(sorter.toolbar, "North"); frame.getContentPane().add(sorter, "Center"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.pack(); frame.setVisible(true); sorter.runAnimation(); } Action startAction = new AbstractAction("Start") { public void actionPerformed(ActionEvent e) { final String methodName = (String)comboBox.getSelectedItem(); new Thread(new Runnable() { public void run() { startButton.setEnabled(false); stopButton.setEnabled(true); reload(array); try { Sorter.class.getMethod(methodName, new Class[]{array.getClass()}) .invoke(Sorter.this, new Object[]{array}); } catch (Exception e) { } stopButton.setEnabled(false); startButton.setEnabled(true); }} ).start(); } }; Action stopAction = new AbstractAction("Stop") { public void actionPerformed(ActionEvent e) { shouldStop = true; } }; private JToolBar toolbar = new JToolBar(); private JButton startButton = new JButton(startAction); private JButton stopButton = new JButton(stopAction); JComboBox comboBox = new JComboBox(new String[]{ "selectionSort", "insertionSort", "bubbleSort", "gnomeSort", "shellSort", "quickSort", "mergeSort", "heapSort", "countingSort" }); public Sorter() { setPreferredSize(new Dimension(ARRAY_LENGTH, MAX_VALUE)); setBorder(BorderFactory.createEtchedBorder()); toolbar.add(comboBox); toolbar.add(startButton); toolbar.add(stopButton); comboBox.setMaximumRowCount(12); } protected void paintComponent(Graphics g) { super.paintComponent(g); for (int i = 0, n = array.length; i < n; i++) { g.drawLine(i, MAX_VALUE, i, MAX_VALUE - array[i]); } } /** * Causes the screen to be repainted every 30 ms or so. */ private void runAnimation() { while (true) { repaint(); try {Thread.sleep(30);} catch (InterruptedException e) {} } } /** * Something to call periodically during sorting. */ private void PAUSE() { try { Thread.sleep(1); if (shouldStop) { shouldStop = false; // Can't think of a better way to stop than this throw new RuntimeException(); } } catch (InterruptedException e) { } }}
