排序算法

最近在学习算法的一些知识，发现这些知识并非可有可无，不再做一个只会使用API的程序员，这是一个漫长的学习过程。

 

以下为常用的几个算法的Java实现，写在一个Junit测试类中了，这样方便执行，也不至于文件太多。

 

 

package alg;

 import java.util.Arrays;
 import org.junit.Test;

 public class Algorithm {

    private static long arr[] = new long[10];

    static {
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (long) (Math.random() * 100);
        }
    }

    private void swap(long[] array, int i, int j) {
        if (i == j) {
            return;
        }

        long temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    @Test
    public void arraysSort() {
        System.out.println("排序前：" + Arrays.toString(arr));

        Arrays.sort(arr);

        System.out.println("排序后：" + Arrays.toString(arr));
    }

    /**
     * 
     * 冒泡排序----交换排序的一种 方法：相邻两元素进行比较，如有需要则进行交换，每完成一次循环就将最大元素排在最后（如从小到大排序），
     * 下一次循环是将其他的数进行类似操作。 性能：比较次数O(n^2),n^2/2；交换次数O(n^2),n^2/4
     * 
     */
    @Test
    public void bubbleSort() {
        System.out.println("排序前：" + Arrays.toString(arr));

        for (int i = arr.length - 1; i >= 1; i--) {

            for (int j = 0; j < i; j++) {
                if (arr[j] > arr[j + 1]) {
                    swap(arr, j, j + 1);
                }
            }
        }

        System.out.println("排序后：" + Arrays.toString(arr));
    }

    // 换一下泡泡的走向
     @Test
    public void bubbleSort2() {
        System.out.println("排序前：" + Arrays.toString(arr));

        for (int i = arr.length - 1; i >= 1; i--) {

            for (int j = i; j > 0; j--) {
                if (arr[j] < arr[j - 1]) {
                    swap(arr, j, j - 1);
                }
            }
        }

        System.out.println("排序后：" + Arrays.toString(arr));
    }

    /**
     * 
     * 直接选择排序法----选择排序的一种 方法：每一趟从待排序的数据元素中选出最小（或最大）的一个元素，
     * 顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。 性能：比较次数O(n^2),n^2/2 交换次数O(n),n
     * 交换次数比冒泡排序少多了，由于交换所需CPU时间比比较所需的CUP时间多，所以选择排序比冒泡排序快。
     * 但是N比较大时，比较所需的CPU时间占主要地位，所以这时的性能和冒泡排序差不太多，但毫无疑问肯定要快些。
     */
    @Test
    public void selectSort() {
        System.out.println("排序前：" + Arrays.toString(arr));

        for (int i = 0; i < arr.length - 1; i++) {

            int index = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[index] > arr[j]) {
                    index = j;
                }
            }

            swap(arr, i, index);
        }

        System.out.println("排序后：" + Arrays.toString(arr));
    }

    /**
     * 插入排序 方法：将一个记录插入到已排好序的有序表（有可能是空表）中,从而得到一个新的记录数增1的有序表。 性能：比较次数O(n^2),n^2/4
     * 复制次数O(n),n^2/4 比较次数是前两者的一般，而复制所需的CPU时间较交换少，所以性能上比冒泡排序提高一倍多，而比选择排序也要快。
     */
    @Test
    public void insertSort() {
        System.out.println("排序前：" + Arrays.toString(arr));

        for (int i = 1; i < arr.length; i++) {
            long temp = arr[i];

            int j;

            for (j = i; j > 0; j--) {
                if (temp < arr[j - 1]) {
                    arr[j] = arr[j - 1];
                } else {
                    break;
                }

            }
            arr[j] = temp;
        }

        System.out.println("排序后：" + Arrays.toString(arr));
    }

    //来自于java.util.Arrays的源码
     @Test
    public void insertSort2() {
        System.out.println("排序前：" + Arrays.toString(arr));

        for (int i = 0; i < arr.length; i++) {
            
            for (int j = i; j > 0 && arr[j - 1] > arr[j]; j--) {
                swap(arr, j, j - 1);
            }
        }

        System.out.println("排序后：" + Arrays.toString(arr));
    }

    @Test
    public void quickSort() {
        System.out.println("排序前：" + Arrays.toString(arr));

        qSort(arr, 0, arr.length - 1);

        System.out.println("排序后：" + Arrays.toString(arr));
    }

    private void qSort(long[] array, int low, int high) {
        if (low < high) {
            int pivot = partition(array, low, high);

            qSort(arr, low, pivot - 1);

            qSort(arr, pivot + 1, high);
        }
    }

    private int partition(long[] array, int low, int high) {
        long pivot = array[low];
        
        int left = low;
        int right = high;
        
        while (left < right) {
            
            while (array[left] <= pivot && left < right) {
                left++;
            }
            
            while (array[right] > pivot) {
                right--;
            }
            
            if (left < right) {
                swap(array, left, right);
            }
        }
        
        swap(array, low, right);
        
        return right;
    }
}
 

 

 

找到一个参考网址http://www.cs.princeton.edu/introcs/40algorithms/