交换排序（Java）

交换排序主要包括冒泡排序与快速排序，下面是冒泡排序和其两种改进方法、快速排序以及其改进方法的代码：

package com.xqq.冒泡排序;

/**
 * 冒泡排序是对相邻两个记录进行关键字比较和交换，这样每次交换后只能改变一对逆序记录
 * 而快速排序则是从待排序记录的两端开始进行比较和交换，并逐渐向中间靠拢，
 * 有可能改变挤兑逆序记录，从而加快了排序速度
 * 快速排序： 当序列基本有序或者逆序时， 每一趟基准只能将其他记录分成一部分，这样降低了时间效率
 * @author xqq
 */
public class Sort<T> {

    // 原始的冒泡排序是 : 每一趟，将一个所需要的元素冒泡之最顶端--即最末尾（也可以根据要求来）
    // 最多组要(n - 1)趟冒泡排序就可以使得记录称为有序序列
    @SuppressWarnings("unchecked")
    public void bubbleSort1(T[] arrays) {
        Comparable<? super T> temp;
        int cmp;
        for (int i = arrays.length - 1; i > 0; i--) {
            for (int j = 0; j <= i - 1; j++) {
                temp = (Comparable<? super T>) arrays[j];
                cmp = temp.compareTo(arrays[j + 1]);
                if (cmp > 0) {
                    swap(arrays, j, j + 1);
                }
            }
        }
    }

    private void swap(T[] arrays, int i, int j) {
        T temp = arrays[i];
        arrays[i] = arrays[j];
        arrays[j] = temp;
    }

    // 在冒泡排序过程中，一旦发现某一趟没有进行交换操作，就表明此时待排序的记录序列已经成为有序序列。
    // 所以引入标志检测 在某一趟中是否发生了交换
    @SuppressWarnings("unchecked")
    public void bubbleSort2(T[] arrays) {
        Comparable<? super T> temp;
        int cmp;
        boolean exchange;
        for (int i = arrays.length - 1; i > 0; i--) {
            exchange = false;
            for (int j = 0; j <= i - 1; j++) {
                temp = (Comparable<? super T>) arrays[j];
                cmp = temp.compareTo(arrays[j + 1]);
                if (cmp > 0) {
                    swap(arrays, j, j + 1);
                    exchange = true;
                }
            }
            if (!exchange)
                break;
        }
    }

    // 如果同时记录第i趟冒泡排序中最后一次发生交换的位置m，
    // 就会发现从此位置以后的记录均为有序序列，那么无序区的范围可以缩小到0 - m
    @SuppressWarnings("unchecked")
    public void bubbleSort3(T[] arrays) {
        Comparable<? super T> temp;
        int cmp;
        boolean exchange;
        int last = arrays.length - 2;

        for (int i = arrays.length - 1; i > 0; i--) {
            exchange = false;
            int m = last; // 初始时将最后需要交换的位置设置为最后一个元素
            // 这个判断条件不能直接用last，因为last在这一趟冒泡排序过程中有可能一直在变化
            for (int j = 0; j <= m; j++) {
                temp = (Comparable<? super T>) arrays[j];
                cmp = temp.compareTo(arrays[j + 1]);
                if (cmp > 0) {
                    swap(arrays, j, j + 1);
                    exchange = true;
                    last = j; // 记录每次发生交换的位置
                }
            }
            if (!exchange)
                break;
        }
    }

    // 快速排序：
    public void quickSort1(T[] arrays) {
        if (arrays == null || arrays.length <= 1)
            return;

        quicksort1(arrays, 0, arrays.length - 1);
    }

    // 快速排序优化，减少数组元素的交换次数
    public void quickSort2(T[] arrays) {
        if (arrays == null || arrays.length <= 1)
            return;

        quicksort2(arrays, 0, arrays.length - 1);
    }

    private void quicksort1(T[] arrays, int first, int end) {
        int partition = partition1(arrays, first, end);

        if (first < partition - 1)
            quicksort1(arrays, first, partition - 1);// 对左侧区域递归进行快速排序
        if (end > partition + 1)
            quicksort1(arrays, partition + 1, end); // 对右侧进行快速排序
    }

    // 快速排序 找基准位置
    @SuppressWarnings("unchecked")
    private int partition1(T[] arrays, int first, int end) {
        T temp = arrays[first];
        Comparable<? super T> t = (Comparable<? super T>) temp;
        int i = first, j = end;
        while (i < j) {
            while (j > i && t.compareTo(arrays[j]) <= 0)
                j--;
            arrays[i] = arrays[j];
            while (i < j && t.compareTo(arrays[i]) >= 0)
                i++;
            arrays[j] = arrays[i];
        }
        arrays[i] = temp;
        return i;
    }

    // 快速排序优化 减少交换次数
    @SuppressWarnings("unchecked")
    private int partition2(T[] arrays, int first, int end) {
        T temp = arrays[first];
        Comparable<? super T> t = (Comparable<? super T>) temp;
        int i = first, j = end;
        while (i < j) {
            while (j > i && t.compareTo(arrays[j]) <= 0)
                j--;
            while (i < j && t.compareTo(arrays[i]) >= 0)
                i++;
            swap(arrays, i, j);
        }
        swap(arrays, first, i);
        return i;
    }

    private void quicksort2(T[] arrays, int first, int end) {
        // int partition = partition1(arrays, first, end);
        int partition = partition2(arrays, first, end);

        if (first < partition - 1)
            quicksort2(arrays, first, partition - 1);// 对左侧区域递归进行快速排序
        if (end > partition + 1)
            quicksort2(arrays, partition + 1, end); // 对右侧进行快速排序
    }
}

测试代码： 
package com.xqq.冒泡排序;

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {
        Integer [] arrays = {4, 5, 7, 3, 3, 2, 1};

        Sort<Integer> sort = new Sort<Integer>();
//      sort.bubbleSort1(arrays);
//      sort.bubbleSort2(arrays);
//      sort.bubbleSort3(arrays);
//      sort.quickSort1(arrays);
        sort.quickSort2(arrays);
        System.out.println(Arrays.asList(arrays).toString());
    }
}