基本排序算法-Java实现

1.选择排序

package sort;

import java.util.Arrays;

class SelectSort {
    public static int[] selectSort(int[] a) {
        int n = a.length;
        for (int i = 0; i < n - 1; i++) {
            int min = i;
            for (int j = i + 1; j < n; j++) {
                if (a[j] < a[min]) {
                    min = j;
                }
            }
            int tmp = a[i];
            a[i] = a[min];
            a[min] = tmp;
        }
        return a;
    }

    public static void main(String[] args) {
        int arr[] = {3, 7, 2, 8, 5};
        System.out.println(Arrays.toString(SelectSort.selectSort(arr)));
    }
}

2.插入排序

package sort;

import java.util.Arrays;

public class InsertSort {
    public static int[] insertSort(int[] arr) {
        if (null == arr || arr.length < 2)
            return arr;
        int n = arr.length;
        for (int i = 1; i < n; i++) {
            int temp = arr[i];
            int k = i - 1;
//            while (arr[k] > arr[i] && k >= 0) 会报数组越界的错误
            while (k >= 0 && arr[k] > arr[i])
                k--;
            for (int j = i; j > k + 1; j--)
                arr[j] = arr[j-1];
            arr[k+1] = temp;
        }
        return arr;
    }

    public static void main(String[] args) {
        int[] arr = {3, 7, 2, 8, 5};
        int[] result = InsertSort.insertSort(arr);
        System.out.print(Arrays.toString(result));
    }
}

3.冒泡排序

package sort;

import java.util.Arrays;

public class BubbleSort {
    public static int[] bubbleSort(int[] arr) {
        if (null == arr || arr.length < 2)
            return arr;
        int n = arr.length;
        for (int i = n - 1; i > 0; i--) {
            boolean sorted = true;
            for (int j = 0; j < i; j++) {
                if (arr[j] > arr[j+1]) {
                    sorted = false;
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            if (sorted) //如果一次排序中未发生元素交换，则表明数组已有序。
                break;
        }
        return arr;
        }

    public static void main(String[] args) {
        int arr[] = {3, 7, 2, 8, 5};
        System.out.print(Arrays.toString(BubbleSort.bubbleSort(arr)));
    }
}

4.希尔排序

package sort;

import java.util.Arrays;

public class ShellSort {
    public static int[] shellSort(int arr[]) {
        if (null == arr || arr.length < 2) return arr;
        int n = arr.length;
        for (int gap = n / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < n; i++) {
                insertI(arr, gap, i);
            }
        }
        return arr;
    }
        private static void insertI(int arr[], int gap, int i) {
            int temp = arr[i];
            int k;
            for (k = i - gap; k >= 0 && temp < arr[k]; k -= gap) {
                arr[k+gap] = arr[k];
            }
            arr[k+gap] = temp;
        }

    public static void main(String[] args) {
        int[] arr = {3, 7, 2, 8, 5};
        System.out.println(Arrays.toString(ShellSort.shellSort(arr)));
    }
}

5.归并排序

package sort;

import java.util.Arrays;
// 递归版本
public class MergeSort {
    public static int[] mergeSort(int[] arr, int left, int right) {
        if (left < right) {
            int mid = (left + right)/2;
            arr = mergeSort(arr, left, mid); // 把左半边排序好
            arr = mergeSort(arr, mid + 1, right); // 把右半边排序好 
            merge(arr, left, mid, right);
        }
        return arr;
    }
    private static void merge(int[] arr, int left, int mid, int right) {
        int[] a = new int[right - left + 1];
        int i = left;
        int j = mid + 1;
        int k = 0;
        while (i <= mid && j <= right) {
            if (arr[i] < arr[j]) {
                a[k++] = arr[i++];
            } else {
                a[k++] = arr[j++];
            }
        }
        while (i <= mid)
            a[k++] = arr[i++];
        while (j <= right)
            a[k++] = arr[j++];
        for (i = 0; i < k; i++)
            arr[left++] = a[i];
    }
    public static int[] mergeSort2(int[] arr) {
        // 非递归的归并排序，自底向上
        int n = arr.length;
        //先从数组大小为1开始合并，合并完后再两两合并，再四四合并..
        for (int i = 1; i < n; i += i) {
            int left = 0;
            int mid = left + i - 1;
            int right = mid + i;
            while (right < n) {
                merge(arr, left, mid, right);
                left = right + 1;
                mid = left + i - 1;
                right = mid + i;
            }
            //再合并遗漏的长度（right-left)不够i的部分，即可能存在left<n,mid<n,right>n的情况，此时将right指定为数组最后一位，即n-1。
            if (left < n && mid < n) {
                merge(arr, left, mid, n-1);
            }
        }
        return arr;
    }
    public static void main(String[] args) {
        int[] arr = {3, 7, 2, 8, 5};
        System.out.println(Arrays.toString(MergeSort.mergeSort(arr, 0, arr.length - 1)));
        System.out.println(Arrays.toString(MergeSort.mergeSort2(arr)));
    }
}

6.快速排序

package sort;

import java.util.Arrays;

public class QuickSort {
    public static int[] quickSort(int[] arr, int left, int right) {
        if (left < right) {
            int mid = partition(arr, left, right);
            quickSort(arr, left, mid - 1);
            quickSort(arr, mid + 1, right);
        }
        return arr;
    }
    //返回中轴元素所在的位置
    private static int partition(int[] arr, int left, int right) {
        int pivot = arr[left];
        int i = left + 1;
        int j = right;
        while (true) {
            while (i <= j && arr[i] <= pivot) i++;
            while (i <= j && arr[j] >= pivot) j--;
            if (i >= j)
                break;
            int temp = arr[j];
            arr[j] = arr[i];
            arr[i] = temp;
        }
        arr[left] = arr[j];
        arr[j] = pivot;
        return j;
    }

    public static void main(String[] args) {
        int[] arr = {3, 7, 2, 8, 5};
        System.out.println(Arrays.toString(QuickSort.quickSort(arr, 0, arr.length - 1)));

    }
}

7.堆排序

package sort;

import java.util.Arrays;

public class HeapSort {
    public static int[] heapSort(int[] arr) {
        int length = arr.length;
        //构建二叉堆，即让非叶子节点依次执行下沉操作
        for (int i = (length - 2) / 2; i >= 0; i--) {
            arr = downAdjust(arr, i, length - 1);
        }
        //堆排序
        for (int i = length - 1; i >= 1; i--) {
            int temp = arr[i];
            arr[i] = arr[0];
            arr[0] = temp;
            arr = downAdjust(arr, 0, i - 1);
        }
        return arr;
    }
    //升序排列构建大顶堆，降序排列构建小顶堆,length指需要下沉的数组最大下标（即下沉数组.length - 1)
    private static int[] downAdjust(int[] arr, int parent, int length) {
        //保存要下沉的元素
        int temp = arr[parent];
        int child = 2 * parent + 1;
        //开始下沉
        while (child <= length) {
            //如果右孩子的值大于左孩子，则下沉位选在右孩子节点
            if (child + 1 <= length && arr[child] < arr[child + 1])
                child ++;
            //如果父节点值大于或等于孩子节点，则下沉结束
            if (temp >= arr[child])
                break;
            arr[parent] = arr[child];
            parent = child;
            child = 2 * parent + 1;
        }
        arr[parent] = temp;
        return arr;
    }

    public static void main(String[] args) {
        int[] arr = {0, 3, 1, 7, 2, 4, 8, 5};
        System.out.println(Arrays.toString(HeapSort.heapSort(arr)));
    }
}