八大排序算法

news2024/11/23 18:38:40

八大排序算法

是指常用的八种排序算法，它们包括：

  1. 冒泡排序（Bubble Sort）：通过不断交换相邻元素的位置，将最大（或最小）的元素逐渐"冒泡"到最后（或最前）的位置。

  2. 选择排序（Selection Sort）：每次从未排序的部分中选择最小（或最大）的元素，并将其放置在已排序部分的末尾。

  3. 插入排序（Insertion Sort）：逐个将元素插入到已排序序列的适当位置，直到所有元素都被插入完毕。

  4. 希尔排序（Shell Sort）：将待排序的序列按照一定的间隔分成若干子序列，对子序列进行插入排序，然后逐渐缩小间隔，直至间隔为1，完成最后的排序。

  5. 归并排序（Merge Sort）：将待排序序列不断划分为较小的子序列，然后将这些子序列两两合并，直到最终只剩下一个有序序列。

  6. 快速排序（Quick Sort）：通过一次划分操作将序列分成两部分，其中一部分的元素都比另一部分小（或大），然后递归地对两部分进行排序。

  7. 堆排序（Heap Sort）：将待排序序列构建成一个堆（大顶堆或小顶堆），然后依次将堆顶元素与最后一个元素交换并调整堆，重复这个过程直到整个序列有序。

  8. 计数排序（Counting Sort）：通过确定每个元素在序列中的位置来排序，需要额外的辅助空间来记录元素出现的次数。

这些排序算法在不同场景下有不同的优劣势，选择适当的排序算法可以提高排序效率。

在这里插入图片描述

优缺点

下面是一个表格，用于统计八大排序算法的优点和缺点：

排序算法优点缺点
冒泡排序简单易懂，实现简单效率较低，对于大规模数据排序较慢
选择排序实现简单，不占用额外空间效率较低，对于大规模数据排序较慢
插入排序对于小规模数据排序效率较高，稳定对于大规模数据排序较慢
希尔排序相对于简单插入排序，效率较高实现较为复杂，需要选择合适的增量序列
归并排序稳定，对于大规模数据排序效率较高需要额外的空间来存储临时数组，实现稍复杂
快速排序效率较高，适用于大规模数据排序对于已基本有序的数据，效率较低
堆排序效率较高，适用于大规模数据排序需要额外的空间来构建堆，实现稍复杂
计数排序稳定，对于数据值分布均匀的情况下，效率较高需要额外的空间来记录元素出现次数，仅适用于非负整数的排序

需要注意的是，这些优点和缺点是相对的，对于不同的应用场景和数据特征，排序算法的表现可能会有所不同。因此，在选择排序算法时，需要综合考虑数据规模、数据分布、稳定性要求等因素。

图解链接

排序过程图解

实现

使用 JavaScript 实现八大排序算法的示例代码

  1. 冒泡排序（Bubble Sort）：
    冒泡排序（Bubble Sort）是一种简单的排序算法，它的基本思想是通过相邻元素的比较和交换，将最大（或最小）的元素逐渐"冒泡"到序列的末尾（或最前）位置。

冒泡排序的逻辑和原理如下：

  1. 首先，比较相邻的两个元素，如果前一个元素大于后一个元素，则交换它们的位置，使得较大的元素"冒泡"到右侧。

  2. 对每一对相邻元素进行同样的操作，依次比较相邻的两个元素，将较大的元素向右移动，直到最后一个元素。

  3. 针对剩下的未排序部分，重复以上步骤，每一轮都将最大的元素"冒泡"到当前未排序部分的末尾。

  4. 重复执行上述步骤，直到所有元素都排序完毕。

冒泡排序的过程可以用以下伪代码表示：

冒泡排序(arr):
    n = arr.length
    for i from 0 to n - 1:
        for j from 0 to n - 1 - i:
            if arr[j] > arr[j + 1]:
                交换 arr[j] 和 arr[j + 1] 的位置

在每一轮内层循环中，相邻的两个元素进行比较，如果前一个元素大于后一个元素，则交换它们的位置。通过多轮的比较和交换，较大的元素逐渐向右移动，最终达到排序的目的。

冒泡排序的特点是简单易懂，但效率相对较低，尤其在处理大规模数据时。它的时间复杂度为 O(n^2)，其中 n 是待排序序列的长度。同时，冒泡排序是一种稳定的排序算法，相等元素的相对位置在排序前后不会改变。

js代码实现：

function bubbleSort(arr) {
  const len = arr.length;
  for (let i = 0; i < len - 1; i++) {
    for (let j = 0; j < len - 1 - i; j++) {
      if (arr[j] > arr[j + 1]) {
        [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]]; // 交换位置
      }
    }
  }
  return arr;
}

思考：为什么 i的结束是len - 1 而不是len

  1. 选择排序（Selection Sort）：
    选择排序（Selection Sort）是一种简单直观的排序算法，其基本思想是每次从未排序的部分中选择最小（或最大）的元素，然后将其放到已排序部分的末尾（或开头）。

选择排序的逻辑和原理如下：

  1. 首先，找到数组中最小（或最大）的元素，记为当前轮次的最小值（或最大值）。

  2. 将最小（或最大）值与未排序部分的第一个元素交换位置，将最小值放到已排序部分的末尾（或最大值放到已排序部分的开头）。

  3. 对剩余未排序的部分重复以上步骤，每一轮选择并交换出一个最小（或最大）值，直到所有元素排序完毕。

选择排序的过程可以用以下伪代码表示：

选择排序(arr):
    n = arr.length
    for i from 0 to n - 1:
        minIndex = i
        for j from i + 1 to n - 1:
            if arr[j] < arr[minIndex]:
                minIndex = j
        交换 arr[i] 和 arr[minIndex] 的位置

在每一轮外层循环中，首先假设未排序部分的第一个元素是当前轮次的最小值（或最大值）。然后，通过内层循环遍历未排序部分的剩余元素，如果找到比当前最小值（或最大值）更小（或更大）的元素，更新最小值（或最大值）的索引。

完成内层循环后，将当前轮次的最小值（或最大值）与未排序部分的第一个元素进行交换，将其放到已排序部分的末尾（或开头）。这样，已排序部分逐渐增加，未排序部分逐渐减少，直到所有元素排序完毕。

选择排序的时间复杂度为 O(n^2)，其中 n 是待排序序列的长度。它是一种不稳定的排序算法，相等元素的相对位置在排序前后可能会改变。

js代码实现：

function selectionSort(arr) {
  const len = arr.length;
  for (let i = 0; i < len - 1; i++) {
    let minIndex = i;
    for (let j = i + 1; j < len; j++) {
      if (arr[j] < arr[minIndex]) {
        minIndex = j;
      }
    }
    [arr[i], arr[minIndex]] = [arr[minIndex], arr[i]]; // 交换位置
  }
  return arr;
}
  1. 插入排序（Insertion Sort）：
    插入排序（Insertion Sort）是一种简单直观的排序算法，其基本思想是将未排序部分的元素逐个插入到已排序部分的合适位置，从而构建有序序列。

插入排序的逻辑和原理如下：

  1. 将数组的第一个元素视为已排序部分，其余元素视为未排序部分。

  2. 从未排序部分选择第一个元素，将其插入到已排序部分的合适位置，使得已排序部分仍然保持有序。

  3. 重复以上步骤，每次从未排序部分选择一个元素，并将其插入到已排序部分的合适位置，直到所有元素都被插入到已排序部分。

插入排序的过程可以用以下伪代码表示：

插入排序(arr):
    n = arr.length
    for i from 1 to n - 1:
        current = arr[i]
        j = i - 1
        while j >= 0 and arr[j] > current:
            arr[j + 1] = arr[j]
            j = j - 1
        arr[j + 1] = current

在每一轮外层循环中，从未排序部分选择一个元素，记为 current。然后，通过内层循环从已排序部分的末尾开始向前遍历，将比 current 大的元素向后移动一个位置，为 current 找到合适的插入位置。

内层循环会一直进行，直到找到 current 的正确插入位置或者已经遍历到已排序部分的开头。

最后，将 current 插入到正确的位置上，即 j + 1 的位置，这样已排序部分的长度增加了一。

重复执行以上步骤，每次选择并插入一个元素，直到所有元素都被插入到已排序部分。

插入排序的时间复杂度为 O(n^2)，其中 n 是待排序序列的长度。它是一种稳定的排序算法，相等元素的相对位置在排序前后不会改变。

js代码实现：

function insertionSort(arr) {
  const len = arr.length;
  for (let i = 1; i < len; i++) {
    let current = arr[i];
    let j = i - 1;
    while (j >= 0 && arr[j] > current) {
      arr[j + 1] = arr[j];
      j--;
    }
    arr[j + 1] = current;
  }
  return arr;
}
  1. 希尔排序（Shell Sort）：
    希尔排序（Shell Sort），也称为缩小增量排序，是插入排序的一种改进算法。它通过将数组分割成多个子序列来进行排序，并逐步缩小子序列的间隔，最终将整个数组变为有序。

希尔排序的逻辑和原理如下：

  1. 首先，选择一个增量（间隔）序列，通常是按照一定规则确定的，比如初始增量为数组长度的一半，并逐步缩小增量。

  2. 根据选定的增量，将数组划分为多个子序列，每个子序列包含相隔增量个位置的元素。

  3. 对每个子序列应用插入排序，使得每个子序列都变得部分有序。

  4. 缩小增量，重复步骤 2 和步骤 3，直到最后增量为 1，此时进行最后一次插入排序，将整个数组排序。

希尔排序的过程可以用以下伪代码表示：

希尔排序(arr):
    n = arr.length
    增量 = n / 2
    while 增量 > 0:
        for i from 增量 to n - 1:
            temp = arr[i]
            j = i
            while j >= 增量 and arr[j - 增量] > temp:
                arr[j] = arr[j - 增量]
                j = j - 增量
            arr[j] = temp
        增量 = 增量 / 2

在每一轮外层循环中，通过增量将数组划分为多个子序列，然后对每个子序列应用插入排序。内层循环使用插入排序算法，逐个将未排序部分的元素插入到已排序部分的正确位置上。

重复执行以上步骤，不断缩小增量直到增量为 1，最后进行一次完整的插入排序，将整个数组排序。

希尔排序的时间复杂度取决于增量序列的选择，但最坏情况下为 O(n^2)，其中 n 是待排序序列的长度。希尔排序是一种不稳定的排序算法，相等元素的相对位置在排序前后可能会改变。

js代码实现：

function shellSort(arr) {
  const len = arr.length;
  let gap = Math.floor(len / 2);
  while (gap > 0) {
    for (let i = gap; i < len; i++) {
      let current = arr[i];
      let j = i - gap;
      while (j >= 0 && arr[j] > current) {
        arr[j + gap] = arr[j];
        j -= gap;
      }
      arr[j + gap] = current;
    }
    gap = Math.floor(gap / 2);
  }
  return arr;
}
  1. 归并排序（Merge Sort）：
    归并排序（Merge Sort）是一种基于分治法的排序算法，其核心思想是将待排序的序列不断拆分为较小的子序列，然后将这些子序列逐步合并为有序序列，最终得到完全有序的序列。

归并排序的逻辑和原理如下：

  1. 首先，将待排序的序列均匀地分割为两个子序列，直到每个子序列只剩一个元素（认为单个元素已经是有序的）。

  2. 逐步将相邻的子序列进行合并，合并时比较两个子序列的首个元素，将较小（或较大）的元素放入临时数组中。

  3. 继续合并较小的子序列，直到所有的子序列合并为一个完整的有序序列。

归并排序的过程可以用以下伪代码表示：

归并排序(arr):
    if arr.length <= 1:
        return arr
    middle = arr.length / 2
    left = 归并排序(arr[0:middle])
    right = 归并排序(arr[middle:])
    return 合并(left, right)

合并(left, right):
    result = []
    while left.length > 0 and right.length > 0:
        if left[0] <= right[0]:
            result.append(left[0])
            left = left[1:]
        else:
            result.append(right[0])
            right = right[1:]
    if left.length > 0:
        result.append(left)
    if right.length > 0:
        result.append(right)
    return result

在归并排序中，首先将待排序的序列不断拆分为两个子序列，然后分别对这两个子序列进行递归地归并排序。

在合并操作中，通过比较两个子序列的首个元素，将较小（或较大）的元素放入结果数组中，并将相应子序列的索引后移。当一个子序列的所有元素都被放入结果数组后，将另一个子序列中剩余的元素直接追加到结果数组中。

重复执行以上步骤，直到所有子序列合并为一个完整的有序序列。

归并排序的时间复杂度为 O(nlogn)，其中 n 是待排序序列的长度。归并排序是一种稳定的排序算法，相等元素的相对位置在排序前后不会改变。

js代码实现：

function mergeSort(arr) {
  if (arr.length <= 1) {
    return arr;
  }
  const mid = Math.floor(arr.length / 2);
  const left = mergeSort(arr.slice(0, mid));
  const right = mergeSort(arr.slice(mid));
  return merge(left, right);
}

function merge(left, right) {
  const merged = [];
  let i = 0,
    j = 0;
  while (i < left.length && j < right.length) {
    if (left[i] <= right[j]) {
      merged.push(left[i]);
      i++;
    } else {
      merged.push(right[j]);
      j++;
    }
  }
  while (i < left.length) {
    merged.push(left[i]);
    i++;
  }
  while (j < right.length) {
    merged.push(right[j]);
    j++;
  }
  return merged;
}

6.快速排序（Quick Sort）：
js代码实现：

function quickSort(arr) {
  if (arr.length <= 1) {
    return arr;
  }
  const pivot = arr[Math.floor(arr.length / 2)];
  const left = [];
  const right = [];
  for (let i = 0; i < arr.length; i++) {
    if (i === Math.floor(arr.length / 2)) {
      continue;
    }
    if (arr[i] < pivot) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }
  return [...quickSort(left), pivot, ...quickSort(right)];
}
  1. 堆排序（Heap Sort）：
    快速排序（Quick Sort）是一种常用的排序算法，它使用分治法来对待排序的序列进行排序。快速排序的核心思想是选择一个基准元素，将序列中小于基准的元素放在基准的左边，大于基准的元素放在基准的右边，然后对左右两个子序列分别进行递归排序，最终完成整个序列的排序。

快速排序的逻辑和原理如下：

  1. 选择一个基准元素，通常是待排序序列的第一个元素或者随机选择一个元素。

  2. 将序列中小于基准的元素放在基准的左边，大于基准的元素放在基准的右边，使得基准元素所在的位置最终确定。

  3. 对基准元素左边的子序列和右边的子序列分别进行递归快速排序。

  4. 重复以上步骤，直到每个子序列只剩下一个元素，此时整个序列排序完成。

快速排序的过程可以用以下伪代码表示：

快速排序(arr, left, right):
    if left < right:
        pivotIndex = 分区(arr, left, right)
        快速排序(arr, left, pivotIndex - 1)
        快速排序(arr, pivotIndex + 1, right)

分区(arr, left, right):
    pivot = arr[left]  // 选择第一个元素作为基准
    i = left + 1
    j = right
    while True:
        while i <= j and arr[i] < pivot:
            i = i + 1
        while i <= j and arr[j] > pivot:
            j = j - 1
        if i > j:
            break
        交换 arr[i] 和 arr[j] 的位置
    交换 arr[left] 和 arr[j] 的位置
    return j

在快速排序中，首先选择一个基准元素，然后通过分区操作将小于基准的元素放在基准的左边，大于基准的元素放在基准的右边。

分区操作使用两个指针 i 和 j 分别从左边和右边向中间移动，寻找需要交换的元素对。当找到需要交换的元素对时，交换它们的位置。

重复进行分区操作，直到左右指针相遇，此时基准元素所在的位置确定。然后对基准元素左边的子序列和右边的子序列分别进行递归快速排序，最终完成整个序列的排序。

快速排序的时间复杂度取决于划分的平衡性，平均情况下为 O(nlogn)，最坏情况下为 O(n^2)，其中 n 是待排序序列的长度。快速排序是一

种不稳定的排序算法，相等元素的相对位置在排序前后可能会改变。

js代码实现：

function heapSort(arr) {
  const len = arr.length;
  // 构建最大堆
  for (let i = Math.floor(len / 2) - 1; i >= 0; i--) {
    heapify(arr, len, i);
  }
  // 依次取出堆顶元素，并调整堆
  for (let i = len - 1; i > 0; i--) {
    [arr[0], arr[i]] = [arr[i], arr[0]]; // 将堆顶元素与末尾元素交换
    heapify(arr, i, 0);
  }
  return arr;
}

function heapify(arr, len, i) {
  let largest = i;
  const left = 2 * i + 1;
  const right = 2 * i + 2;
  if (left < len && arr[left] > arr[largest]) {
    largest = left;
  }
  if (right < len && arr[right] > arr[largest]) {
    largest = right;
  }
  if (largest !== i) {
    [arr[i], arr[largest]] = [arr[largest], arr[i]]; // 交换位置
    heapify(arr, len, largest);
  }
}
  1. 计数排序（Counting Sort）：
    计数排序（Counting Sort）是一种线性时间复杂度的排序算法，适用于待排序序列的取值范围较小且已知的情况。计数排序的核心思想是统计每个元素出现的次数，然后根据统计信息将元素放回到正确的位置上，从而实现排序。

计数排序的逻辑和原理如下：

  1. 首先，统计待排序序列中每个元素的出现次数，并将统计结果存储在一个辅助数组中。

  2. 根据统计结果，计算每个元素在排序后的序列中的位置信息。位置信息可以通过累加前面元素的出现次数得到。

  3. 创建一个与待排序序列长度相同的结果数组，用于存储排序后的序列。

  4. 遍历待排序序列，根据统计结果将每个元素放入结果数组的正确位置上。

计数排序的过程可以用以下伪代码表示：

计数排序(arr):
    n = arr.length
    maxVal = 找出序列中的最大值
    count = new Array(maxVal + 1)
    result = new Array(n)
    
    // 统计每个元素的出现次数
    for i from 0 to n - 1:
        count[arr[i]] = count[arr[i]] + 1
    
    // 计算每个元素在排序后序列中的位置信息
    for i from 1 to maxVal:
        count[i] = count[i] + count[i - 1]
    
    // 将元素放回到正确的位置上
    for i from n - 1 to 0:
        result[count[arr[i]] - 1] = arr[i]
        count[arr[i]] = count[arr[i]] - 1
    
    return result

在计数排序中，首先找出待排序序列中的最大值 maxVal，根据 maxVal 创建一个辅助数组 count，用于统计每个元素的出现次数。

接下来，通过遍历 count 数组，累加前面元素的出现次数，计算每个元素在排序后序列中的位置信息。

然后，创建一个与待排序序列长度相同的结果数组 result，用于存储排序后的序列。

最后，从待排序序列的末尾开始遍历，根据统计结果将每个元素放入结果数组的正确位置上，并更新统计数组的计数信息。

计数排序的时间复杂度为 O(n+k)，其中 n 是待排序序列的长度，k 是序列中元素的取值范围。计数排序是一种稳定的排序算法，相等元素的相对位置在排序前后不会改变。但需要注意，计数排序对于取值范围较大的情况，会占用较大的内存空间。

js代码实现：

function countingSort(arr) {
  const len = arr.length;
  if (len <= 1) {
    return arr;
  }
  const max = Math.max(...arr);
  const countArr = new Array(max + 1).fill(0);
  const sortedArr = [];
  for (let i = 0; i < len; i++) {
    countArr[arr[i]]++;
  }
  for (let i = 0; i < countArr.length; i++) {
    while (countArr[i] > 0) {
      sortedArr.push(i);
      countArr[i]--;
    }
  }
  return sortedArr;
}

这些示例代码展示了如何使用 JavaScript 实现八大排序算法。你可以使用这些代码进行测试和验证，并观察排序算法的执行过程。

补充:

  1. 插入排序的时间复杂度是O(n2),所以不仅仅对小规模数据效率高,对于接近有序的大规模数据也有较高效率,因为插入元素所需移动的次数少。
  2. 希尔排序的时间复杂度是O(nlogn),实际效率可能高于简单插入排序,需要选择一个合适的增量序列才能发挥出高效率,增量序列的选择比较关键。
  3. 归并排序的空间复杂度是O(n),需要额外空间的同时也产生了额外的数组拷贝操作,实际效率略低于表格所说的“效率较高”。
  4. 快速排序的时间复杂度是O(nlogn),但是选择枢轴的不恰当可能导致极端时间复杂度变为O(n2),所以对近乎有序的数据效率就会变低,这一点与表格描述的“对于已基本有序的数据,效率较低”有些差异。
  5. 堆排序更准确的空间复杂度应该是O(1),因为除了排序使用的堆结构外不需要其他额外空间,所以不需要像表格所说的“需要额外的空间”。
  6. 计数排序的时间复杂度和空间复杂度均为O(n+k),k为数据值域大小,所以更准确的描述应该是“当k为O(n)时,时间和空间复杂度均为O(n)”。

图解链接

排序过程图解

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/628395.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【技术分享】华为防火墙双机热备

【技术分享】华为防火墙双机热备

组网需求 如图所示&#xff0c;两台FW旁挂在数据中心的核心交换机侧&#xff0c;保证数据中心网络安全。通过核心交换机的流量都会被引流到旁挂的FW上进行安全检测&#xff0c;引流的方式为静态路由方式。企业希望两台FW以主备备份方式工作。正常情况下&#xff0c;流量通过FW_…
阅读更多...
android 如何分析应用的内存（五）

android 如何分析应用的内存（五）

android 如何分析应用的内存&#xff08;五&#xff09; 接上文 lldb的工具篇的GUI部分。分成两部分&#xff1a; vscode 的LLDBas的LLDB 接下来是as的LLDB as的LLDB 为了进行LLDB的调试&#xff0c;需要对as进行配置&#xff0c;事实上&#xff0c;每一个在AS中编辑的应…
阅读更多...
充电桩检测仪表TK4860E交流充电桩检定装置

充电桩检测仪表TK4860E交流充电桩检定装置

波形失真度测量&#xff1a;具备电压电流波形失真度测量功能。 时钟校验功能&#xff1a;实时时钟显示&#xff0c;可完成充电桩的时钟时刻误差测试。 温湿度测量&#xff08;选配件&#xff09;&#xff1a;可选配蓝牙温湿度计&#xff0c;通过蓝牙连接平板电脑&#xff0c;…
阅读更多...
properties、yaml作为配置文件的特点

properties、yaml作为配置文件的特点

说明&#xff1a;在软件开发中&#xff0c;经常需要把一些配置写在文件中&#xff0c;如数据库配置、MyBatis配置等。这样&#xff0c;后续如果数据库参数有改动&#xff0c;就可以避免直接对代码做修改&#xff0c;只要修改配置文件中关于数据库的配置。关于配置文件的选择&am…
阅读更多...
数据分析师，如何写好分析报告来体现数据价值

数据分析师，如何写好分析报告来体现数据价值

对数据敏感 数据分析&#xff0c;从名字中就能看出来&#xff0c;数据是数据分析师实际工作中的核心。 对数据敏感是对数据分析师的要求&#xff0c;也是数据分析师在日常工作中培养出来的独特技能&#xff0c;相对于其他岗位的员工&#xff0c;他们会更容易眼发现数据信息中…
阅读更多...
SPC Control Chart Tools for .Net Crack

SPC Control Chart Tools for .Net Crack

.Net 的 SPC 控制图工具 版本 3.1 具有集成表格支持、频率直方图、Cpk 和 Ppk 统计和缩放功能的 X-Bar R Chart 添加变量控制图&#xff08;X-Bar R、X-Bar Sigma、Individual Range、Median Range、EWMA、MA、MAMR、MAMS 和 CuSum 图&#xff09;、属性控制图&#xff08;p-…
阅读更多...
【第三章：链路层】

【第三章：链路层】

目录 知识框架No.0 引言No.1 功能零、基本功能概念一、封装成帧1、字符计数法2、字符填充法3、零比特填充法4、违规编码法 二、透明传输三、差错控制1、位错1.1、奇偶校验码1.2、循环冗余码CRC2、帧错2.1、海明码 四、流量控制1、停止-等待协议2、滑动窗口协议2.1、后退N帧协议…
阅读更多...
Mybatis 学习笔记总结

Mybatis 学习笔记总结

1.概念 2.开发环境搭建 2.1 开发环境 2.2 创建Maven工程 <!--junit测试--><dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.11</version> <scope>test</scope>&l…
阅读更多...
【P56】JMeter 响应时间图（Response Time Graph）

【P56】JMeter 响应时间图（Response Time Graph）

文章目录 一、响应时间图&#xff08;Response Time Graph&#xff09;参数说明二、准备工作三、测试计划设计 一、响应时间图&#xff08;Response Time Graph&#xff09;参数说明 可以以图形的方式查看和分析各事务和取样器的响应时间 使用场景&#xff1a;用于评估测试结…
阅读更多...
ASEMI代理英飞凌TLE4250-2G汽车级线性稳压器

ASEMI代理英飞凌TLE4250-2G汽车级线性稳压器

编辑-Z TLE4250-2G参数描述&#xff1a; 型号&#xff1a;TLE4250-2G 输入电压VI&#xff1a;45V 输出电压VQ&#xff1a;40V 结点温度Tj&#xff1a;-40~ 150℃ 储存温度Tstg&#xff1a;-50~150℃ 输出电容器要求CQ&#xff1a;1F 连接到焊接点RthJSP&#xff1a;30K…
阅读更多...
简单使用feign

简单使用feign

feign是一款非常好用的&#xff0c;能直接把我们省去端口号的编写&#xff0c; 下面直接开始&#xff0c;需要有一定的SpringCloud的基础&#xff0c;不然可能看不明白&#xff0c;我这里很多都是关键步骤。敬请原谅。 首先我们需要引入feign的依赖 <!-- 引入openfiegn-->…
阅读更多...
开发技术-使用 JDB 调试

开发技术-使用 JDB 调试

Java 调试器&#xff08;JDB&#xff09;是 JDK 内置的命令行工具。从调试的指令和命令行接口两方面看的话&#xff0c;JDB 至少从概念上是 GNU 调试器&#xff08;GDB&#xff0c;受 Unix DB 的影响&#xff09;的继承者。 示例&#xff1a; public class SimpleDebugging {p…
阅读更多...
C++ String类（上篇）

C++ String类（上篇）

绪论 放弃时间的人&#xff0c;时间也会放弃他。——莎士比亚 &#xff1b; 本篇章是关于string类内一些函数的介绍以及使用方法&#xff0c;都是我们编程必须掌握的基础&#xff01; ​ 全文共7000字左右. 话不多说安全带系好&#xff0c;发车啦&#xff08;建议电脑观看&…
阅读更多...
点亮创意灯，用Firefly Beta绘制生动有趣的成语故事！

点亮创意灯，用Firefly Beta绘制生动有趣的成语故事！

1、打开链接&#xff1a; Adobe Firefly 2、点击generate按钮。 3、输入需要生成的成语描述&#xff0c;英文的。 比如我们要画守株待兔&#xff1a; An ancient Chinese farmer, lying under a big tree, waiting for a rabbit to run over 4、点击fresh按钮。 5、下载其…
阅读更多...
（MIT6.045）自动机、可计算性和复杂性-图灵机

（MIT6.045）自动机、可计算性和复杂性-图灵机

有穷自动机(FA)对有限存储量设备是比较好的模型&#xff0c;下推自动机对无限存储设备是较好的模型&#xff08;但是其存储只能用后进先出的栈模式来使用。&#xff09;这两个模型过于局限&#xff0c;不能作为通用模型。 图灵机 和FA相似&#xff0c;但是图灵机有无限的存储…
阅读更多...
中央商务区对区域空间结构的影响机制

中央商务区对区域空间结构的影响机制

中央商务区&#xff08;CBD&#xff09;是经济发展到一定阶段后的必然产物&#xff0c;它已经成为城市或国家最重要的经济增长驱动器。中央商务区的形成过程本身即是区域空间结构的变化过程&#xff0c;经济活动在空间上的集聚与分散形成各类产业的集聚体&#xff0c;区域经济活…
阅读更多...
ROS学习——通信机制（话题通信①—发布方实现）

ROS学习——通信机制（话题通信①—发布方实现）

2.1 话题通信 Autolabor-ROS机器人入门课程《ROS理论与实践》零基础教程 040话题通信(C)1_发布方框架_Chapter2-ROS通信机制_哔哩哔哩_bilibili 一、ROS 中的基本通信机制主要有如下三种实现策略 话题通信(发布订阅模式服务通信(请求响应模式)参数服务器(参数共享模式) 二、…
阅读更多...
引领618首波爆发！实在RPA数字员工与海尔等品牌共赢全域增量

引领618首波爆发！实在RPA数字员工与海尔等品牌共赢全域增量

作为全面放开之后的首个现象级电商大促&#xff0c;今年618的重要性不言而喻。如何在“毛遂自荐”的大促秀场中&#xff0c;满足甚至超过消费者购物需求&#xff0c;成为每个品牌商家的必修课。 疫情的催化和直播间强互动属性&#xff0c;越来越多消费者倾向直播购物&#xff0…
阅读更多...
在通讯方面对讲机比微信更有优势吗？

在通讯方面对讲机比微信更有优势吗？

对讲机和微信属于不同的通信工具&#xff0c;它们在某些方面都有着各自的优势。那么在通讯方面对讲机比微信更有优势吗&#xff1f;下面河南宝蓝小编为大家详细介绍下。 一、即时与实时通信&#xff1a; 对讲机作为一种即时通信工具&#xff0c;能够立即与其他用户进行实时语…
阅读更多...
vue项目中el-upload 组件添加token的方法

vue项目中el-upload 组件添加token的方法

在使用el-upload的时候&#xff0c;上传文件到服务器&#xff0c;有时候后台要求上传token&#xff0c;怎么处理呢&#xff1f;以下是一个示例。 效果图 template中片段 <el-dialog :modal-append-to-body"false" title"上传文件" :visible.sync"…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023