Java函数实现排序算法的演示

排序算法是计算机科学中必备的概念之一，是在编程中经常使用的技巧。排序算法用于将一个无序序列中的元素按照一定规则排序。Java中提供了多种排序算法的实现，可以方便地实现对数组或集合的排序。

本文将介绍Java中常用的几种排序算法，并用Java代码实现其功能，以帮助读者更好地理解排序算法的具体实现过程。

1. 冒泡排序

冒泡排序是一种简单的排序算法，它重复地遍历要排序的序列，一次比较两个元素，如果它们的顺序错误就交换位置，直到序列有序。

Java代码实现：

public static void bubbleSort(int[] arr) {
    int len = arr.length;
    for (int i = 0; i < len - 1; i++) {
        for (int j = i + 1; j < len; j++) {
            if (arr[i] > arr[j]) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
}

2. 选择排序

选择排序是一种简单直观的排序算法，它的基本思想是：首先在未排序的序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序的元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

Java代码实现：

public static void selectionSort(int[] arr) {
    int len = arr.length;
    for (int i = 0; i < len - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < len; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        int temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
}

3. 插入排序

插入排序的基本操作是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据。

Java代码实现：

public static void insertionSort(int[] arr) {
    int len = arr.length;
    for (int i = 1; i < len; i++) {
        int current = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > current) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = current;
    }
}

4. 快速排序

快速排序是一种基于分治的排序算法，它将一个大的序列分成两个小的序列，然后对这两个小的序列分别进行快速排序，最终得到有序序列。

Java代码实现：

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

private static void quickSort(int[] arr, int low, int high) {
    if (low < high) {
        int index = partition(arr, low, high);
        quickSort(arr, low, index - 1);
        quickSort(arr, index + 1, high);
    }
}

private static int partition(int[] arr, int low, int high) {
    int pivot = arr[low];
    int i = low;
    int j = high;
    while (i < j) {
        while (i < j && arr[j] >= pivot) {
            j--;
        }
        if (i < j) {
            arr[i] = arr[j];
            i++;
        }
        while (i < j && arr[i] <= pivot) {
            i++;
        }
        if (i < j) {
            arr[j] = arr[i];
            j--;
        }
    }
    arr[i] = pivot;
    return i;
}

5. 归并排序

归并排序是一种采用分治法思想的排序算法，其基本思路是将一个大的数组分成两个小的数组，然后对这两个小的数组进行排序，最后将排好序的两个小数组合并成一个大的数组。

Java代码实现：

public static void mergeSort(int[] arr) {
    mergeSort(arr, 0, arr.length - 1);
}

private static void mergeSort(int[] arr, int low, int high) {
    if (low < high) {
        int mid = (low + high) / 2;
        mergeSort(arr, low, mid);
        mergeSort(arr, mid + 1, high);
        merge(arr, low, mid, high);
    }
}

private static void merge(int[] arr, int low, int mid, int high) {
    int[] temp = new int[high - low + 1];
    int i = low;
    int j = mid + 1;
    int k = 0;
    while (i <= mid && j <= high) {
        if (arr[i] < arr[j]) {
            temp[k] = arr[i];
            i++;
        } else {
            temp[k] = arr[j];
            j++;
        }
        k++;
    }
    while (i <= mid) {
        temp[k] = arr[i];
        i++;
        k++;
    }
    while (j <= high) {
        temp[k] = arr[j];
        j++;
        k++;
    }
    for (int m = 0; m < temp.length; m++) {
        arr[low + m] = temp[m];
    }
}

这是Java中几种常见的排序算法的实现代码，通过学习和理解这些代码，我们可以更深入地了解排序算法的原理和实现方法，并在实际开发中应用到排序算法。