21xrx.com
2024-09-17 04:17:59 Tuesday
登录
文章检索 我的文章 写文章
我一直对Java排序算法的时间复杂度很感兴趣
2023-06-10 08:42:01 深夜i     --     --
- 冒泡排序

我一直对Java排序算法的时间复杂度很感兴趣。在本文中,我将介绍一些常用的Java排序算法以及它们的时间复杂度。我将着重讨论以下三个 、快速排序和归并排序。

冒泡排序:

冒泡排序是一种最简单但最慢的排序算法。这个算法将数组中相邻的两个元素进行比较,然后将它们交换位置,直到整个数组都排好序。最坏情况下,排序的时间复杂度为O(n^2)。

示例代码:


public 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]) {

        int temp = arr[j];

        arr[j] = arr[j+1];

        arr[j+1] = temp;

      }

    }

  }

}

快速排序:

快速排序是一种使用分治法来实现的排序算法。在快速排序中,我们选择一个pivot元素并将数组分为两个部分,一部分比pivot小,另一部分比pivot大。然后对每个部分再进行递归排序。快速排序的时间复杂度最坏情况下为O(n^2),但通常情况下是O(nlogn)。

示例代码:


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

  }

}

private int partition(int[] arr, int low, int high) {

  int pivot = arr[high];

  int i = (low - 1);

  for (int j = low; j <= high-1; j++) {

    if (arr[j] < pivot) {

      i++;

      int temp = arr[i];

      arr[i] = arr[j];

      arr[j] = temp;

    }

  }

  int temp = arr[i+1];

  arr[i+1] = arr[high];

  arr[high] = temp;

  return (i + 1);

}

归并排序:

归并排序是一种基于分治法的排序算法。在归并排序中,我们将数组分为两个部分,对每个部分分别进行排序,然后将两个部分合并成一个有序数组。最坏情况下,归并排序的时间复杂度为O(nlogn)。

示例代码:


public void mergeSort(int[] arr, int l, int r) {

  if (l < r) {

    int m = (l + r) / 2;

    mergeSort(arr, l, m);

    mergeSort(arr, m + 1, r);

    merge(arr, l, m, r);

  }

}

private void merge(int[] arr, int l, int m, int r) {

  int left = m - l + 1;

  int right = r - m;

  int[] L = new int[left];

  int[] R = new int[right];

  for (int i = 0; i < left; ++i) {

    L[i] = arr[l + i];

  }

  for (int j = 0; j < right; ++j) {

    R[j] = arr[m + 1 + j];

  }

  int i = 0, j = 0;

  int k = l;

  while (i < left && j < right) {

    if (L[i] <= R[j]) {

      arr[k++] = L[i++];

    } else {

      arr[k++] = R[j++];

    }

  }

  while (i < left) {

    arr[k++] = L[i++];

  }

  while (j < right) {

    arr[k++] = R[j++];

  }

}

综上所述,本文介绍了几种常用的Java排序算法,包括冒泡排序、快速排序和归并排序,以及它们的时间复杂度。在选择排序算法时,我们需要考虑到数据的大小以及排序的速度和效率。

  
  

评论区

{{item['qq_nickname']}}
()
回复
回复