Java中的数组函数和常用排序算法

一、Java中的数组函数

1. Arrays.sort()

Arrays.sort()函数可以对数组进行排序，使用该函数需要传入要排序的数组名，该函数会返回一个已排好序的数组。

示例：

int[] arr = {3, 2, 1};
Arrays.sort(arr);

2. Arrays.fill()

Arrays.fill()函数可以将整个数组或部分数组中的元素修改为指定的值。

示例：

int[] arr = new int[5];
Arrays.fill(arr, 1);

3. Arrays.copyOf()

Arrays.copyOf()函数用于复制数组，可以指定要复制的数组和新数组的长度。

示例：

int[] arr = {1, 2, 3};
int[] copy = Arrays.copyOf(arr, 5);

4. Arrays.binarySearch()

Arrays.binarySearch()函数用于在已排序的数组中查找指定元素的索引值，查找到则返回对应索引值，否则返回负数。

示例：

int[] arr = {1, 2, 3};
int index = Arrays.binarySearch(arr, 3);

5. Arrays.equals()

Arrays.equals()函数用于比较两个数组是否相等。

示例：

int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
boolean isEqual = Arrays.equals(arr1, arr2);

二、常用排序算法

1. 冒泡排序

冒泡排序是一种基础排序算法，它逐步比较相邻两个元素的大小，并根据大小交换它们的位置，最终得到从小到大或从大到小的有序数组。

示例：

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

2. 快速排序

快速排序是一种高效的排序算法，它通过不断地选择一个基准值，将数组分为比基准值小和比基准值大的两部分，然后对这两部分递归排序，最终得到有序数组。

示例：

public 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);
    }
}

private int partition(int[] arr, int left, int right) {
    int pivot = left;
    int index = pivot + 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;
}

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

3. 归并排序

归并排序采用分治的思想，它将数组分为两部分，对每一部分递归排序，最后将两部分合并为一个有序数组。

示例：

public void mergeSort(int[] arr, int left, int right) {
    if (left < right) {
        int mid = (left + right) / 2;
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);
        merge(arr, left, mid, right);
    }
}

private void merge(int[] arr, int left, int mid, int right) {
    int[] temp = 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]) {
            temp[k++] = arr[i++];
        } else {
            temp[k++] = arr[j++];
        }
    }
    while (i <= mid) {
        temp[k++] = arr[i++];
    }
    while (j <= right) {
        temp[k++] = arr[j++];
    }
    for (int m = 0; m < temp.length; m++) {
        arr[left + m] = temp[m];
    }
}

总结：以上算法虽然不是所有算法的全集，但它们是解决实际问题时最实用的算法之一。对于不同的问题，我们需要根据其特定的需求选择最适合的算法。