排序算法简单实现

1、选择排序

1. 第一次，找出数组中最小的元素，将它和数组的第一个元素交换位置

2. 在剩下的数组中找到最小的元素，将它和数组第二个元素交换位置

3. 如此反复，知道将整个数组排序

 public class Selection {
 ​
     public static void main(String[] args) {
         String[] a = { "S", "O", "R", "T", "E", "X", "A", "M", "P", "L", "E" };
         select(a);
     }
     
     // 实现了Comparable接口的数组
     public static void select(Comparable[] a) {
 ​
         for (int i = 0; i < a.length; i++) {
             int minIndex = i;
             for (int j = i+1; j < a.length; j++) {
                 // 小于最小值时，返回负数
                 if (a[j].compareTo(a[minIndex]) < 0) {
                     minIndex = j;
                 }
             }
 ​
             if (minIndex != i) {
                 Comparable temp = a[i];
                 a[i] = a[minIndex];
                 a[minIndex] = temp;
             }
         }
 ​
         for (Comparable j : a) {
             System.out.println(j + " ");
         }
     }
 }

2、插入排序

遍历数组

• 当第j个元素大于第j-1个元素时，保持不变，j+1

• 当第j个元素小于第j-1个元素时，交换位置，并且递归查询之前的元素，小于则交换，大于等于的时候停止。

 public class Insertion {
     public static void main(String[] args) {
         String[] a = { "S", "O", "R", "T", "E", "X", "A", "M", "P", "L", "E" };
         insert(a);
     }
 ​
     public static void insert(Comparable[] a) {
 ​
         for (int i = 1; i < a.length; i++) {
             for (int j = i; j > 0 && a[j].compareTo(a[j-1]) < 0 ; j--) {
                 Comparable temp = a[j];
                 a[j] = a[j-1];
                 a[j-1] = temp;
             }
         }
 ​
         for (Comparable j : a) {
             System.out.println(j + " ");
         }
     }
 }

3、冒泡排序

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

3. 针对所有的元素重复以上的步骤，除了最后一个。

4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

 public class BubbleSort {
 ​
     public static void main(String[] args) {
         String[] a = { "S", "O", "R", "T", "E", "X", "A", "M", "P", "L", "E" };
         bubbleSort(a);
     }
 ​
     public static void bubbleSort(Comparable[] a) {
 ​
         for (int i = 0; i < a.length - 1; i++) {
             for (int j = 0; j < a.length - 1 - i; j++) {
                 if (a[j].compareTo(a[j+1]) > 0) {
                     Comparable temp = a[j];
                     a[j] = a[j+1];
                     a[j+1] = temp;
                 }
             }
         }
 ​
         for (Comparable comparable : a) {
             System.out.println(comparable + " ");
         }
     }
 }

4、快速排序

• 将数组索引0元素选为切分元素

• 从数组左端开始向右扫描直到找到一个大于等于它的元素

• 再从数组右端开始向左扫描直到找到一个小于等于它的元素

• 交换他们的位置，再继续重复查找  ​

 public class QuickSort {
 ​
     public static void main(String[] args) {
         String[] a = { "S", "O", "R", "T", "E", "X", "A", "M", "P", "L", "E" };
         sort(a);
 ​
         for (String s : a) {
             System.out.println(s + " ");
         }
     }
 ​
     public static void sort(Comparable[] a) {
         sort(a, 0, a.length-1);
     }
 ​
     public static void sort(Comparable[] a, int lo, int hi) {
         if (hi <= lo) return;
         int j = partition(a, lo, hi);
         // 确定首元素位置为j
         // 对前部分以及后部分的数组进行排序
         sort(a, lo, j-1);
         sort(a, j+1, hi);
     }
 ​
     public static int partition(Comparable[] a, int lo, int hi) {
         int i = lo, j = hi + 1;
 ​
         while (true) {
             // 用while循环进行++i以及--j
             while (a[++i].compareTo(a[lo]) < 0) { if (i == hi) {break;} }
             while (a[--j].compareTo(a[lo]) > 0) { if (j == lo) {break;} }
             if (i >= j) { break; }
             exchange(a, i, j);
         }
         // 确定首元素位置为j，交换位置
         exchange(a, lo, j);
         return j;
     }
 ​
     public static void exchange(Comparable[] a, int i, int j) {
         Comparable temp = a[i];
         a[i] = a[j];
         a[j] = temp;
     }
 }