常见的排序算法解析实现

置顶 已于 2024-01-03 09:18:14 修改
阅读量1.1k 收藏 19
点赞数 21
文章标签： 排序算法 算法 数据结构
于 2023-12-29 09:25:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54650406/article/details/135283073
版权

  1. 简单介绍一下排序算法

  2. 具体写一下实现排序的代码

  3. 算法复杂度：时间复杂度和空间复杂度

  4. 是否为稳定排序

选择排序

介绍

SelectSort: 每轮从未排序区间选择最小的元素，将其放到已排序区间的末尾。

实现


import java.util.*;


public class SelectSort {


  public static void selectSort(int[] array) {
    if (array == null) {
      throw new IllegalArgumentException("The input array cannot be null");
    }
    if (array.length <= 1) {
      return;
    }
    int n = array.length;
    for (int i = 0; i < n - 1; i++) {
      int minValueIndex = i;
      for (int j = i + 1; j < n; j++) {
        if (array[minValueIndex] > array[j]) {
          minValueIndex = j;
        }
      }
      swapElementInArray(array, i, minValueIndex);
    }
  }



  public static void swapElementInArray(int[] array, int firstIndex, int secondIndex) {
    if (array == null || array.length == 0) {
      throw new IllegalArgumentException("The input array cannot be null or empty");
    }
    if (firstIndex < 0 || firstIndex >= array.length || secondIndex < 0 || secondIndex >= array.length) {
      throw new IndexOutOfBoundsException("Invalid index values");
    }
    if (firstIndex != secondIndex) {
      int tempElement = array[firstIndex];
      array[firstIndex] = array[secondIndex];
      array[secondIndex] = tempElement;
    }
  }


  public static void main(String[] args) {
    int[] unorderedArray = {2, 1, 1, 9, 8, 5};
    System.out.println(Arrays.toString(unorderedArray));
    selectSort(unorderedArray);
    System.out.println(Arrays.toString(unorderedArray));
  }
}

算法复杂度

  • 时间复杂度： O(n^2)
  • 空间复杂度： O(1) 原地排序

稳定性

非稳定排序，初始的两个相等的元素的相对位置发生了变化

冒泡排序

介绍

冒泡排序是一种简单的比较排序算法，它的基本思想是通过多次遍历待排序的元素，依次比较相邻的两个元素，如果它们的顺序不符合排序要求（例如，如果要升序排序，那么左边的元素比右边的元素大），就交换它们的位置。这样，每一轮遍历都会将当前未排序序列中的最大元素“冒泡”到最后的位置，因此得名“冒泡排序”。

具体步骤如下：

  1. 从数组的第一个元素开始，比较相邻的两个元素。
  2. 如果左边的元素大于右边的元素（如果是升序排序），则交换它们的位置。
  3. 继续比较下一对相邻元素，重复步骤 2，直到遍历到数组的倒数第二个元素。
  4. 重复上述步骤，每次遍历都会将未排序序列中的最大元素“冒泡”到最后的位置。
  5. 每一轮遍历都会减少未排序序列的长度，直到整个数组都有序为止。

冒泡排序的时间复杂度为 O(n^2)，其中 n 是待排序元素的数量。虽然它不是效率最高的排序算法，但它的实现非常简单，适用于小规模数据或已经基本有序的数据集。然而，在大规模数据集上使用冒泡排序会很慢，更高效的排序算法如快速排序和归并排序通常更适合处理大型数据集。

实现


import java.util.*;

public class BubbleSort {

  public static void bubbleSort(int[] array) {
    if (array == null) {
      throw new IllegalArgumentException("The input array cannot be null");
    }
    if (array.length <= 1) {
      return;
    }
    int n = array.length;
    for (int i = n - 1; i > 0; i--) {
      boolean hasSwapped = false;
      for (int j = 0; j < i; j++) {
        if (array[j] > array[j + 1]) {
          swapElementInArray(array, j, j + 1);
          hasSwapped = true;
        }
      }
      if (!hasSwapped) {
        break;
      }
    }
  }

  public static void swapElementInArray(int[] array, int firstIndex, int secondIndex) {
    if (array == null || array.length == 0) {
      throw new IllegalArgumentException("The input array cannot be null or empty");
    }
    if (firstIndex < 0 || firstIndex >= array.length || secondIndex < 0 || secondIndex >= array.length) {
      throw new IndexOutOfBoundsException("Invalid index values");
    }
    if (firstIndex != secondIndex) {
      int tempElement = array[firstIndex];
      array[firstIndex] = array[secondIndex];
      array[secondIndex] = tempElement;
    }
  }



  public static void main(String[] args) {
    int[] unorderedArray = {2, 1, 1, 9, 8, 5};
    System.out.println(Arrays.toString(unorderedArray));
    bubbleSort(unorderedArray);
    System.out.println(Arrays.toString(unorderedArray));

  }
}

算法复杂度

  • 时间复杂度：O(n^2)

  • 空间复杂度：O(1) 原地排序

稳定性

 if (array[j] > array[j + 1]) {
      swapElementInArray(array, j, j + 1);
      hasSwapped = true;
 }

稳定排序：array[j] > array[j + 1] 遇到相等的元素不交换

插入排序

介绍

将待排序的数据分为已排序和未排序两部分，初始时已排序部分只包含第一个元素，然后逐步将未排序部分的元素插入到已排序部分中的适当位置，直到所有元素都被排序为止。

实现

import java.util.*;

public class InsertSort {


  public static void insertSort(int[] array) {
    if (array == null) {
      throw new IllegalArgumentException("The input array cannot be null");
    }
    if (array.length <= 1) {
      return;
    }
    int n = array.length;
    for (int i = 1; i < n; i++) {
      int baseElement = array[i];
      int j = i - 1;
      while (j >= 0 && array[j] > baseElement) {
        array[j + 1] = array[j];
        j--;
      }
      array[j + 1] = baseElement;
    }
  }



  public static void main(String[] args) {
    int[] unorderedArray = {2, 1, 1, 9, 8 ,5};
    System.out.println(Arrays.toString(unorderedArray));
    insertSort(unorderedArray);
    System.out.println(Arrays.toString(unorderedArray));
  }
}

算法复杂度

  • 时间复杂度：O(n^2)

  • 空间复杂度：O(1) 原地排序

稳定性

while (j >= 0 && array[j] > baseElement) {
     array[j + 1] = array[j];
     j--;
}
array[j + 1] = baseElement;

从上面的代码可以看出这是稳定排序，遇到相等的元素了，插入到这一元素的右边。

快速排序

介绍

它基于分而治之的思想，通过将待排序的数组分割成两个子数组，分别排序后再合并，从而实现整个数组的排序。快速排序的特点是平均情况下性能非常好，通常比其他常见的排序算法（如冒泡排序和插入排序）更快。

以下是快速排序的基本思想和步骤：

  1. 选择一个元素作为枢轴（pivot），通常选择数组中的第一个元素或随机选择。枢轴的选择是快速排序的关键，它将数组分为两个子数组。
  2. 划分阶段：将数组中小于枢轴的元素移动到枢轴的左边，将大于枢轴的元素移动到枢轴的右边。这一过程称为分区（partitioning）。可以使用两个指针来遍历数组，一个从左边开始，一个从右边开始，直到它们相遇。在这个过程中，小于枢轴的元素被交换到左边，大于枢轴的元素被交换到右边。
  3. 递归排序：将左右两个子数组分别递归地应用快速排序算法。这将继续划分和排序子数组，直到每个子数组只包含一个元素或为空。
  4. 合并：已排序的子数组会被合并成一个完整的有序数组。

实现

package sorts7;

import java.util.*;


public class QuickSort {

  public static void quickSort(int[] array, int leftIndex, int rightIndex) {
    if (leftIndex >= rightIndex) {
      return;
    }
    int pivotIndex = partition(array, leftIndex, rightIndex);
    quickSort(array, leftIndex, pivotIndex - 1);
    quickSort(array, pivotIndex + 1, rightIndex);
  }

  public static int partition(int[] array, int leftIndex, int rightIndex) {
    int i = leftIndex;
    int j = rightIndex;
    while (i < j) {
      while (i < j && array[j] >= array[leftIndex]) {
        j--;
      }
      while (i < j && array[i] <= array[leftIndex]) {
        i++;
      }
      swapElementInArray(array, j, i);
    }
    swapElementInArray(array, i, leftIndex);
    return i;
  }


  public static void swapElementInArray(int[] array, int firstIndex, int secondIndex) {
    if (array == null || array.length == 0) {
      throw new IllegalArgumentException("The input array cannot be null or empty");
    }
    if (firstIndex < 0 || firstIndex >= array.length || secondIndex < 0 || secondIndex >= array.length) {
      throw new IndexOutOfBoundsException("Invalid index values");
    }
    if (firstIndex != secondIndex) {
      int tempElement = array[firstIndex];
      array[firstIndex] = array[secondIndex];
      array[secondIndex] = tempElement;
    }
  }




  public static void main(String[] args) {

    int[] unorderedArray = {2, 1, 1, 9, 8, 5};
    System.out.println(Arrays.toString(unorderedArray));
    quickSort(unorderedArray, 0, unorderedArray.length - 1);
    System.out.println(Arrays.toString(unorderedArray));
  }
}

算法复杂度

  • 时间复杂度：O(nlogn) 递归层数为 log n ，循环次数为 n， 时间复杂度为 O(nlogn)

  • 空间复杂度：O(n) 最坏的情况下，使用的是 O(n)的栈帧空间

稳定性

不稳定排序

归并排序

介绍

归并排序的核心思想是将待排序的数组分割成若干个小数组，然后逐个合并这些小数组，最终得到一个有序的数组。归并排序的特点是稳定且具有一定的性能优势，尤其在大型数据集上表现良好。

以下是归并排序的基本思想和步骤：

  1. 分割阶段：将待排序的数组分割成两个相等或近似相等的子数组，通常采用递归方式进行分割，直到每个子数组只包含一个元素或为空。
  2. 合并阶段：逐个合并已分割的子数组，同时保持它们的有序性。合并过程中，将两个有序子数组合并成一个更大的有序数组。这一过程将一直进行，直到所有子数组都被合并成一个完整的有序数组。
  3. 递归排序：递归地对子数组进行归并排序，直到整个数组都有序。

实现

package sorts7;

import java.util.*;

public class MergeSort {



  public static int[] mergeSort(int[] array) {
    if (array.length <= 1) {
      return array;
    }
    int midIndex = array.length >> 1;
    int[] leftArray = Arrays.copyOfRange(array, 0, midIndex);
    int[] rightArray = Arrays.copyOfRange(array, midIndex, array.length);
    return merge(mergeSort(leftArray), mergeSort(rightArray));
  }

  public static int[] merge(int[] leftArray, int[] rightArray) {
    if (leftArray == null || leftArray.length == 0) {
      return rightArray;
    }
    if (rightArray == null || rightArray.length == 0) {
      return leftArray;
    }
    int leftIndex = 0;
    int rightIndex = 0;
    int mergedIndex = 0;
    int[] mergedArray = new int[leftArray.length + rightArray.length];

    while (leftIndex < leftArray.length && rightIndex < rightArray.length) {
      if (leftArray[leftIndex] < rightArray[rightIndex]) {
        mergedArray[mergedIndex++] = leftArray[leftIndex++];
      } else {
        mergedArray[mergedIndex++] = rightArray[rightIndex++];
      }
    }
    while (leftIndex < leftArray.length) {
      mergedArray[mergedIndex++] = leftArray[leftIndex++];
    }


    while (rightIndex < rightArray.length) {
      mergedArray[mergedIndex++] = rightArray[rightIndex++];
    }
    return mergedArray;

  }



  public static void main(String[] args) {
    int[] unorderedArray = {2, 1, 1, 9, 8, 5};
    System.out.println(Arrays.toString(unorderedArray));
    int[] mergedArray = mergeSort(unorderedArray);
    System.out.println(Arrays.toString(mergedArray));
  }
}

算法复杂度

  • 时间复杂度：O(nlogn) 递归的深度为 log n ，合并的时间复杂度为 O(n)， 时间复杂度为 O(nlogn)

  • 空间复杂度：O(n) 最坏的情况下，使用的是 O(n)的栈帧空间

稳定性

稳定排序

堆排序

介绍

堆排序（Heap Sort）是一种基于二叉堆数据结构的排序算法，它的核心思想是将待排序的数组看作是一个二叉堆，通过构建最大堆（Max Heap）或最小堆（Min Heap）来实现排序。在堆排序中，首先将数组转换成一个二叉堆，然后不断从堆中移出最大（或最小）元素，放入已排序部分，直到整个数组有序。

实现

package sorts7;

import java.util.*;

public class HeapSort {


  public static void heapSort(int[] array) {
    if (array == null) {
      throw new IllegalArgumentException("The input array cannot be null");
    }
    if (array.length <= 1) {
      return;
    }
    int n = array.length;
    for (int i = n / 2 - 1; i >= 0; i--) {
      heapify(array, i, n);
    }
    for (int i = n - 1; i > 0; i--) {
      swapElementInArray(array, 0, i);
      heapify(array, 0, i);
    }
  }




  public static void heapify(int[] array, int i, int n) {
    int maxValueIndex = i;
    int leftIndex = 2 * i + 1;
    int rightIndex = 2 * i + 2;
    if (leftIndex < n && array[leftIndex] > array[maxValueIndex]) {
      maxValueIndex = leftIndex;
    }
    if (rightIndex < n && array[rightIndex] > array[maxValueIndex]) {
      maxValueIndex = rightIndex;
    }
    if (i != maxValueIndex) {
      swapElementInArray(array, i, maxValueIndex);
      heapify(array, maxValueIndex, n);
    }
  }

  public static void swapElementInArray(int[] array, int firstIndex, int secondIndex) {
    if (array == null || array.length == 0) {
      throw new IllegalArgumentException("The input array cannot be null or empty");
    }
    if (firstIndex < 0 || firstIndex >= array.length || secondIndex < 0 || secondIndex >= array.length) {
      throw new IndexOutOfBoundsException("Invalid index values");
    }
    if (firstIndex != secondIndex) {
      int tempElement = array[firstIndex];
      array[firstIndex] = array[secondIndex];
      array[secondIndex] = tempElement;
    }
  }



  public static void main(String[] args) {
    int[] unorderedArray = {2, 1, 1, 9, 8, 5};
    System.out.println(Arrays.toString(unorderedArray));
    heapSort(unorderedArray);
    System.out.println(Arrays.toString(unorderedArray));
  }
}

算法复杂度

  • 时间复杂度为 O(n log n)
  • 空间复杂度为 O(1)

稳定性

不稳定排序

计数排序

介绍

计数排序（Counting Sort）是一种非比较性的整数排序算法，适用于待排序元素都是非负整数的情况。计数排序的核心思想是通过统计每个元素出现的次数，然后根据这些统计信息将元素放置在正确的位置上，从而完成排序。

以下是计数排序的关键特点和步骤：

  1. 找到待排序数组中的最大值，以确定计数数组的大小。计数数组的大小为最大元素值加一。
  2. 创建一个计数数组，用于存储每个元素出现的次数。初始时，计数数组的所有元素都初始化为 0。
  3. 遍历待排序数组，统计每个元素出现的次数，并将统计结果存储在计数数组中。具体来说，对于数组中的每个元素 x，将计数数组中的 counts[x]加 1。
  4. 根据计数数组中的统计信息，重新构建有序数组。遍历计数数组，对于每个元素 x，将 x 重复 counts[x]次放入有序数组中。
  5. 完成排序后，有序数组即为排序结果。

实现

package sorts7;

import java.util.*;


public class CountSort {

  public static void countSort(int[] nums) {
    if (nums == null) {
      throw new IllegalArgumentException("The input nums cannot be null");
    }
    if (nums.length <= 1) {
      return;
    }
    int maxValue = 0;
    for (int num : nums) {
      maxValue = Math.max(num, maxValue);
    }
    int[] counts = new int[maxValue + 1];
    for (int num : nums) {
      counts[num]++;
    }
    int sortedIndex = 0;

    for (int value = 0; value < counts.length; value++) {
      for (int i = 0; i < counts[value]; i++) {
        nums[sortedIndex++] = value;
      }
    }



  }



  public static void main(String[] args) {
    int[] unorderedArray = {2, 1, 1, 9, 8, 5};
    System.out.println(Arrays.toString(unorderedArray));
    countSort(unorderedArray);
    System.out.println(Arrays.toString(unorderedArray));
  }
}

算法复杂度

  • 时间复杂度：计数排序的时间复杂度为 O(n + k)，其中 n 是待排序元素的数量，k 是计数数组的大小。当 k 不过于大且是常数时，计数排序的时间复杂度可以近似看作 O(n)

  • 空间复杂度：计数排序的空间复杂度取决于计数数组的大小，通常为 O(k)，其中 k 是计数数组的大小。计数数组的大小取决于待排序数据中的最大元素值。如果待排序数据的范围很大，那么计数数组的大小也会很大，从而导致空间复杂度增加。

稳定性

稳定排序

桶排序

介绍

桶排序（Bucket Sort）是一种分布式排序算法，它将元素分散到多个桶中，然后对每个桶中的元素进行排序，最后将桶中的元素按顺序合并起来，形成有序的输出。桶排序通常用于处理具有均匀分布的输入数据。

以下是桶排序的简要介绍：

初始化桶： 首先，确定要使用的桶的数量，通常是根据输入数据的范围和分布来确定的。每个桶可以是一个容器，可以是数组、链表或其他数据结构。

分配元素到桶中： 接下来，遍历输入数组，将每个元素根据某种规则分配到相应的桶中。分配规则通常是将元素映射到特定的桶索引。这个映射可以使用一种映射函数来完成。

对每个桶进行排序： 一旦元素分配到桶中，就对每个桶中的元素进行排序。通常，桶内排序可以使用快速排序、归并排序等常见的排序算法，也可以选择其他排序方法，具体取决于应用的需要。

合并桶中的元素： 排序后，将各个桶中的元素按照桶的顺序合并起来，形成有序的输出。合并可以通过简单地按顺序访问每个桶中的元素并放入输出数组来实现。

输出结果： 最终得到一个有序的输出数组，其中包含了输入数据的有序排列。

实现

import java.util.*;


public class BucketSort {


  public static void bucketSort(float[] nums) {
    if (nums == null) {
      throw new IllegalArgumentException("The input nums cannot be null");
    }
    if (nums.length <= 1) {
      return;
    }


    int halfLength = nums.length / 2;
    List<List<Float>> buckets = new ArrayList<>();
    for (int i = 0; i < halfLength; i++) {
      buckets.add(new ArrayList<>());
    }


    for (float num : nums) {
      int bucketIndex = (int) (num * halfLength);
      buckets.get(bucketIndex).add(num);
    }


    for (List<Float> bucket : buckets) {
      Collections.sort(bucket);
    }

    int sortedIndex = 0;
    for (List<Float> bucket : buckets) {
      for (float num : bucket) {
        nums[sortedIndex++] = num;
      }
    }
  }

  public static void main(String[] args) {
    float[] unorderedArray = {0.2f, 0.1f, 0.1f, 0.3f, 0.5f, 0.7f, 0.6f};
    System.out.println(Arrays.toString(unorderedArray));
    bucketSort(unorderedArray);
    System.out.println(Arrays.toString(unorderedArray));
  }

}

算法复杂度

  • 时间复杂度: O(n), 当桶的数量比较多的时候。
  • 空间复杂度: O(n + k), 需要借助 k 个桶和 List 中的 n 个元素的额外空间

稳定性

桶排序的稳定性取决于每个桶里面的排序算法的稳定性

for (List<Float> bucket : buckets) {
    Collections.sort(bucket);
}

github 仓库地址: https://github.com/XIAOZHUXUEJAVA/sorting-algorithms-in-java

xiaozhulzq
关注
  • 21
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java实现数据结构常见排序算法及详解
11-08
详细讲述了8中常见算法的原理及思想，并用JAVA进行了实现，代码中有详细的注释，解释了算法的实现逻辑和一些小技巧。
常见排序算法详解
小鱼学编程
07-20 1647
今天，我们来详细讲解一下常见的排序算法
详细解析十大排序算法(js实现)
带你回江南的博客
06-07 2914
这里写自定义目录标题排序算法复杂度对比冒泡排序实现合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 排序算法复杂度对比 以上表格是基于数组进行排序的一般结论 冒泡、选择、插入、归并、快速、希尔、堆排，属于比较排序 你好！ 这是你第一次使用
【算法系列 | 4】深入解析排序算法之——归并排序
热门推荐
颜淡慕潇
06-10 2万+
排序算法是很常见的一类问题，主要是将一组数据按照某种规则进行排序。以下是一些常见的排序算法：冒泡排序（Bubble Sort）插入排序（Insertion Sort）选择排序（Selection Sort）归并排序（Merge Sort）快速排序（Quick Sort）堆排序（Heap Sort）归并排序（Merge Sort）是一种基于分治思想的排序算法，它将待排序的数组分成两部分，分别对这两部分递归地进行排序，最后将两个有序子数组合并成一个有序数组。
【算法系列 | 1】深入解析排序算法之——冒泡排序
颜淡慕潇
06-02 1万+
这些排序算法各有特点，可以根据具体需求选择适合的算法。在实际应用中，常常需要综合考虑时间复杂度、空间复杂度、稳定性等因素进行选择。
【算法系列 | 3】深入解析排序算法之——选择排序
颜淡慕潇
06-09 1万+
排序算法是很常见的一类问题，主要是将一组数据按照某种规则进行排序。以下是一些常见的排序算法：冒泡排序（Bubble Sort）插入排序（Insertion Sort）选择排序（Selection Sort）归并排序（Merge Sort）快速排序（Quick Sort）堆排序（Heap Sort）选择排序（Selection Sort）是一种简单的排序算法，其基本原理是在未排序的元素中找到最小（或最大）的元素，然后将其放在已排序的序列的末尾。重复这个过程，直到所有元素都被排序完毕。
【C语言】八大排序算法
weixin_63449996的博客
09-30 1万+
本文详细介绍了数据结构的排序算法，结合动图，基本思想，解析，代码，你也可以手撕算法。
【算法系列 | 6】深入解析排序算法之——堆排序
颜淡慕潇
06-13 1万+
堆排序（Heap Sort）是一种基于堆数据结构的排序算法，其核心思想是将待排序的序列构建成一个最大堆（或最小堆），然后将堆顶元素与最后一个元素交换，再将剩余元素重新调整为最大堆（或最小堆），重复以上步骤直到所有元素都有序。
JAVA实现十大基本排序算法
曾小二的博客
05-26 2036
基本排序算法 排序是计算机的核心内容，快速排序算法一直推动计算机的发展，同时也可以为我们工作生活提供一些有益的优化，帮助我们了解管理与社会的本质。 0、算法概述 0.1 算法分类 十种常见排序算法可以分为两大类： 非线性时间比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此称为非线性时间比较类排序。 线性时间非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此称为线性时间非比较类排序。 0.2 算法复杂度 术语说
八种常见经典排序算法
weixin_38405770的博客
02-17 1700
八种常见经典排序算法 1、冒泡排序（Bubble Sort） 冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。 1.1 算法描述 比较相邻的元素。如果第一个比第二个大，就交换它们两个； ...
Java语言实现常用的十种排序算法
Young_深情不及里子的博客
02-23 2139
排序问题一直都是程序工作或面试中的重点，特别是对于排序算法而言，在一些公司的笔试中，手写个冒泡啥的也不足为奇，因此今天抽空整理一下Java语言实现的各类排序算法，互勉学习一下。
十大排序算法
10-16
常见10大算法，从原理，动图解析到代码实现，逐步分析，让你轻松入门算法
java常见算法题解析大全。
11-22
这里是java常见算法题的集合，貌似包含了500多提的题目及其答案源码和分析过程。比如折半查找，各种排序，还有各种经典的算法小题的java解答。总之，不会令你失望。
十大排序算法.rar
12-26
常见排列算法，十大排列算法，GIF解析，快速掌握数据结构的算法问题，非常适合初学者，入门级别。插入排序，堆排序，基数排序，快速排序，冒泡排序，希尔排序，选择排序
JAVA经典算法42例.rar
03-10
每个算法都提供了详细的解析和代码实现，帮助读者深入理解算法的原理和应用。 对于初学者，这些算法可以帮助他们掌握Java语言的基本语法和编程技巧，同时了解常见算法的实现方式。对于有一定基础的开发者，可以通过...
排序算法（1）
2301_79783967的博客
04-28 1738
1. 堆排序使用堆来选数，效率就高了很多。2. 时间复杂度：O(N*logN)3. 空间复杂度：O(1)4. 稳定性：不稳定。
笔试强训-day17_T2 十字爆破
最新发布
weixin_46186903的博客
05-03 783
模拟即可，但是由于数据量过⼤，我们可以提前把每⼀⾏以及每⼀列的和存起来，⽅便统计总和。解法二：提前把每⼀⾏以及每⼀列的和存起来，然后输入输出使用快速的IO方式，解答如下所示。解法一：暴力遍历，这种方法很容易想到，并且也容易编写出代码，但是会超时。因为1+2+3=6，1+2+4=7，1+3+4=8，2+3+4=9。牛牛选择一个方格，可以得到和这个方格同行、同列的所有数之和的得分。现在牛牛想知道下一步选择每个格子的得分情况，你可以帮帮他吗？m个方格，每个方格中有一个整数。
leetcode16-3Sum Closest
我的程序人生
04-29 429
这道题目和那道3Num的题目很类似，解题思路也是类似的，我们先对数组排序，然后固定一个元素，通过双指针遍历剩下的元素，用一个哨兵记录三个元素的和与target的diff，分别处理三个元素的和小于target，大于target，等于target这三种情况即可。请你从 nums 中选出三个整数，使它们的和与 target 最接近。解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2)。输入：nums = [-1,2,1,-4], target = 1。假定每组输入只存在恰好一个解。
基于模糊PI控制算法的龙格库塔CSTR模型控制系统simulink建模与仿真
熟悉MATLAB/fpga/RK3588/LABVIEW/protus/单片机/dsp/Multisim
04-30 722
基于模糊PI控制算法的龙格库塔CSTR模型控制系统simulink建模与仿真。基于模糊PI控制算法的龙格-库塔（Runge-Kutta, RK）连续搅拌釜反应器（Continuous Stirred Tank Reactor, CSTR）模型控制系统，是将模糊控制理论与经典的数值积分方法相结合的一种先进控制策略。模糊控制是一种基于模糊集合理论和语言变量的控制方法，适用于非线性、时变系统的控制。
排序算法和NLP算法的区别
09-18
### 回答1： 排序算法和NLP算法的区别在于它们解决的问题不同。排序算法是用于对一组数据进行排序，而NLP算法则是用于自然语言处理，例如文本分类、情感分析等。排序算法通常涉及到数学和计算机科学的基础知识，而NLP算法则需要深入了解自然语言的语法、语义等方面。 ### 回答2： 排序算法和NLP算法是两种完全不同的算法。 排序算法是针对一组数据的排列顺序进行操作的算法。其主要目的是将数据按照一定的规则重新排列，例如按照升序或降序的方式排列。常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序等。排序算法的核心思想是通过比较和交换数据元素的位置来实现排序。 而NLP（自然语言处理）算法则是一种用来处理和分析人类自然语言的算法。NLP算法主要涉及文本分析、语义理解、文本生成、机器翻译等。NLP算法的核心思想是通过分析文本中的语法、结构和意义等要素来对文本进行处理和理解。 排序算法和NLP算法的不同之处主要体现在两个方面： 1. 目标和应用领域的不同：排序算法主要应用于对一组数据进行排序，可以用在各种需要对数据进行排序的场景中；而NLP算法主要用于处理和理解自然语言文本，可以应用于文本分析、机器翻译、情感分析等领域。 2. 核心处理方式的不同：排序算法主要通过比较和交换数据元素的位置来实现排序；而NLP算法则主要通过对文本进行语法解析、词义分析、语义理解等处理来实现对文本的理解和分析。 综上所述，排序算法和NLP算法是两个完全不同的算法，分别用于对数据进行排序和对自然语言进行处理和分析。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值