Java语言实现的一些其他常用算法

Java语言实现的冒泡排序算法： public static void bubbleSort(int[] arr) { int n = arr.length; for (int i = 0; i < n-1; i++) { for (int j = 0; j < n-i-1; j++) { if (arr[j] > arr[j+1]) { // swap arr[j] and arr[j+1] int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } } }

以下是Java语言实现的递归函数示例：

java public static int recursiveFunction(int n) { if (n == 0) { return 0; } else if (n == 1) { return 1; } else { return recursiveFunction(n-1) + recursiveFunction(n-2); } } 这个函数采用了递归的方式来计算斐波那契数列的第n项。如果n等于0，则返回0；如果n等于1，则返回1；否则，递归调用函数来计算前两项的和。

您可以使用以下代码段来测试该函数：

java int result = recursiveFunction(6); // 计算斐波那契数列的第6项 System.out.println(result); // 输出结果：8 请注意，尽管递归函数可以解决某些问题，但由于其可能导致栈溢出等问题，因此需要谨慎使用。

以下是Java语言实现的一些其他常用算法及其代码示例：

选择排序 java public static void selectionSort(int[] arr) { int n = arr.length; for (int i = 0; i < n-1; i++) { int minIndex = i; for (int j = i+1; j < n; j++) { if (arr[j] < arr[minIndex]) { minIndex = j; } } // swap arr[i] and arr[minIndex] int temp = arr[i]; arr[i] = arr[minIndex]; arr[minIndex] = temp; } } 插入排序 java public static void insertionSort(int[] arr) { int n = arr.length; for (int i = 1; i < n; i++) { int key = arr[i]; int j = i - 1; while (j >= 0 && arr[j] > key) { arr[j+1] = arr[j]; j--; } arr[j+1] = key; } } 快速排序 java public static void quickSort(int[] arr, int low, int high) { if (low < high) { int pivotIndex = partition(arr, low, high); quickSort(arr, low, pivotIndex-1); quickSort(arr, pivotIndex+1, high); } }

public static int partition(int[] arr, int low, int high) { int pivot = arr[high]; int i = low - 1; for (int j = low; j < high; j++) { if (arr[j] < pivot) { i++; // swap arr[i] and arr[j] int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } // swap arr[i+1] and arr[high] int temp = arr[i+1]; arr[i+1] = arr[high]; arr[high] = temp; return i+1; } 归并排序 java public static 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); } }

public static void merge(int[] arr, int left, int mid, int right) { int n1 = mid - left + 1; int n2 = right - mid;

int[] L = new int[n1];
int[] R = new int[n2];

for (int i = 0; i < n1; i++) {
    L[i] = arr[left+i];
}
for (int j = 0; j < n2; j++) {
    R[j] = arr[mid+1+j];
}

int i = 0, j = 0, k = left;
while (i < n1 && j < n2) {
    if (L[i] <= R[j]) {
        arr[k] = L[i];
        i++;
    } else {
        arr[k] = R[j];
        j++;
    }
    k++;
}

while (i < n1) {
    arr[k] = L[i];
    i++;
    k++;
}

while (j < n2) {
    arr[k] = R[j];
    j++;
    k++;
}

} 以上算法的时间复杂度分别为：

选择排序：O(n^2) 插入排序：O(n^2) 或 O(n)（如果输入数组已经有序） 快速排序：平均情况下 O(nlog(n))，最坏情况下 O(n^2) 归并排序：O(nlog(n))