常见的排序算法

冒泡排序

public class BubbleSort {
    public static void bubbleSort(int[] sourceArray) {
        for (int i = 1; i < sourceArray.length; i++) {
            // 设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已经完成。
            boolean flag = true;
            for (int j = 0; j < sourceArray.length - i; j++) {
                if (sourceArray[j] > sourceArray[j + 1]) {
                    int tmp = sourceArray[j];
                    sourceArray[j] = sourceArray[j + 1];
                    sourceArray[j + 1] = tmp;
                    flag = false;
                }
            }
            if (flag) {
                break;
            }
        }
    }
}

选择排序

public class SelectionSort {
    public void selectionSort(int[] sourceArray) {
        // 总共要经过 N-1 轮比较
        for (int i = 0; i < sourceArray.length - 1; i++) {
            int min = i;
            // 每轮需要比较的次数 N-i
            for (int j = i + 1; j < sourceArray.length; j++) {
                if (sourceArray[j] < sourceArray[min]) {
                    // 记录目前能找到的最小值元素的下标
                    min = j;
                }
            }
            // 将找到的最小值和i位置所在的值进行交换
            if (i != min) {
                int tmp = sourceArray[i];
                sourceArray[i] = sourceArray[min];
                sourceArray[min] = tmp;
            }

        }
    }
}

插入排序

public class InsertSort {
    public void insertSort(int[] sourceArray) throws Exception {
        // 从下标为1的元素开始选择合适的位置插入，因为下标为0的只有一个元素，默认是有序的
        for (int i = 1; i < sourceArray.length; i++) {
            // 记录要插入的数据
            int tmp = sourceArray[i];
            // 从已经排序的序列最右边的开始比较，找到比其小的数
            int j = i;
            while (j > 0 && tmp < sourceArray[j - 1]) {
                sourceArray[j] = sourceArray[j - 1];
                j--;
            }
            // 存在比其小的数，插入
            if (j != i) {
                sourceArray[j] = tmp;
            }
        }
    }
}

归并排序

public class MergeSort {
    public static void mergeSort(int[] array) {
        sort(array, 0, array.length - 1);
    }

    //递归
    public static void sort(int[] array, int start, int end) {
        if (start >= end){
            return;
        }
        // 找出中间索引
        int mid = (start + end) / 2;
        // 对左边数组进行递归
        sort(array, start, mid);
        // 对右边数组进行递归
        sort(array, mid + 1, end);
        // 合并
        merge(array, start, mid, end);
    }

    public static void merge(int[] array, int start, int mid, int end) {
        int[] temp = new int[array.length];
        int k = 0;
        int i = start;
        int j = mid + 1;
        while (i <= mid && j <= end) {
            // 从两个数组中取出较小的放入临时数组
            if (array[i] <= array[j]) {
                temp[k++] = array[i++];
            } else {
                temp[k++] = array[j++];
            }
        }
        // 剩余部分依次放入临时数组（实际上两个while只会执行其中一个）
        while (i <= mid) {
            temp[k++] = array[i++];
        }
        while (j <= end) {
            temp[k++] = array[j++];
        }
        // 将临时数组中的内容拷贝回原数组中 （left-right范围的内容）
        for (int m = 0; m < k; m++) {
            array[m + start] = temp[m];
        }
    }
}

堆排序

public class HeapSort {
    public static void sort(int[] sourceArray) {
        int len = sourceArray.length;
        buildMaxHeap(sourceArray, len);
        for (int i = len - 1; i > 0; i--) {
            swap(sourceArray, 0, i);
            len--;
            heapify(sourceArray, 0, len);
        }
    }

    public static void buildMaxHeap(int[] arr, int length) {
        for (int i = arr.length / 2; i >= 0; i--) {
            heapify(arr, i, length);
        }

    }

    public static void heapify(int[] arr, int index, int len) {
        int left = index * 2 + 1;
        int right = index * 2 + 2;
        int parent = index;
        if (left < len && arr[left] > arr[parent]) {
            parent = left;
        }
        if (right < len && arr[right] > arr[parent]) {
            parent = right;
        }
        if (parent != index) {
            swap(arr, parent, index);
            heapify(arr, parent, len);
        }
    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

希尔排序

public class ShellSort {
    public static void shellSort(int[] arr) {
        int length = arr.length;
        int temp;
        for (int step = length / 2; step >= 1; step /= 2) {
            for (int i = step; i < length; i++) {
                temp = arr[i];
                int j = i - step;
                while (j >= 0 && arr[j] > temp) {
                    arr[j + step] = arr[j];
                    j -= step;
                }
                arr[j + step] = temp;
            }
        }
    }
}

快速排序

public class QuickSort {
    public static void sort(int[] arr) {
        quickSort(arr, 0, arr.length - 1);
    }

    public static void quickSort(int[] arr, int left, int right) {
        if (left < right) {
            int partitionIndex = partition(arr, left, right);
            quickSort(arr, left, partitionIndex - 1);
            quickSort(arr, partitionIndex + 1, right);
        }
    }

    public static int partition(int[] arr, int left, int right) {
        int pivot = left;
        int index = left + 1;
        for (int i = index; i <= right; i++) {
            if (arr[i] < arr[pivot]) {
                swap(arr, i, index);
                index++;
            }
        }
        swap(arr, pivot, index - 1);
        return index - 1;
    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}