java常见算法一览（不定期更新中......）

蜡笔214

已于 2024-12-27 22:06:26 修改

阅读量165

点赞数 1

文章标签： java 开发语言算法

于 2023-07-12 14:41:07 首次发布

本文链接：https://blog.youkuaiyun.com/qq_20362867/article/details/131681145

版权

本文介绍了几种常见的排序算法在PHP中的实现，包括效率较高的二分查找法，以及效率较低但易于理解的冒泡排序。还展示了桶排序和快速排序的原理及代码示例，其中快速排序在平均情况下的时间复杂度为O(nlogn)。此外，还讨论了递归算法在计算阶乘和斐波那契数列中的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

插入排序

public static void insertionSort(int[] arr) {
    //从数组第二个元素开始遍历
    for (int i = 1; i < arr.length; i++) {
        int current = arr[i]; // 待插入的元素
        int j = i - 1; //已排好序的最后一个元素
        // 找到插入位置，将比 current 大的元素向后移动
        while (j >= 0 && arr[j] > current) {
        arr[j + 1] = arr[j];
            j--;
        }
        // 插入到正确位置
        arr[j + 1] = current;
    }
}

快速排序

public static void quickSort(int[] arr, int low, int high){
	if (low < high) {
		int index = getIndex(arr, low, high);
		quickSort(arr, low, index - 1);
		quickSort(arr, index + 1, high);
	}
}
//获取基准元素的索引
public static int getIndex(int[] arr, int low, int high){
	//假定一个基准元素
	int pivot = arr[high];
	//i是小于基准元素的区域的末尾，默认从-1位置开始
	int i = low - 1;
	//遍历操作
	for (int j = low; j < high; j++) {
		if (arr[j] < pivot) {
			i++;
			swap(arr, i, j);
		}
	}
	//将基准元素放到正确位置
	swap(arr, i + 1, high);
	return i + 1;
}
//交换元素
public static void swap(int[] arr, int i, int j){
	int temp = arr[i];
	arr[i] = arr[j];
	arr[j] = temp;
}

冒泡排序：

public static void bubbleSort(int[] arr) {
    int n = arr.length;
    boolean swapped;
        
    for (int i = 0; i < n - 1; i++) {
        swapped = false;
            
        for (int j = 0; j < n - 1 - i; j++) {
            // 如果当前元素大于下一个元素，交换它们
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swapped = true;
            }
        }
            
        // 如果内层循环没有发生交换，说明数组已经有序
        if (!swapped) {
            break;
        }
    }
}

合并两个有序数组

public static int[] mergeToArray(int[] arr1, int[] arr2){
    int m = arr1.length;
    int n = arr2.length;
    int[] arr3 = new int[m + n];//合并后的结果数组

    //双指针法，下标从0开始，比较两个数组的元素，哪个小哪个就丢到结果数组里
    int i = 0, j = 0, k = 0;
    while (i < m && j < n) {
       if (arr1[i] < arr2[j]) {
          arr3[k++] = arr1[i++];
       } else {
          arr3[k++] = arr2[j++];
       }
    }

    //如果i还没遍历完，则把结果全都丢进结果数组
    while (i < m) {
       arr3[k++] = arr1[i++];
    }
    //如果j还没遍历完，则把结果全都丢进结果数组
    while (j < n) {
       arr3[k++] = arr1[j++];
    }
    return arr3;
}

二分法查找元素

public static int binarySearchIterative(int[] arr, int target) {
    int left = 0;
    int right = arr.length - 1;
        
    while (left <= right) {
        int mid = left + (right - left) / 2;
        // 找到目标值
        if (arr[mid] == target) {
            return mid;
        }
            
        // 目标值在左半部分
        if (arr[mid] > target) {
            right = mid - 1;
        }
        // 目标值在右半部分
        else {
            left = mid + 1;
        }
    }
        
    return -1; // 未找到目标值
}