排序算法-java（选择，插入，交换）

import java.util.Random;

public class 排序 {

    public static void main(String[] args) {
        int[] unSort = new int[11];
        int[] unSort2 = new int[10];
        Random random = new Random();
        System.out.println("排序前:");
        for (int i = 1; i < 11; i++) {
            unSort[i] = random.nextInt(100);
            unSort2[i - 1] = unSort[i];
            System.out.print(unSort[i] + " ");
        }
        int[] unSort3 = unSort2.clone();
        int[] unSort4 = unSort2.clone();
        System.out.println();
        System.out.println("-----------------------");
        插入排序.insertSort(unSort);
        System.out.println();
        System.out.println("-----------------------");
        选择排序.selectSort(unSort2);
        System.out.println();
        System.out.println("-----------------------");
        交换排序.bubbleSort(unSort3);
        System.out.println();
        System.out.println("-----------------------");
        交换排序.quickSort(unSort4, 0, unSort3.length - 1);
        for (int i = 0; i < unSort4.length; i++) {
            System.out.print(unSort4[i] + " ");
        }
    }
}

class 插入排序 {

    /**
     * 直接插入排序
     * 
     * @param unSort 未排序的数组 <br>
     *               unSort[0] 是监视哨 用于存放unSort[i]的副本
     */
    public static void insertSort(int[] unSort) {
        int j = 0;
        for (int i = 2; i < unSort.length; i++) {
            // 把需要排序的数放到 下标为0的 监视位
            unSort[0] = unSort[i];
            j = i - 1; // 有序区 最后一个元素的位置
            // 当有序区j位置的元素> 需要排序的数
            while (unSort[j] > unSort[0])
                // 那么 有序区j位置的元素 向后移一位 直到 需要排序的元素不比有序区j位置的元素大
                unSort[j + 1] = unSort[j--];
            // 将需要排序的数 放到 找到的在有序区的位置
            unSort[j + 1] = unSort[0];
        }
        // 输出排序的结果
        for (int i = 1; i < unSort.length; i++) {
            System.out.print(unSort[i] + " ");
        }
    }
}

class 选择排序 {
    /**
     * 直接选择排序
     * 
     * @param unSort 未排序的数组
     */
    public static void selectSort(int[] unSort) {
        int k = 0;
        int temp = 0;
        for (int i = 0; i < unSort.length - 1; i++) {
            // 假设 最小值是i
            k = i;
            // 在无序区中找 比 i 小 且 最小的数字的下标
            for (int j = i + 1; j < unSort.length; j++) {
                if (unSort[k] > unSort[j])
                    k = j;
            }
            // 如果 k 和 i 不等 说明最小值不是i 交换最小值
            if (k != i) {
                temp = unSort[i];
                unSort[i] = unSort[k];
                unSort[k] = temp;
            }
        }
        for (int i = 0; i < unSort.length; i++) {
            System.out.print(unSort[i] + " ");
        }
    }

    /**
     * 归并合并（合并两个文件） <br>
     * 将两个相邻且有序的文件合并成一个,取两个文件中元素小的元素复制
     * 
     * @param r1           存储两个文件的数组
     * @param r2           合并后的数组
     * @param 文件1在r1中的起始位置
     * @param 文件1在r1中的结束位置
     * @param 文件2在r1中的结束位置
     */
    public static void merge(int[] r, int[] r1, int low, int mid, int high) {
        // i,j为文件1指针
        int i, j, k;
        // 初始化
        i = low;
        j = mid + 1;
        k = low;
        // 取小的复制
        while ((i <= mid) && (j <= high))
            if (r[i] <= r[j])
                r1[k++] = r[i++];
            else
                r1[k++] = r[j++];
        // 复制剩余的部分
        while (i <= mid)
            r1[k++] = r[i++];
        while (j <= high)
            r1[k++] = r[j++];
    }

    /**
     * 归并排序
     * 
     * @param r    
     * @param r1
     * @param length 本次归并的有序文件的长度
     */
    public static void mergePass(int[] r, int r1, int length) {
        
    }
}

class 交换排序 {
    /**
     * 起泡排序 <br>
     * 把元素看成是垂直的,从后往两两比较大小
     * 
     * @param unSort 未排序的数组
     */
    public static void bubbleSort(int[] unSort) {
        for (int i = 0; i < unSort.length; i++) {
            boolean noSwap = true; // 是否交换过顺序
            int temp = 0;
            // 无序区 从后往前遍历到有序区 找最小的元素
            for (int j = unSort.length - 2; j >= i; j--) {
                // 后面的小于前面的 交换
                if (unSort[j + 1] < unSort[j]) {
                    temp = unSort[j + 1];
                    unSort[j + 1] = unSort[j];
                    unSort[j] = temp;
                    noSwap = false;
                }
            }
            // 没有交换过 说明已经是正确的顺序了
            if (noSwap)
                break;
        }

        for (int i = 0; i < unSort.length; i++) {
            System.out.print(unSort[i] + " ");
        }
    }

    /**
     * 快速排序
     * 
     * @param unSort 未排序的数组
     * @param l      左指针
     * @param r      右指针
     * 
     */
    public static void quickSort(int[] unSort, int l, int r) {
        if (l > r)
            return;
        int i, j, temp, t; // 左右指针
        // 初始化
        temp = unSort[l];
        i = l;
        j = r;
        t = 0;

        do {
            // 从右向左查找小于 基准的 数
            while ((unSort[j] >= temp) && (i < j))
                j--;

            // 从左向右扫描
            while ((unSort[i] <= temp) && (i < j))
                i++;
            // 交换找到的两个数在数组中的位置
            if (i < j) {
                t = unSort[i];
                unSort[i] = unSort[j];
                unSort[j] = t;
            }

        } while (i != j);

        // 重新定位基准
        unSort[l] = unSort[i];
        unSort[i] = temp;
        // 向左递归
        quickSort(unSort, l, i - 1);
        // 向右递归
        quickSort(unSort, i + 1, r);
    }

}