数据结构-十大排序算法

数据结构十大排序算法

十大排序算法分别是直接插入排序、折半插入排序、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序、基数排序、外部排序。

其中插入排序包括直接插入排序、折半插入排序、希尔排序；交换排序包括冒泡排序、快速排序；选择排序包括简单选择排序、堆排序

1. 直接插入排序

直接插入排序（Insertion Sort）是一种简单的排序算法，它的基本思想是将待排序的元素逐个插入已经有序的部分序列中，从而得到一个有序的序列。

下面是直接插入排序的步骤：

  1. 假设要对一个数组进行升序排序，从第二个元素开始，将其作为当前元素。
  2. 将当前元素与已排序的部分序列进行比较，找到合适的位置插入当前元素。如果当前元素小于已排序部分的某个元素，就将这个元素后移一位，直到找到合适的位置。
  3. 将当前元素插入到合适的位置。
  4. 重复步骤 2 和步骤 3，直到所有元素都被插入到合适的位置。

以下是使用 C 实现的直接插入排序的示例代码：

void insertionSort(int arr[], int n) {int i, j, current;for (i = 1; i < n; i++) {current = arr[i];j = i - 1;while (j >= 0 && arr[j] > current) {arr[j + 1] = arr[j];j--;}arr[j + 1] = current;}
}

2.折半插入排序

折半插入排序（Binary Insertion Sort）是对直接插入排序算法的改进，通过利用二分查找的方式来寻找插入位置，减少了比较的次数，从而提高了排序的效率。

下面是折半插入排序的步骤：

  1. 假设要对一个数组进行升序排序，从第二个元素开始，将其作为当前元素。
  2. 将当前元素与已排序的部分序列的中间元素进行比较，确定插入位置的范围。
  3. 使用二分查找在确定的范围内找到合适的位置插入当前元素。
  4. 将当前元素插入到合适的位置。
  5. 重复步骤 2 到步骤 4，直到所有元素都被插入到合适的位置。

以下是使用 C 语言实现折半插入排序的示例代码：

void binaryInsertionSort(int arr[], int n) {int i, j, current, low, high, mid;for (i = 1; i < n; i++) {current = arr[i];low = 0;high = i - 1;// 使用二分查找确定插入位置的范围while (low <= high) {mid = (low + high) / 2;if (arr[mid] > current)high = mid - 1;elselow = mid + 1;}// 插入当前元素到合适的位置for (j = i - 1; j >= low; j--) {arr[j + 1] = arr[j];}arr[low] = current;}
}

3.希尔排序

希尔排序（Shell Sort）是一种改进的插入排序算法，它通过比较和交换相隔一定间隔的元素，逐步减小间隔，最终使整个序列达到有序状态。

下面是希尔排序的步骤：

  1. 首先选择一个间隔序列（增量序列），通常使用 Knuth 序列或者 Hibbard 序列。这些序列中的元素逐步减小，最后一个元素为 1。
  2. 对于每个间隔，将数组分为多个子序列，分别对这些子序列进行插入排序。
  3. 逐步减小间隔，重复步骤 2，直到间隔为 1。
  4. 最后进行一次间隔为 1 的插入排序，完成整个排序过程。

以下是使用 C 语言实现希尔排序的示例代码：

#include <stdio.h>void shellSort(int arr[], int n) {int gap, i, j, temp;// 使用 Knuth 序列计算初始间隔gap = 1;while (gap < n / 3) {gap = gap * 3 + 1;}while (gap > 0) {for (i = gap; i < n; i++) {temp = arr[i];j = i;while (j > gap - 1 && arr[j - gap] > temp) {arr[j] = arr[j - gap];j -= gap;}arr[j] = temp;}// 缩小间隔gap = (gap - 1) / 3;}
}// 示例用法
int main() {int arr[] = {5, 2, 8, 1, 3};int n = sizeof(arr) / sizeof(arr[0]);shellSort(arr, n);printf("Sorted array: ");for (int i = 0; i < n; i++) {printf("%d ", arr[i]);}printf("\n");return 0;
}

4.冒泡排序

冒泡排序（Bubble Sort）是一种简单的排序算法，它重复地比较相邻的两个元素，并交换顺序不正确的元素，直到整个序列排序完成。

下面是冒泡排序的步骤：

  1. 从序列的第一个元素开始，比较该元素与下一个元素的大小。
  2. 如果当前元素大于下一个元素，则交换它们的位置。
  3. 继续向后比较相邻的元素，重复步骤 2，直到遍历到倒数第二个元素。
  4. 重复步骤 1 到步骤 3，直到没有需要交换的元素，即序列已经排序完成。

以下是使用 C 语言实现冒泡排序的示例代码：

void bubbleSort(int arr[], int n) {int i, j, temp;for (i = 0; i < n - 1; i++) {for (j = 0; j < n - i - 1; j++) {if (arr[j] > arr[j + 1]) {// 交换元素temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}
}

5.快速排序

快速排序（Quick Sort）是一种高效的排序算法，它基于分治的思想，通过将数组分成较小的子数组，然后递归地对子数组进行排序，最终将整个数组排序。

以下是快速排序的步骤：

  1. 选择一个元素作为基准（通常选择数组的第一个元素）。
  2. 将数组分成两个子数组，比基准小的元素放在左边，比基准大的元素放在右边。
  3. 对左右两个子数组递归地执行步骤 1 和步骤 2，直到子数组的长度为 0 或 1，表示已经排序完成。
  4. 合并排序后的子数组，得到最终的排序结果。

以下是使用 C 语言实现快速排序的示例代码：

// 交换两个元素的值
void swap(int* a, int* b) {int temp = *a;*a = *b;*b = temp;
}// 将数组分成左右两个子数组，并返回基准元素的最终位置
int partition(int arr[], int low, int high) {int pivot = arr[low];  // 选择第一个元素作为基准int i = low + 1;int j = high;while (1) {// 在左侧找到第一个大于基准的元素的位置while (i <= j && arr[i] < pivot) {i++;}// 在右侧找到第一个小于基准的元素的位置while (j >= i && arr[j] > pivot) {j--;}// 若两个指针相遇或交错，则跳出循环if (i >= j) {break;}// 交换元素，使小于基准的元素在左侧，大于基准的元素在右侧swap(&arr[i], &arr[j]);i++;j--;}// 将基准元素放到最终的位置swap(&arr[low], &arr[j]);// 返回基准元素的位置return j;
}// 执行快速排序算法
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);}
}

6.简单选择排序

简单选择排序（Selection Sort）是一种简单直观的排序算法，它每次从未排序的部分选择最小（或最大）的元素，并将其放到已排序部分的末尾。

以下是简单选择排序的步骤：

  1. 在未排序部分中，找到最小（或最大）的元素。
  2. 将最小（或最大）的元素与未排序部分的第一个元素交换位置。
  3. 将已排序部分的末尾向后扩展一个位置。
  4. 重复步骤 1 到步骤 3，直到未排序部分为空。

以下是使用 C 语言实现简单选择排序的示例代码：

void swap(int* a, int* b) {int temp = *a;*a = *b;*b = temp;
}void selectionSort(int arr[], int n) {int i, j, minIndex;for (i = 0; i < n - 1; i++) {minIndex = i;for (j = i + 1; j < n; j++) {if (arr[j] < arr[minIndex]) {minIndex = j;}}swap(&arr[i], &arr[minIndex]);}
}

7.堆排序

堆排序（Heap Sort）是一种基于堆数据结构的排序算法，它利用堆的性质进行排序。堆排序分为两个步骤：建堆和排序。

以下是堆排序的步骤：

  1. 建堆（Heapify）：将待排序的数组构建成一个堆结构。堆是一个完全二叉树，其中每个节点的值都大于等于（或小于等于）其子节点的值，这被称为最大堆（或最小堆）的性质。
  2. 排序：将堆顶元素与最后一个叶节点交换，并从根节点开始调整堆，使其满足堆的性质。然后再次将堆顶元素与倒数第二个叶节点交换，再次调整堆。重复这个过程，直到堆中剩下一个元素为止。

以下是使用 C 语言实现堆排序的示例代码：

// 交换两个元素的值
void swap(int* a, int* b) {int temp = *a;*a = *b;*b = temp;
}// 对以rootIndex为根节点的子树进行堆调整，n为堆的大小
void heapify(int arr[], int n, int rootIndex) {int largest = rootIndex;  // 最大元素的索引int leftChild = 2 * rootIndex + 1;  // 左子节点的索引int rightChild = 2 * rootIndex + 2;  // 右子节点的索引// 找出左右子节点和根节点中的最大元素if (leftChild < n && arr[leftChild] > arr[largest]) {largest = leftChild;}if (rightChild < n && arr[rightChild] > arr[largest]) {largest = rightChild;}// 如果最大元素不是根节点，则交换根节点和最大元素，并递归调整交换后的子树if (largest != rootIndex) {swap(&arr[rootIndex], &arr[largest]);heapify(arr, n, largest);}
}// 堆排序
void heapSort(int arr[], int n) {// 构建最大堆，从最后一个非叶节点开始向上调整for (int i = n / 2 - 1; i >= 0; i--) {heapify(arr, n, i);}// 依次将堆顶元素与末尾元素交换，并重新调整堆for (int i = n - 1; i >= 0; i--) {swap(&arr[0], &arr[i]);heapify(arr, i, 0);}
}

在上述代码中，我们定义了一个辅助函数 swap，用于交换两个元素的值。

然后，我们定义了 heapify 函数来进行堆调整，以满足堆的性质。

接下来，我们定义了 heapSort 函数来执行堆排序算法。在该函数中，我们首先构建一个最大堆，然后依次将堆顶元素与末尾元素交换，并重新调整堆。

8.归并排序

归并排序（Merge Sort）是一种基于分治思想的排序算法。它将待排序的数组分成两个子数组，分别进行排序，然后将排序后的子数组合并成一个有序数组。归并排序的关键步骤是合并（Merge）操作，通过将两个有序的子数组合并成一个有序数组来实现排序。

以下是归并排序的步骤：

  1. 分解：将待排序的数组递归地分解成两个子数组，直到每个子数组只剩下一个元素或为空。
  2. 合并：将两个有序的子数组合并成一个有序数组。合并过程中，依次比较两个子数组的元素，将较小（或较大）的元素放入临时数组中，并更新索引，直到其中一个子数组的所有元素都放入临时数组中。将剩余的元素依次放入临时数组中。
  3. 返回合并后的有序数组。

以下是使用 C 语言实现归并排序的示例代码：

#include <stdio.h>
#include <stdlib.h>// 合并两个有序子数组为一个有序数组
void merge(int arr[], int left, int mid, int right) {int n1 = mid - left + 1;    // 左子数组的元素个数int n2 = right - mid;       // 右子数组的元素个数// 创建临时数组来存储两个子数组的元素int* leftArr = (int*)malloc(n1 * sizeof(int));int* rightArr = (int*)malloc(n2 * sizeof(int));// 将元素复制到临时数组中for (int i = 0; i < n1; i++) {leftArr[i] = arr[left + i];}for (int j = 0; j < n2; j++) {rightArr[j] = arr[mid + 1 + j];}// 合并两个子数组为一个有序数组int i = 0;      // 左子数组的索引int j = 0;      // 右子数组的索引int k = left;   // 合并后数组的索引while (i < n1 && j < n2) {if (leftArr[i] <= rightArr[j]) {arr[k] = leftArr[i];i++;} else {arr[k] = rightArr[j];j++;}k++;}// 将剩余的元素放入合并后的数组中while (i < n1) {arr[k] = leftArr[i];i++;k++;}while (j < n2) {arr[k] = rightArr[j];j++;k++;}// 释放临时数组的内存free(leftArr);free(rightArr);
}// 归并排序递归函数
void mergeSort(int arr[], int left, int right) {if (left < right) {int mid = left + (right - left) / 2;    // 计算中间索引// 递归地对左右子数组进行排序mergeSort(arr, left, mid);mergeSort(arr, mid + 1, right);// 合并两个有序子数组merge(arr, left, mid, right);}
}// 示例用法
int main() {int arr[] = {5, 2, 8, 1, 3};int n = sizeof(arr) / sizeof(arr[0]);mergeSort(arr, 0, n - 1);printf("Sorted array: ");for (int i = 0; i < n; i++) {printf("%d ", arr[i]);}printf("\n");return 0;
}

在上述代码中，我们定义了 merge 函数，用于合并两个有序子数组。该函数接受数组 arr、左子数组的起始索引 left、中间索引 mid 和右子数组的结束索引 right。

然后，我们定义了 mergeSort 函数来执行归并排序算法。该函数采用分治的思想，首先递归地对左右子数组进行排序，然后调用 merge 函数合并两个有序子数组。

9.基数排序

基数排序（Radix Sort）是一种非比较型的排序算法，它根据元素的位数进行排序。基数排序逐位比较元素，从最低有效位（LSB）到最高有效位（MSB）进行排序。在每一位上，使用稳定的排序算法（如计数排序或桶排序）对元素进行排序。通过重复这个过程，直到对所有位都完成排序，最终得到一个有序的数组。

以下是基数排序的步骤：

  1. 获取数组中最大元素的位数（最大元素的位数决定了排序的轮数）。
  2. 对每一位进行排序：
    • 使用稳定的排序算法对当前位进行排序（例如计数排序或桶排序）。
    • 根据当前位的值将元素放入对应的桶中。
    • 将桶中的元素按照顺序取出，更新原数组。
  3. 重复步骤 2 直到对所有位都完成排序。

以下是使用 C 语言实现基数排序的示例代码，使用计数排序作为稳定的排序算法：

#include <stdio.h>// 获取数组中的最大元素
int getMax(int arr[], int n) {int max = arr[0];for (int i = 1; i < n; i++) {if (arr[i] > max) {max = arr[i];}}return max;
}// 使用计数排序对数组按照指定的位进行排序
void countSort(int arr[], int n, int exp) {const int MAX_RANGE = 10;  // 桶的范围，0-9int output[n];             // 存储排序结果的临时数组int count[MAX_RANGE] = {0};// 统计当前位上每个数字的出现次数for (int i = 0; i < n; i++) {count[(arr[i] / exp) % 10]++;}// 计算每个数字在排序后的数组中的起始索引for (int i = 1; i < MAX_RANGE; i++) {count[i] += count[i - 1];}// 将元素按照当前位的值放入临时数组中，同时更新 count 数组for (int i = n - 1; i >= 0; i--) {output[count[(arr[i] / exp) % 10] - 1] = arr[i];count[(arr[i] / exp) % 10]--;}// 将临时数组的元素复制回原数组for (int i = 0; i < n; i++) {arr[i] = output[i];}
}// 基数排序
void radixSort(int arr[], int n) {int max = getMax(arr, n);  // 获取最大元素// 对每一位进行排序for (int exp = 1; max / exp > 0; exp *= 10) {countSort(arr, n, exp);}
}

在上述代码中，我们定义了 getMax 函数，用于获取数组中的最大元素。

然后，我们定义了 countSort 函数，用于对数组按照指定的位进行排序。该函数采用计数排序算法，在每一位上统计元素的出现次数，然后根据当前位的值将元素放入对应的桶中，并更新原数组。

接下来，我们定义了 radixSort 函数来执行基数排序算法。该函数通过循环对每一位进行排序，调用 countSort 函数。

10.外部排序

外部排序（External Sorting）是一种用于处理大规模数据的排序算法，其中数据量大于计算机内存的容量。外部排序通常涉及将数据分割成较小的块，然后在内存中对这些块进行排序，并最终将它们合并为一个有序的结果。

以下是一种常见的外部排序算法：多路归并排序（Multiway Merge Sort）。

多路归并排序的基本思想是将大型数据集分割成更小的块（通常是内存可容纳的大小），在内存中对这些块进行排序，然后使用归并操作将它们合并成一个有序的结果。

以下是多路归并排序的步骤：

  1. 将大型数据集划分为较小的块，每个块可以适应内存容量。可以使用外部缓存或者分割文件为固定大小的块来实现。
  2. 将每个块加载到内存中，并使用内部排序算法（如快速排序、归并排序等）对块进行排序。
  3. 创建一个输出文件作为最终的有序结果。
  4. 从每个块中读取一部分数据到内存中（通常是一个块的大小），选择最小的元素，将其写入输出文件。
  5. 如果块中的数据被消耗完，从该块所在的文件中读取下一块数据到内存中。
  6. 重复步骤 4 和步骤 5，直到所有块中的数据都被处理。
  7. 关闭输出文件，排序完成。

需要注意的是，多路归并排序需要使用外部存储器（例如磁盘）来存储和处理大量数据，因此算法的性能会受到外部存储器的读写速度的限制。

实际的外部排序算法中，还会考虑更复杂的策略，如缓冲区管理、归并策略等，以提高排序的效率和性能。

外部排序是一种常用的处理大规模数据的排序方法，在处理海量数据、大型数据库等场景中有广泛的应用。

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

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

相关文章

LSTM中文新闻分类源码详解

LSTM中文新闻分类源码详解

LSTM中文新闻分类 一、导包二、读取数据三、数据预处理1.分词、去掉停用词和数字、字母转换成小写等2.新闻文本标签数值化 三、创建词汇表/词典1.data.Field()2.空格切分等3.构建词汇表/词典使用训练集构建单词表&#xff0c;vectorsNone:没有使用预训练好的词向量,而是使用的是…
阅读更多...
阿里云自建官方Docker仓库镜像提交拉取方法

阿里云自建官方Docker仓库镜像提交拉取方法

文章目录 发布镜像到DockerHub发布镜像到自建Docker仓库(Harbor)修改配置文件在Linux服务器中登录Docker打TAGPUSH提交镜像PULL拉取镜像 发布镜像到阿里云容器服务在Linux服务器中登录DockerPUSH提交镜像PULL拉取镜像 发布镜像到DockerHub 本地我们镜像命名可能会不规范&#…
阅读更多...
详解Keras3.0 Layer API: LSTM layer

详解Keras3.0 Layer API: LSTM layer

LSTM layer 用于实现长短时记忆网络&#xff0c;它的主要作用是对序列数据进行建模和预测。 遗忘门&#xff08;Forget Gate&#xff09;&#xff1a;根据当前输入和上一个时间步的隐藏状态&#xff0c;计算遗忘门的值。遗忘门的作用是控制哪些信息应该被遗忘&#xff0c;哪些…
阅读更多...
kotlin by lazy 的使用

kotlin by lazy 的使用

by lazy 的作用 by 是在kotlin中代表者委托&#xff0c; lazy 懒加载 by lazy 就是委托延时处理 下面写一个demo说明下 新建一个类 class ExportController {fun getName(): String? {return "name";}fun getAge(): Int {return 18;}} 在mian中如下 class Ma…
阅读更多...
C语言中的结构体和联合体：异同及应用

C语言中的结构体和联合体：异同及应用

文章目录 C语言中的结构体和联合体&#xff1a;异同及应用1. 结构体&#xff08;Struct&#xff09;的概述代码示例&#xff1a; 2. 联合体&#xff08;Union&#xff09;的概述代码示例&#xff1a; 3. 结构体与联合体的异同点相同点&#xff1a;不同点&#xff1a;代码说明 结…
阅读更多...
C++面试宝典第10题：绘制各种图形

C++面试宝典第10题：绘制各种图形

题目 我们需要编写一个图形相关的应用程序，并处理大量图形（Shape）信息，图形有矩形（Rectangle）、正方形（Square）、圆形（Circle）等种类。应用程序需要计算这些图形的面积，并且可能需要在某个设备上进行显示（使用在标准输出上打印信息的方式作为示意）。 （1）请使用面…
阅读更多...
华为——使用ACL限制内网主机访问外网网站示例

华为——使用ACL限制内网主机访问外网网站示例

组网图形 图1 使用ACL限制内网主机访问外网网站示例 ACL简介配置注意事项组网需求配置思路操作步骤配置文件 ACL简介 访问控制列表ACL&#xff08;Access Control List&#xff09;是由一条或多条规则组成的集合。所谓规则&#xff0c;是指描述报文匹配条件的判断语句&#…
阅读更多...
Python技能手册 - 模块module

Python技能手册 - 模块module

目录 内置排序 列表排序 元组排序 字符串排序&#xff08;按长度&#xff09; 字符串排序&#xff08;按字典序&#xff09; 类排序 Lambda表达式排序 copy 浅拷贝 copy.copy 深拷贝 copy.deepcopy heapq 创建&#xff08;小顶&#xff09;堆 heapq.heappush 获取…
阅读更多...
Spring系列：基于Spring-Jdbc实现事务

Spring系列：基于Spring-Jdbc实现事务

文章目录 一、事务基本概念二、编程式事务三、声明式事务前期准备 四、基于注解的声明式事务Transactional注解标识的位置事务属性&#xff1a;只读事务属性&#xff1a;超时事务属性&#xff1a;回滚策略事务属性&#xff1a;隔离级别事务属性&#xff1a;传播行为测试 五、基…
阅读更多...
大数据开发之Sqoop详细介绍

大数据开发之Sqoop详细介绍

测试环境 CDH 6.3.1 Sqoop 1.4.7 一.Sqoop概述 Apache Sqoop&#xff08;SQL-to-Hadoop&#xff09;项目旨在协助RDBMS与Hadoop之间进行高效的大数据交流。用户可以在 Sqoop 的帮助下&#xff0c;轻松地把关系型数据库的数据导入到 Hadoop 与其相关的系统 (如HBase和Hive)中&…
阅读更多...
IRIS、Cache系统类汉化

IRIS、Cache系统类汉化

文章目录 系统类汉化简介标签说明汉化系统包说明效果展示类分类%Library包下的类重点类非重点类弃用类数据类型类工具类 使用说明 系统类汉化 简介 帮助小伙伴更加容易理解后台系统程序方法使用&#xff0c;降低代码的难度。符合本土化中文环境的开发和维护&#xff0c;有助于…
阅读更多...
年底大厂今年发多少年终奖，怎么发（上）？

年底大厂今年发多少年终奖，怎么发（上）？

马上就2023年年底了&#xff0c;互联网大厂腾讯员工首先&#xff0c;发年终奖了&#xff0c;111354 元&#xff01; 腾讯的同学可以查一查了&#xff0c;应该发多少已经定下来了&#xff01;&#x1f44b; 除此之外&#xff0c;千寻找了很多的大厂的年终奖发放时间&#xff0c;…
阅读更多...
k8s搭建（一、环境配置与docker安装）

k8s搭建（一、环境配置与docker安装）

天行健&#xff0c;君子以自强不息&#xff1b;地势坤&#xff0c;君子以厚德载物。 每个人都有惰性&#xff0c;但不断学习是好好生活的根本&#xff0c;共勉&#xff01; 文章均为学习整理笔记&#xff0c;分享记录为主&#xff0c;如有错误请指正&#xff0c;共同学习进步。…
阅读更多...
SpringBoot3 整合Redis

SpringBoot3 整合Redis

1. 场景整合 依赖导入 <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId> </dependency>配置 spring.data.redis.host192.168.200.100 spring.data.redis.passwordLfy…
阅读更多...
Android Studio 如何隐藏默认标题栏

Android Studio 如何隐藏默认标题栏

目录 前言 一、修改清单文件 二、修改代码 三、更多资源 前言 在 Android 应用中&#xff0c;通常会有一个默认的标题栏&#xff0c;用于显示应用的名称和一些操作按钮。但是&#xff0c;在某些情况下&#xff0c;我们可能需要隐藏默认的标题栏&#xff0c;例如自定义标题栏…
阅读更多...
时序预测 | Matlab实现SSA-CNN-LSTM麻雀算法优化卷积长短期记忆神经网络时间序列预测

时序预测 | Matlab实现SSA-CNN-LSTM麻雀算法优化卷积长短期记忆神经网络时间序列预测

时序预测 | Matlab实现SSA-CNN-LSTM麻雀算法优化卷积长短期记忆神经网络时间序列预测 目录 时序预测 | Matlab实现SSA-CNN-LSTM麻雀算法优化卷积长短期记忆神经网络时间序列预测预测效果基本介绍程序设计参考资料 预测效果 基本介绍 MATLAB实现SSA-CNN-LSTM麻雀算法优化卷积长短…
阅读更多...
electron + sqlite3 解决打包后无法写入数据库

electron + sqlite3 解决打包后无法写入数据库

前言 window环境。 electron28.0.0 sqlite35.1.6 使用 electron-builder 打包。 本文旨在解决打包后无法写入数据库的问题。 但如果你是打包后无法访问sqlite&#xff0c;且有报错弹窗&#xff0c;不妨也看看本文。 也许是同一种原因。 错误原因分析 打包后无法创建db文件&…
阅读更多...
【HarmonyOS开发】探究Hap与App包的结构与区别

【HarmonyOS开发】探究Hap与App包的结构与区别

1、Hap与App包的区别 OpenHarmony 可以进行两种形式&#xff08;Hap和App&#xff09;的打包&#xff0c;HAP是用于本地调试的&#xff0c;APP包是用于上架发布的。 根据不同的设备类型&#xff0c;一个APP包可以包含多个HAP包。 下面从两个角度进行分析 1.1 编译构建角度 编…
阅读更多...
uniapp中uview的text组件

uniapp中uview的text组件

基本使用&#xff1a; 通过text参数设置文本内容。推荐您使用:textvalue的形式 <u--text text"我用十年青春,赴你最后之约"></u--text>设置主题&#xff1a; 通过type参数设置文本主题&#xff0c;我们提供了五类属性。primary error success warning…
阅读更多...
javafx写一个文档编辑器

javafx写一个文档编辑器

文本编辑器是一种用于编辑纯文本文件的工具。它具有基本的文本编辑功能，如插入、删除、复制、粘贴等。文本编辑器通常不具备格式化文本、排版和图形编辑等高级功能，专注于纯文本的编辑。常见的文本编辑器包括记事本(Notepad)、Sublime Text、Visual Studio Code、Atom、Emacs…
阅读更多...
最新文章

Copyright @ 2022~2023