七大排序 (9000字详解直接插入排序，希尔排序，选择排序，堆排序，冒泡排序，快速排序，归并排序）

news2025/7/18 22:05:09

一：排序的概念及引入

1.1 排序的概念

1.1 排序的概念

  • 排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。

  • 稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。

在这里插入图片描述

  • 内部排序：数据元素全部放在内存中的排序。
  • 外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

在这里插入图片描述
在这里插入图片描述

1.2常见的排序算法

常见的排序算法有七种，分别是直接插入排序，希尔排序，选择排序，堆排序，冒泡排序，快速排序，归并排序
在这里插入图片描述
下面我们对这些排序进行一 一讲解。

二：插入排序

2.1 直接插入排序

直接插入排序是一种简单的插入排序法，其基本思想是：

把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。实际中我们玩扑克牌时，就用了插入排序的思想。

在这里插入图片描述
插入排序是一种简单直观的排序算法。它的原理是将待排序的元素逐个插入到已排序序列的适当位置，从而形成一个有序序列。

该算法的工作原理如下：

  1. 从第二个元素开始，将其与前面已排序的元素逐个比较，找到合适的位置插入。
  2. 将当前元素与前面已排序的元素进行比较，如果当前元素小于前面的元素，则将前面的元素后移一位，直到找到合适的位置。
  3. 插入当前元素到合适的位置后，继续比较并插入下一个元素。
  4. 重复上述步骤，直到所有元素都被插入到合适的位置。

动图如下：

在这里插入图片描述

下面是一个使用Java实现插入排序的示例代码：

public class InsertionSort {
    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; // 已经排好序的元素的最后一个索引

            // 将比 key 大的元素向后移动
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j]; // 向后移动元素
                j--; // 向前遍历已经排好序的元素
            }

            // 插入 key 到合适的位置
            arr[j + 1] = key; // 将 key 插入到正确的位置
        }
    }

    public static void main(String[] args) {
        int[] arr = {5, 2, 8, 9, 1, 3};
        insertionSort(arr); // 使用插入排序算法对数组进行排序

        System.out.println("排序后的数组：");
        for (int num : arr) {
            System.out.print(num + " "); // 输出排序后的数组
        }
    }
}

直接插入排序的特性总结：

  1. 元素集合越接近有序，直接插入排序算法的时间效率越高
  2. 时间复杂度：O(N^2)
  3. 空间复杂度：O(1)，它是一种稳定的排序算法
  4. 稳定性：稳定

2.2 希尔排序( 缩小增量排序 )

希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成多个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。

下面是希尔排序的工作原理：

  1. 选择一个增量序列，增量序列由一系列整数构成，通常是递减的，最后一个增量必须为1。
  2. 根据选定的增量序列，将待排序的数组分割成若干个子数组，每个子数组包含相同间隔的元素。
  3. 对每个子数组进行插入排序，即将每个子数组的元素依次与该子数组中的其他元素进行比较和交换，使得子数组中的元素逐渐有序。
  4. 重复以上步骤，缩小增量，直至增量为1。
  5. 最后进行一次完整的插入排序，以保证数组的最终有序性。

示图如下：
在这里插入图片描述

希尔排序的特性总结：

  1. 希尔排序是对直接插入排序的优化。
  2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很
    快。这样整体而言，可以达到优化的效果。
  3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的希尔排
    序的时间复杂度都不固定

动图如下：
在这里插入图片描述

因为咋们的gap是按照Knuth提出的方式取值的，而且Knuth进行了大量的试验统计，我们暂时就按照：O（n1.25）到O（1.6 * n1.25） 来算。

下面是一个使用Java实现的希尔排序示例代码：

public class ShellSort {
    public static void shellSort(int[] arr) {
        int n = arr.length;
        
        // 初始化增量为数组长度的一半
        int gap = n / 2;
        
        while (gap > 0) {
            for (int i = gap; i < n; i++) {
                int temp = arr[i];
                int j = i;
                
                // 插入排序
                while (j >= gap && arr[j - gap] > temp) {
                    arr[j] = arr[j - gap];
                    j -= gap;
                }
                
                arr[j] = temp;
            }
            
            // 缩小增量
            gap /= 2;
        }
    }
    
    public static void main(String[] args) {
        int[] arr = {9, 5, 2, 7, 1, 3, 6, 8, 4};
        
        System.out.println("原始数组：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();
        
        shellSort(arr);
        
        System.out.println("排序后的数组：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

希尔排序稳定性：不稳定

三：选择排序

3.1直接选择排序

当我们需要对一个数组进行排序时，选择排序是一种简单而直观的算法。它的工作原理是选择数组中最小的元素，将它与数组的第一个元素交换位置。然后，选择剩余元素中最小的元素，将它与数组的第二个元素交换位置。以此类推，直到整个数组排序完成

动图如下：
在这里插入图片描述

public class SelectionSort {
    public static void main(String[] args) {
        // 创建一个整数数组
        int[] arr = {64, 25, 12, 22, 11};
        
        // 调用选择排序方法
        selectionSort(arr);
        
        // 输出排序后的数组
        System.out.println("排序后的数组：");
        for(int i=0; i < arr.length; i++){
            System.out.print(arr[i] + " ");
        }
    }

    public static void selectionSort(int[] arr) {
        // 获取数组长度
        int n = arr.length;
        
        // 遍历整个数组
        for (int i = 0; i < n-1; i++) {
            // 假设当前索引为 i 的元素是最小值
            int minIndex = i;
            
            // 在剩余的元素中寻找最小值的索引
            for (int j = i+1; j < n; j++) {
                // 如果找到比当前最小值还小的值，则更新最小值的索引
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            
            // 将最小值与当前位置交换
            int temp = arr[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = temp;
        }
    }
}

【直接选择排序的特性总结】

  1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
  2. 时间复杂度：O(N^2)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定

3.2堆排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。

在这里插入图片描述
堆排序具体的讲解可以查看这篇文章

【堆排序的特性总结】

  1. 堆排序使用堆来选数，效率就高了很多。
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定

四：交换排序

4.1冒泡排序

冒泡排序是一种简单但效率较低的排序算法。它的基本思想是通过不断比较相邻的两个元素并交换位置，从而将较大（或较小）的元素逐渐“冒泡”到数组的顶部（或底部）。这个过程会不断重复，直到数组中的所有元素都按照顺序排列。

下面是一个详细注释的 Java 示例代码：

public class BubbleSort {
    public static void bubbleSort(int[] arr) {
        int n = arr.length;

        // 外层循环控制比较的轮数，每轮比较后，最大的元素就会被冒泡到数组末尾
        for (int i = 0; i < n - 1; i++) {
            // 内层循环用于比较相邻的元素并交换位置
            // 每轮结束后，当前轮数已经排序完成的元素就会排在数组的最后
            // 所以下一轮比较时，不需要再考虑这些元素
            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;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};

        System.out.println("原始数组：");
        for (int num : arr) {
            System.out.print(num + " ");
        }

        // 调用冒泡排序
        bubbleSort(arr);

        System.out.println("\n排序后的数组：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

动图如下：
在这里插入图片描述
【冒泡排序的特性总结】

  1. 冒泡排序是一种非常容易理解的排序
  2. 时间复杂度：O(N^2)
  3. 空间复杂度：O(1)
  4. 稳定性：稳定

4.2快速排序

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

4.2.1Hoare版

实现思路：
1: 首先，从数组的左端和右端分别设置一个指针，即i和j，以及选择一个基准值pivot。

2:通过循环，从数组的右端开始向左查找，找到第一个小于基准值的元素的下标，将该下标赋给j。然后从数组的左端开始向右查找，找到第一个大于基准值的元素的下标，将该下标赋给i。

3: 在找到两个元素的下标后，交换它们的位置，将小于基准值的元素移动到基准值的左边，大于基准值的元素移动到基准值的右边。然后继续循环，直到左指针i大于等于右指针j。

最后，将基准值放在正确的位置上，将其与左指针i所指向的元素进行交换。这样，基准值左边的元素都小于基准值，右边的元素都大于基准值。

需要注意的是：若选择最左边的数据作为key，则需要right先走；若选择最右边的数据作为key，则需要left先走

动图如下：
在这里插入图片描述

private static int partition(int[] array, int left, int right) {
  // 设置左右指针和基准值
  int i = left;
  int j = right;
  int pivot = array[left];
  
  // 在左指针小于右指针的条件下，进行循环
  while (i < j) {
    // 从右往左找到第一个小于基准值的元素的下标
    while (i < j && array[j] >= pivot) {
      j--;
   }
  
    // 从左往右找到第一个大于基准值的元素的下标
    while (i < j && array[i] <= pivot) {
      i++;
   }
  
    // 交换找到的两个元素的位置
    swap(array, i, j);
 }
  
  // 将基准值放在正确的位置上
  swap(array, i, left);
  
  // 返回基准值的下标
  return i;
}

4.2.2挖坑法

实现思路：
1: 首先，在函数内部定义两个指针i和j，分别指向分区的左侧和右侧。初始时，将left作为基准元素的索引，即基准元素为array[left]。
2: 然后，通过循环，不断将大于基准元素的元素移动到右侧，将小于基准元素的元素移动到左侧。具体的操作是，先从右侧开始，找到小于或等于基准元素的元素，然后将该元素移动到左侧指针i的位置。
3: 接着，从左侧开始，找到大于或等于基准元素的元素，然后将该元素移动到右侧指针j的位置。如此反复进行，直到指针i和j相遇。
4: 最后，将基准元素放置到它最终的位置上，也就是指针i的位置。这样，基准元素左侧的元素都小于或等于它，右侧的元素都大于或等于它。
5: 最后返回基准元素的索引i，用于后续的分区。

注意：若在最左边挖坑，则需要R先走；若在最右边挖坑，则需要L先走

动图如下：
在这里插入图片描述

private static int partition(int[] array, int left, int right) {
    // 设置指针i和j分别指向分区的左侧和右侧
    int i = left;
    int j = right;
    // 设置基准元素为分区的第一个元素
    int pivot = array[left];
    
    // 开始循环，直到指针i和j相遇
    while (i < j) {
        // 从右侧开始，寻找小于或等于基准元素的元素
        while (i < j && array[j] >= pivot) {
            j--;
        }
        // 找到后将该元素移动到左侧指针i的位置
        array[i] = array[j];
        
        // 从左侧开始，寻找大于或等于基准元素的元素
        while (i < j && array[i] <= pivot) {
            i++;
        }
        // 找到后将该元素移动到右侧指针j的位置
        array[j] = array[i];
    }
    
    // 将基准元素放置到它最终的位置上
    array[i] = pivot;
    
    // 返回基准元素的索引，用于后续的分区
    return i;
}

4.2.3前后指针

实现思路：

  1. 我们首先定义了两个变量 cur 和 prev，它们都指向数组的起始位置（cur = begin，prev = begin - 1）。
  2. 我们选择数组的最后一个元素作为基准元素，将其索引保存在变量 keyi 中。
  3. 然后我们开始遍历数组，从头到尾比较每个元素与基准元素的大小。
  4. 如果当前元素小于基准元素，并且 prev 不等于 cur，则将当前元素与 prev 指向的元素交换位置。
  5. 随后，我们将 cur 向后移动一位。
  6. 当遍历完整个数组后，我们将基准元素与 prev 指向的元素交换位置，以确保基准元素的位置在整个数组中是正确的。
  7. 这样，数组被分成了两部分：左边是小于基准元素的部分，右边是大于基准元素的部分。基准元素的位置为 keyi。
  8. 接下来，我们对左半部分（begin 到 keyi - 1）和右半部分（keyi + 1 到 end）分别进行递归调用。
  9. 重复以上步骤，直到子数组的长度为 1 或 0，即递归终止条件。
//快速排序法  前后指针版本
void QuickSort2(int* arr, int begin, int end)
{
	if (begin >= end)
		return;
	int cur = begin, prev = begin - 1;
	int keyi = end;
	while (cur != keyi)
	{
		if (arr[cur] < arr[keyi] && ++prev != cur)
		{
			swap(&arr[cur], &arr[prev]);
		}
		++cur;
	}
	swap(&arr[++prev],&arr[keyi]);
	keyi = prev;
	//[begin,keyi -1]keyi[keyi+1,end]
	QuickSort2(arr, begin, keyi - 1);
	QuickSort2(arr, keyi + 1, end);

}

快速排序优化

  1. 三数取中法选key （三个数中取中间的数为基准）
  2. 递归到小的子区间时，可以考虑使用插入排序

快速排序总结：

  1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(logN)（特殊情况，如果数据本身有序或者逆序，那么时间复杂度为 O （N2））
  4. 稳定性：不稳定

时间复杂度示图：
在这里插入图片描述

五：归并排序

5.1 基本思想

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 归并排序核心步骤：

在这里插入图片描述
动图：
在这里插入图片描述
归并排序总结：

  1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(N)
  4. 稳定性：稳定

5.2 代码实现

public class MergeSort {
    // 归并排序入口函数
    public int[] mergeSort(int[] array) {
        // 特殊情况处理：当数组为空或只有一个元素时，无需排序，直接返回
        if (array == null || array.length <= 1) {
            return array;
        }
        
        // 调用归并排序算法进行排序
        mergeSort(array, 0, array.length - 1);
        
        return array;
    }
    
    // 归并排序递归函数
    private void mergeSort(int[] array, int start, int end) {
        // 当前排序范围只有一个元素，无需继续拆分
        if (start >= end) {
            return;
        }
        
        // 找到当前排序范围的中间位置
        int mid = start + (end - start) / 2;
        
        // 递归拆分左半部分
        mergeSort(array, start, mid);
        // 递归拆分右半部分
        mergeSort(array, mid + 1, end);
        
        // 合并左右两部分排序结果
        merge(array, start, mid, end);
    }
    
    // 归并两个有序数组
    private void merge(int[] array, int start, int mid, int end) {
        // 创建一个临时数组保存合并的结果
        int[] temp = new int[end - start + 1];
        
        int i = start;  // 左半部分起始位置
        int j = mid + 1;  // 右半部分起始位置
        int k = 0;  // 临时数组的索引
        
        // 遍历左右两部分数组，依次取出较小的元素放入临时数组中
        while (i <= mid && j <= end) {
            if (array[i] < array[j]) {
                temp[k++] = array[i++];
            } else {
                temp[k++] = array[j++];
            }
        }
        
        // 处理剩余的元素
        while (i <= mid) {
            temp[k++] = array[i++];
        }
        
        while (j <= end) {
            temp[k++] = array[j++];
        }
        
        // 将临时数组中的元素拷贝回原数组中
        for (i = 0; i < temp.length; i++) {
            array[start + i] = temp[i];
        }
    }
}

下面对这段代码进行详细的讲解：

  1. 首先我们定义了一个公共类MergeSort，用于实现归并排序算法。
  2. mergeSort方法是入口函数，接收一个整型数组作为参数，并返回一个排序后的整型数组。在这个方法中，首先判断特殊情况，即当数组为空或只有一个元素时，无需排序，直接返回原数组；否则，调用归并排序算法进行排序。
  3. 归并排序的核心是递归拆分和合并两个有序数组。
  4. mergeSort方法是一个递归函数，接收一个整型数组array和两个整型变量start和end作为参数，表示当前排序范围的起始位置和结束位置。首先判断当前范围是否只有一个元素，如果是，则无需继续拆分；否则，找到当前范围的中间位置mid，分别递归拆分左半部分和右半部分，然后将拆分后的结果合并起来。
  5. merge方法用于合并两个有序数组。它接收一个整型数组array和三个整型变量start、mid和end作为参数，表示需要合并的两个有序数组在原数组中的位置。首先创建一个临时数组temp，用于保存合并的结果，长度为end-start+1。然后设置三个指针i、j和k，分别表示左半部分数组的起始位置、右半部分数组的起始位置和临时数组的索引。接下来，遍历左右两部分数组，依次取出较小的元素放入临时数组中，直到其中一个部分的元素取完。最后，如果左半部分数组还有剩余的元素，将其全部复制到临时数组中；如果右半部分数组还有剩余的元素，也将其全部复制到临时数组中。最后，将临时数组中的元素拷贝回原数组中，完成合并过程。

5.3海量数据的排序问题

外部排序：排序过程需要在磁盘等外部存储进行的排序
前提：内存只有 1G，需要排序的数据有 100G因为内存中因为无法把所有数据全部放下，所以需要外部排序，而归并排序是最常用的外部排序

  1. 先把文件切分成 200 份，每个 512 M
  2. 分别对 512 M 排序，因为内存已经可以放的下，所以任意排序方式都可以
  3. 进行 2路归并，同时对 200 份有序文件做归并过程，最终结果就有序了

六：排序总结

6.1排序算法复杂度及稳定性分析

在这里插入图片描述

6.2各个排序的比较

排序方法最好平均最坏空间复杂度稳定性
冒泡排序O(n)O(n2)O(n2 )O(1)稳定
插入排序O(n)O(n2)O(n2)O(1)稳定
选择排序O(n^2)O(n2)O(n2)O(1)不稳定
希尔排序O(n)O(n1.3)O(n2)O(1)不稳定
堆排序O(n*log n)O(n*log n)O(n*log n)O(1)不稳定
快速排序O(n*log n)O(n*log n)O(n2)O(log n)~O(n)不稳定
归并排序O(n*log n)O(n*log n)O(n*log n)O(n)稳定

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

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

相关文章

[Python中常用的回归模型算法大全2：从线性回归到XGBoost]

[Python中常用的回归模型算法大全2：从线性回归到XGBoost]

文章目录 概要多输出K近邻回归集成算法回归梯度提升决策树回归随机森林回归 概要 回归分析在数据科学领域扮演着关键角色&#xff0c;用于预测数值型目标变量。本文深入探讨了几种常用的回归模型&#xff0c;包括多输出K近邻回归&#xff0c;决策树回归&#xff0c;集成算法回…
阅读更多...
告别手动调节！iOS 17让你全自动调节音量大小，那么如何实现个性化音量呢

告别手动调节！iOS 17让你全自动调节音量大小，那么如何实现个性化音量呢

多亏了iOS 17&#xff0c;你的AirPods Pro 2现在具有个性化音量功能&#xff0c;可以根据周围环境智能调整音频音量。 这很酷&#xff0c;任何喜欢尽可能降低音量以避免听力受损的人都会对此表示赞赏。使用个性化音量&#xff0c;你的iPhone将检测音量何时可以降低&#xff0c…
阅读更多...
MyBatisPlus-02

MyBatisPlus-02

一 查询条件的三种 1.按条件查询 //方式一&#xff1a;按条件查询QueryWrapper qw new QueryWrapper();qw.lt("age",18);List<User> userList userDao.selectList(qw);System.out.println(userList); 2.lambda格式按条件查询 //方式二&#xff1a;lambda格…
阅读更多...
【前端学习】—函数节流（九）

【前端学习】—函数节流（九）

【前端学习】—函数节流&#xff08;九&#xff09; 一、什么是函数节流 函数节流&#xff1a;规定在一个单位时间内&#xff0c;事件响应函数只能被触发一次&#xff0c;如果这个单位时间内触发多次函数&#xff0c;只有一次生效。 二、函数节流使用场景 window.onresize事…
阅读更多...
pytorch代码实现之动态蛇形卷积模块DySnakeConv

pytorch代码实现之动态蛇形卷积模块DySnakeConv

动态蛇形卷积模块DySnakeConv 血管、道路等拓扑管状结构的精确分割在各个领域都至关重要&#xff0c;确保下游任务的准确性和效率。 然而&#xff0c;许多因素使任务变得复杂&#xff0c;包括薄的局部结构和可变的全局形态。在这项工作中&#xff0c;我们注意到管状结构的特殊…
阅读更多...
安达发|大多数离散型生产模式适用APS自动排程系统

安达发|大多数离散型生产模式适用APS自动排程系统

在离散型生产模式中&#xff0c;智能生产排程软件&#xff08;APS&#xff09;的应用越来越广泛。这是因为APS能够根据实时的生产需求和资源状况&#xff0c;自动进行生产计划的制定和调整&#xff0c;从而提高生产效率&#xff0c;降低生产成本&#xff0c;保证生产的顺利进行…
阅读更多...
美国股票和加密货币平台【Alpaca】完成1500万美元融资

美国股票和加密货币平台【Alpaca】完成1500万美元融资

来源&#xff1a;猛兽财经 作者&#xff1a;猛兽财经 猛兽财经获悉&#xff0c;总部位于美国加利福尼亚州圣马特奥的股票和加密交易经纪平台提供商&#xff0c;近期宣布已从SBI集团获得了1500万美元融资。 该公司打算利用这笔资金加快业务扩张&#xff0c;并将其业务范围扩大到…
阅读更多...
iPaaS混合集成平台，打造数字化生态

iPaaS混合集成平台，打造数字化生态

如今企业分工越来越细&#xff0c;上下游合作越来越紧密、各企业之间的业务系统需要相互协作完成业务、外部API依赖越来越多、同时企业系统运行在多个混合云环境及SaaS中&#xff0c;私有端大量业务系统与云端系统形成了错综复杂的集成关系&#xff0c;企业面临集成技术复杂多样…
阅读更多...
Springboot整合taos时序数据库TDengine

Springboot整合taos时序数据库TDengine

1.首先安装TDengine服务端在linux上 TDengine多种安装包的安装和卸载 - TDengine | 涛思数据安装过程直接去官网看，非常详细简单 2.出现的问题 windows连接 invalid app version 版本不对应 版本不对应的问题，需要在linux上安装的版本和windows client版本一致，不然w…
阅读更多...
Kubernetes基础(六)-常见 Kubernetes Pod 驱逐场景

Kubernetes基础(六)-常见 Kubernetes Pod 驱逐场景

Kubernetes Pod 被驱逐是什么意思&#xff1f; 它们被终止&#xff0c;通常是没有足够资源的结果。但是为什么会这样呢&#xff1f; 驱逐是指派给节点的Pod 被终止的过程。 Kubernetes 中最常见的情况之一是Preemption&#xff0c;为了在资源有限的节点中调度新的 Pod&#…
阅读更多...
安卓14通过“冻结”缓存应用程序腾出CPU，提高性能和内存效率

安卓14通过“冻结”缓存应用程序腾出CPU，提高性能和内存效率

本月早些时候&#xff0c;我们听说更新到安卓14似乎提高了谷歌Pixel 7和Pixel 6的效率——提高了电池寿命&#xff0c;并在这个过程中减少了热量的产生。现在看来&#xff0c;安卓14的增效功能细节已经公布。 安卓侦探Mishaal Rahman在X&#xff08;前身为Twitter&#xff09;…
阅读更多...
林沛满--快递员的工作策略——TCP窗口

林沛满--快递员的工作策略——TCP窗口

本文整理自&#xff1a;《Wireshark网络分析就这么简单 第1版》 作者&#xff1a;林沛满 著 出版时间&#xff1a;2014-12 假如你是一位勤劳的快递员&#xff0c;要送100个包裹到某公司去&#xff0c;怎样送货才科学? 最简单的方式是每次送1个&#xff0c;总共跑100趟。当然这…
阅读更多...
uCOSIII实时操作系统 八 软件定时器

uCOSIII实时操作系统 八 软件定时器

目录 软件定时器概述 使用步骤&#xff1a; 创建软件定时器&#xff1a; 启动软件定时器&#xff1a; 停止软件定时器&#xff1a; 删除软件定时器&#xff1a; 单次定时器&#xff1a; ​编辑周期定时器&#xff1a; 无初始化延时&#xff1a; 有初始化延时&#xff…
阅读更多...
LabVIEW中使用Get LV Class Default Value 出现错误1498

LabVIEW中使用Get LV Class Default Value 出现错误1498

LabVIEW中使用Get LV Class Default Value 出现错误1498 在LabVIEW中开发了一个应用程序&#xff0c;其中包含可以在执行时动态配置插件的基类。生成可执行文件后&#xff0c;当应用程序要执行子类时&#xff0c;收到以下错误信息。 Error1498 occurred at Gen LV Class Defa…
阅读更多...
Sandboxie+Buster Sandbox Analyzer打造个人沙箱

Sandboxie+Buster Sandbox Analyzer打造个人沙箱

一、运行环境和需要安装的软件 实验环境&#xff1a;win7_x32或win7_x64 用到的软件&#xff1a;WinPcap_4_1_3.exe、Sandboxie-3-70.exe、Buster Sandbox Analyzer 重点是Sandboxie必须是3.70版本。下载地址&#xff1a;https://github.com/sandboxie-plus/sandboxie-old/blo…
阅读更多...
Linux性能优化--使用性能工具发现问题

Linux性能优化--使用性能工具发现问题

9.0 概述 本章主要介绍综合运用之前提出的性能工具来缩小性能问题产生原因的范围。阅读本章后&#xff0c;你将能够&#xff1a; 启动行为异常的系统&#xff0c;使用Linux性能工具追踪行为异常的内核函数或应用程序。启动行为异常的应用程序&#xff0c;使用Linux性能工具追…
阅读更多...
浪子带你【25天】玩转Python——期中福利

浪子带你【25天】玩转Python——期中福利

人生苦短&#xff0c;我用Python! 目录 回顾上文 正文 最后的话 回顾上文 浪子带你【25天】玩转Python——5.面向对象编程&#xff08;类和对象&#xff09;-CSDN博客 正文 哈喽&#xff0c;不知不觉中&#xff0c;浪子的【25天】玩转Python已经开播13天啦&#xff01…
阅读更多...
【c++智能指针】

【c++智能指针】

目录 一、智能指针的使用及原理二、auto_ptr三、unique_ptr三、shared_ptr四、weak_ptr五、定制删除器 一、智能指针的使用及原理 RAII&#xff08;Resource Acquisition Is Initialization&#xff09;是一种利用对象生命周期来控制程序资源&#xff08;如内存、文件句柄、网…
阅读更多...
新型的终端复用器 tmux

新型的终端复用器 tmux

以前遇到长时间执行任务时&#xff0c;一般是使用nohup加后台运行&#xff0c;但是涉及到少量代码编写。 同事介绍了一个screen命令&#xff0c;根据文档&#xff0c;此命令已经过时&#xff0c;最新的命令是tmux。 tmux的介绍文档&#xff0c;RedHat的这一篇非常不错。 在文…
阅读更多...
vue ref和$refs获取dom元素

vue ref和$refs获取dom元素

vue ref和$refs获取dom元素 **创建 工程&#xff1a; H:\java_work\java_springboot\vue_study ctrl按住不放 右键 悬着 powershell H:\java_work\java_springboot\js_study\Vue2_3入门到实战-配套资料\01-随堂代码素材\day04\准备代码\14-ref和$refs获取dom对象 vue --ve…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023