几个简单排序demo

几个简单排序demo

package com.myapp.test.sort;

public class SortTest {

public static void main(String[] args) {

    int arr[] = { 9, 5, 2, 4, 1, 3, 8, 7 };

    maopaoSort(arr);// 冒泡
    simpleChioce(arr);// 简单选择
    insertSort(arr);// 插入排序
    shellSort(arr);// 希尔排序
    heapSort(arr);// 二叉堆排序

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

/**
 * 冒泡
 * 平方阶圈复杂
 * 
 * 1.迭代数组长度的次数<br>
 * 2.选择每次迭代的记录对应，与数组中其它每一个记录进行大小对比<br>
 *   如果前面的大于后面的则交换位置
 * 
 * @param array
 */
public static void maopaoSort(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        for (int j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(arr, j, j + 1);
            }
        }
    }
}

/**
 * 交换位置
 * 
 * @param arr
 * @param x
 * @param y
 */
private static void swap(int[] arr, int x, int y) {
    int temp = arr[x];
    arr[x] = arr[y];
    arr[y] = temp;
}

/**
 * 简单选择排序
 * 
 * @param arr
 */
private static void simpleChioce(int[] arr) {
    int temp = 0;
    int min = 0;
    for (int i = 0; i < arr.length - 1; i++) {
        min = i;

        // 寻找最小数值的下标
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[min] > arr[j])
                min = j;
        }

        // 将arr[i]与最小数值交换，如果最小数值就是arr[i]则不操作
        if (min != i) {
            temp = arr[min];
            arr[min] = arr[i];
            arr[i] = temp;
        }
    }
}

/**
 * 插入排序
 * 
 * @param arr
 */
public static void insertSort(int[] arr) {
    int temp;
    int j = 0;
    for (int i = 1; i < arr.length; i++) {
        // 此处的判断很重要，这里体现了插入排序比冒泡排序和选择排序快的原因。
        if (arr[i] < arr[i - 1]) {
            temp = arr[i];
            // 如果后面一位小于前面一位数字，则交换位置
            for (j = i - 1; j >= 0 && temp < arr[j]; j--) {
                arr[j + 1] = arr[j];
            }
            // 将数据插入到j+1位置
            arr[j + 1] = temp;
            // System.out.print("第" + (i) + "次：");
            // for (int k = 0; k < arr.length; k++) {
            // System.out.print(arr[k] + ",");
            // }
            // System.out.println("");
        }
    }
}

/**
 * 希尔排序
 * 
 * @param arr
 */
private static void shellSort(int[] arr) {
    double d1 = arr.length;
    int temp = 0;
    while (true) {

        d1 = Math.ceil(d1 / 2);

        int d = (int) d1;

        for (int x = 0; x < d; x++) {

            for (int i = x + d; i < arr.length; i += d) {
                int j = i - d;
                temp = arr[i];
                for (; j >= 0 && temp < arr[j]; j -= d) {
                    arr[j + d] = arr[j];
                }

                arr[j + d] = temp;
            }

        }
        if (d == 1) {
            break;
        }
        // for (int i = 0; i < arr.length; i++) {
        // System.out.print(arr[i] +" ");
        // }
    }
}

/**
 * 二叉堆排序
 * 
 * @param arr  
 * [9, 5, 2, 4, 1, 3, 8, 7] 
 * 
 */
public static void heapSort(int[] arr) {
    buildHeap(arr);// 构建堆 
    int n = arr.length;
    int i = 0;
    for (i = n - 1; i >= 1; i--) {
        swap(arr, 0, i);
        heapify(arr, 0, i);
    }
}

public static void buildHeap(int[] arr) {
    int n = arr.length;// 数组中元素的个数
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, i, n);

}

public static void heapify(int[] A, int idx, int max) {
    int left = 2 * idx + 1;// 左孩子的下标（如果存在的话）
    int right = 2 * idx + 2;// 右孩子的下标（如果存在的话）
    int largest = 0;// 寻找3个节点中最大值节点的下标
    if (left < max && A[left] > A[idx])
        largest = left;
    else
        largest = idx;
    if (right < max && A[right] > A[largest])
        largest = right;
    if (largest != idx) {
        swap(A, largest, idx);
        heapify(A, largest, max);
    }

}

}