排序算法详细总结

news/2024/11/13 10:18:21/

算法

  1. 定义：算法是解决特定问题的明确步骤集合。算法的效率通常用时间复杂度和空间复杂度来衡量。

算法>排序算法

  1. 定义：算法>排序算法是计算机科学中用于对元素序列进行排序的一系列算法。算法>排序算法在各种应用中都非常常见，从简单的数据处理到复杂的数据库和搜索引擎优化。
  2. 分类：冒泡排序（Bubble Sort）、选择排序（Selection Sort）、插入排序（Insertion Sort）、归并排序（Merge Sort）、快速排序（Quick Sort）、堆排序（Heap Sort）、希尔排序（Shell Sort）、计数排序（Counting Sort）、桶排序（Bucket Sort）、基数排序（Radix Sort）等等。

冒泡排序 Bubble Sort

  1. 定义：冒泡排序（Bubble Sort）是一种简单的算法>排序算法，它通过重复遍历要排序的数列，比较每对相邻元素，并在顺序错误的情况下交换它们。这个过程会重复进行，直到没有再需要交换的元素为止，这意味着数列已经排序完成。冒泡排序的名字来源于较小的元素会逐渐“冒泡”到数列的顶端（开始位置）。
  2. 步骤：
    • 比较相邻的元素：从数列的开始位置比较每对相邻元素，如果第一个比第二个大，则交换它们的位置。
    • 遍历数列：继续比较下一对相邻元素，直到到达数列的末尾。
    • 重复遍历：重复上述步骤，但每次遍历都从上一次遍历停止的位置开始，因为最后的元素已经是最大的，不需要再比较。
    • 优化：在每次遍历中，如果一次完整的遍历都没有发生交换，说明数列已经排序完成，可以提前结束排序。
  3. 复杂度：
    • 时间复杂度：冒泡排序的平均和最坏情况时间复杂度都是 (O(n^2))，其中 (n) 是数列的长度。这是因为算法需要进行多次遍历和比较。
    • 空间复杂度：冒泡排序的空间复杂度是 (O(1))，因为它只需要一个额外的空间来存储交换的元素。
  4. 示例
#include <iostream>
#include <vector>
#include <algorithm> // 用于std::swap// 冒泡排序函数
void bubbleSort(std::vector<int>& arr) {int n = arr.size();bool swapped;for (int i = 0; i < n - 1; i++) {swapped = false;for (int j = 0; j < n - i - 1; j++) {if (arr[j] > arr[j + 1]) {// 使用std::swap交换两个元素std::swap(arr[j], arr[j + 1]);swapped = true;}}// 如果在这一轮排序中没有发生交换，说明数组已经有序，可以提前结束if (!swapped) {break;}}
}// 打印数组的函数
void printArray(const std::vector<int>& arr) {for (int num : arr) {std::cout << num << " ";}std::cout << std::endl;
}// 主函数
int main() {std::vector<int> arr = {64, 34, 25, 12, 22, 11, 90};std::cout << "Original array:\n";printArray(arr);bubbleSort(arr);std::cout << "Sorted array:\n";printArray(arr);return 0;
}

快速排序 Quick Sort

  1. 定义：由英国计算机科学家托尼·霍尔（Tony Hoare）在1960年提出。它的基本思想是分治法（Divide and Conquer），通过一个称为“基准”（pivot）的元素将数组分成两个子数组，使得左边子数组的所有元素都比基准小，右边子数组的所有元素都比基准大，然后递归地对这两个子数组进行快速排序。
  2. 基本步骤：
    • 选择基准：从数组中选择一个元素作为基准（pivot）。选择基准的方法可以有多种，例如选择第一个元素、最后一个元素、中间元素，或者随机选择一个元素。
    • 分区操作（Partitioning）：重新排列数组，使得所有比基准小的元素都在基准的左边，所有比基准大的元素都在基准的右边。这个过程结束后，基准元素就处于其最终位置。
    • 递归排序：递归地对基准左边和右边的子数组进行快速排序。
    • 返回：当子数组的大小减少到1或0时，递归结束，整个数组变为有序。
  3. 复杂度：平均时间复杂度为 O(nlogn)，但在最坏情况下（例如，数组已经是有序的，或者所有元素都相等）时间复杂度会退化到 O(n^2)。
  4. 示例：
#include <iostream>
#include <vector>// 交换两个元素
void swap(int* a, int* b) {int t = *a;*a = *b;*b = t;
}// 选择基准并进行分区
int partition(std::vector<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++;    // 增加小于基准元素的索引swap(&arr[i], &arr[j]);}}swap(&arr[i + 1], &arr[high]);return (i + 1);
}// 快速排序函数
void quickSort(std::vector<int>& arr, int low, int high) {if (low < high) {// pi 是分区后的基准索引，可以直接选择 （low+high）/2 位置作为分区索引int pi = partition(arr, low, high);// 分别对基准左边和右边的子数组进行快速排序quickSort(arr, low, pi - 1);quickSort(arr, pi + 1, high);}
}// 打印数组
void printArray(const std::vector<int>& arr) {for (int num : arr) {std::cout << num << " ";}std::cout << std::endl;
}// 主函数
int main() {std::vector<int> arr = {10, 7, 8, 9, 1, 5};int n = arr.size();std::cout << "Original array: ";printArray(arr);quickSort(arr, 0, n - 1);std::cout << "Sorted array: ";printArray(arr);return 0;
}

选择排序 Selection Sort

  1. 定义：是一种简单直观的算法>排序算法。它的工作原理是：首先在未排序的元素中找到最小（或最大）的元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
  2. 基本步骤：
    • 从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置。
    • 从剩余未排序元素中寻找最小（或最大）元素，然后放到已排序序列的末尾。
    • 重复第二步，直到所有元素均排序完毕。
  3. 示例：
#include <iostream>
#include <vector>
#include <algorithm> // For std::swap()void selectionSort(std::vector<int>& arr) {int n = arr.size();for (int i = 0; i < n - 1; ++i) {// 找到从i到数组末尾部分的最小元素的索引int min_idx = i;for (int j = i + 1; j < n; ++j) {if (arr[j] < arr[min_idx]) {min_idx = j;}}// 交换当前位置i和找到的最小元素的位置std::swap(arr[i], arr[min_idx]);}
}int main() {std::vector<int> arr = {64, 25, 12, 22, 11};selectionSort(arr);std::cout << "Sorted array: ";for (int num : arr) {std::cout << num << " ";}std::cout << std::endl;return 0;
}

插入排序 Insertion Sort

  1. 定义：是一种简单直观的算法>排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为新元素提供插入空间。
  2. 基本步骤：
    • 从第一个元素开始，该元素可以认为已经被排序。
    • 取出下一个元素，在已经排序的元素序列中从后向前扫描。
    • 如果该元素（已排序）小于新元素，将该元素移到下一位置。
    • 重复步骤3，直到找到已排序元素小于或者等于新元素的位置。
    • 将新元素插入到该位置后。
    • 重复步骤2~5。
  3. 复杂度：时间复杂度是O(n2)，在小规模数据或基本有序的数据中，插入排序可以表现得非常好，因为它的最好情况和平均情况时间复杂度分别为O(n)和O(n2)。此外，插入排序是稳定的算法>排序算法，这意味着相等的元素之间的相对顺序不会改变。
  4. 示例：
#include <iostream>
#include <vector>void insertionSort(std::vector<int>& arr) {int n = arr.size();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 = j - 1;}// 将key插入到正确的位置arr[j + 1] = key;}
}
/* 推算
n = 5
第一次循环
for(i=1; i<5; i++>)
{key=arr[i]=arr[1]=5j=i-1 = 1-1 = 0while(0>=0 && 9>5){arr[j+1]=arr[1]=a[0]=9j = j-1 = -1}arr[j+1] = arr[0] = key = 5
}
第二次循环
for(i=2; i<5; i++)
{key = arr[i] = arr[2] = 1j = i-1 = 2-1 =1//第一次whilewhile(1>=0 && arr[1]>1){arr[j+1]=arr[2] = arr[1] = 9j = j-1=0}//第二次whilewhile(0>=0 && arr[0] > 1){arr[1] = arr[0] = 5j = j-1 = -1}arr[j+1] = arr[0] = key = 1
}
...以此类推...*/int main() {std::vector<int> arr = {9, 5, 1, 4, 3};insertionSort(arr);std::cout << "Sorted array: ";for (int num : arr) {std::cout << num << " ";}std::cout << std::endl;return 0;
}

归并排序 Merge Sort

  1. 定义：是一种分治算法，其基本思想是将两个已经排序的序列合并成一个排序的序列。归并排序的效率很高，对于大数据集来说，归并排序通常比插入排序和选择排序更快。归并排序是稳定的算法>排序算法，这意味着相等的元素之间的相对顺序不会改变。
  2. 基本步骤：
    • 将当前序列分成两个等长的部分。
    • 对两个部分分别进行归并排序。
    • 将两个已排序的部分合并成一个排序的序列。
  3. 复杂度：归并排序的时间复杂度是O(n log n)，其中n是数组的长度。由于归并排序需要额外的存储空间来存储临时数组，因此它的空间复杂度是O(n)。
  4. 示例：
#include <iostream>
#include <vector>// 合并两个子序列的函数
void merge(std::vector<int>& arr, int left, int mid, int right) {int n1 = mid - left + 1; // 左子序列的长度int n2 = right - mid;   // 右子序列的长度// 创建临时数组std::vector<int> L(n1), R(n2);// 拷贝数据到临时数组 L[] 和 R[]for (int i = 0; i < n1; i++)L[i] = arr[left + i];for (int j = 0; j < n2; j++)R[j] = arr[mid + 1 + j];// 合并临时数组回到 arr[left..right]int i = 0; // 初始索引第一个子数组int j = 0; // 初始索引第二个子数组int k = left; // 初始索引合并的子数组while (i < n1 && j < n2) {if (L[i] <= R[j]) {arr[k] = L[i];i++;} else {arr[k] = R[j];j++;}k++;}// 拷贝 L[] 的剩余元素while (i < n1) {arr[k] = L[i];i++;k++;}// 拷贝 R[] 的剩余元素while (j < n2) {arr[k] = R[j];j++;k++;}
}// l 是数组的左边界，r 是右边界
void mergeSort(std::vector<int>& arr, int left, int right) {if (left < right) {// 同 [left, mid] 和 [mid+1, right] 两个子序列int mid = left + (right - left) / 2;// 分别对两个子序列进行归并排序mergeSort(arr, left, mid);mergeSort(arr, mid + 1, right);// 合并两个子序列merge(arr, left, mid, right);}
}int main() {std::vector<int> arr = {12, 11, 13, 5, 6};int arr_size = arr.size();mergeSort(arr, 0, arr_size - 1);std::cout << "Sorted array: ";for (int i = 0; i < arr_size; i++) {std::cout << arr[i] << " ";}std::cout << std::endl;return 0;
}

堆排序 Heap Sort

  1. 定义：是一种基于比较的算法>排序算法，使用二叉堆数据结构。堆排序分为两个阶段：建立堆（Build Max Heap）和排序（Heapsort）。堆是一个满足以下性质的完全二叉树：对于最大的堆（大顶堆），父节点的键值总是大于或等于其子节点的键值；对于最小的堆（小顶堆），父节点的键值总是小于或等于其子节点的键值。
  2. 基本步骤：
    • 建立最大堆：将无序序列构建成一个最大堆，即每个父节点的值都大于或等于其子节点的值。
    • 排序：交换堆顶元素（当前最大值）和数组末尾元素，然后对堆进行调整（堆化），使其满足最大堆的性质。重复这个过程，直到数组完全有序。
  3. 复杂度：堆排序的时间复杂度是O(n log n)，其中n是数组的长度。堆排序是原地排序，不需要额外的存储空间，因此空间复杂度是O(1)。
  4. 示例：
#include <iostream>
#include <vector>
#include <algorithm> // For std::swap()// 调整堆，保持最大堆性质
void heapify(std::vector<int>& arr, int n, int i) {int largest = i;       // 初始化最大元素为根int left = 2 * i + 1;  // 左子节点int right = 2 * i + 2; // 右子节点// 如果左子节点比根大，则更新最大元素if (left < n && arr[left] > arr[largest])largest = left;// 如果右子节点比最大元素大，则更新最大元素if (right < n && arr[right] > arr[largest])largest = right;// 如果最大元素不是根，交换它们，并继续调整堆if (largest != i) {std::swap(arr[i], arr[largest]);heapify(arr, n, largest);}
}// 堆排序
void heapSort(std::vector<int>& arr) {int n = arr.size();// 构建最大堆for (int i = n / 2 - 1; i >= 0; i--)heapify(arr, n, i);// 一个个从堆顶取出元素for (int i = n - 1; i >= 0; i--) {// 将当前最大元素（堆顶）与末尾元素交换std::swap(arr[0], arr[i]);// 调整堆heapify(arr, i, 0);}
}int main() {std::vector<int> arr = {12, 11, 13, 5, 6};heapSort(arr);std::cout << "Sorted array: ";for (int num : arr) {std::cout << num << " ";}std::cout << std::endl;return 0;
}

希尔排序 Shell Sort

  1. 定义：是插入排序的一种优化版本，也称为缩小增量排序。它的基本思想是将原始数据分成若干子序列，这些子序列中的元素之间存在一定的间隔（称为增量），对每个子序列分别进行插入排序。随着增量逐渐减小，整个序列最终变为有序序列。
  2. 基本步骤：
    • 选择一个增量序列：增量序列的选择对算法的性能有很大影响。常见的增量序列有原始长度的一半、原始长度除以某个常数等。
    • 对子序列进行插入排序：以增量为间隔将原始序列分割成多个子序列，并对每个子序列进行插入排序。
    • 减小增量：减小增量的值，重复步骤2，直到增量为1，此时对整个序列进行插入排序。
  3. 复杂度：时间复杂度在平均情况下是O(n log n)，但在最坏情况下是O(n^2)。希尔排序是不稳定的算法>排序算法.
  4. 示例:
#include <iostream>
#include <vector>
#include <algorithm> // For std::swap()// 希尔排序
void shellSort(std::vector<int>& arr) {int n = arr.size();// 增量序列，可以自定义增量序列std::vector<int> gaps = {1, 4, 10, 23, 57, 132, 316};// 也可以使用动态计算增量序列，例如：gaps[i] = n/2^ifor (int gap : gaps) {for (int i = gap; i < n; i++) {int temp = arr[i];int j;for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {arr[j] = arr[j - gap];}arr[j] = temp;}}
}int main() {std::vector<int> arr = {12, 11, 13, 5, 6, 7, 2, 3, 4, 1};shellSort(arr);std::cout << "Sorted array: ";for (int num : arr) {std::cout << num << " ";}std::cout << std::endl;return 0;
}

计数排序 Counting Sort

  1. 定义：是一种非比较型算法>排序算法，适用于一定范围内的整数排序。它的基本思想是使用一个额外的数组来统计每个值的出现次数，然后根据这些计数来确定每个元素在排序后数组中的位置。
  2. 基本步骤：
    • 找出待排序数组中的最大值和最小值：确定排序的范围。
    • 创建计数数组：初始化计数数组，长度为最大值和最小值之差再加1。
    • 填充计数数组：遍历待排序数组，对于每个元素，增加计数数组中对应位置的计数。
    • 调整计数数组：将计数数组中的每个值调整为累积计数，这将给出每个元素在排序后数组中的位置。
    • 构建排序数组：根据调整后的计数数组构建排序后的数组。
  3. 复杂度：计数排序的时间复杂度是O(n + k)，其中n是数组的长度，k是数值的范围。计数排序是稳定的算法>排序算法，并且由于它不需要比较，所以在处理大量数据且数值范围不大时非常高效。然而，当数值范围非常大时，计数排序可能会消耗大量内存
  4. 示例:
#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>// 计数排序
void countingSort(std::vector<int>& arr) {int n = arr.size();int maxVal = *std::max_element(arr.begin(), arr.end());int minVal = *std::min_element(arr.begin(), arr.end());// 计数数组的大小int range = maxVal - minVal + 1;std::vector<int> count(range, 0);// 填充计数数组for (int num : arr) {count[num - minVal]++;}// 调整计数数组为累积计数for (int i = 1; i < count.size(); i++) {count[i] += count[i - 1];}// 构建排序数组std::vector<int> sortedArr(n);for (int num : arr) {sortedArr[count[num - minVal] - 1] = num;count[num - minVal]--;}// 将排序后的数组复制回原数组for (int i = 0; i < n; i++) {arr[i] = sortedArr[i];}
}int main() {std::vector<int> arr = {4, 2, 2, 8, 3, 3, 1};countingSort(arr);std::cout << "Sorted array: ";for (int num : arr) {std::cout << num << " ";}std::cout << std::endl;return 0;
}

桶排序 Bucket Sort

  1. 定义：是一种分布式算法>排序算法，其基本思想是将数组分为多个“桶”，每个桶负责排序数组中的一部分数据。桶排序通常用于数据服从均匀分布的情况，它通过将数据分散到有限数量的桶里，每个桶内使用其他算法>排序算法（如插入排序）进行排序，最后按顺序合并各个桶中的数据以得到有序的序列。
  2. 基本步骤：
    • 确定桶的数量：根据数据的范围和数据个数确定桶的数量。
    • 分配数据到桶：遍历待排序数组，将每个数据分配到对应的桶中。
    • 对每个桶内的数据进行排序：通常使用插入排序或其他算法>排序算法对桶内数据进行排序。
    • 合并桶中的数据：按顺序合并各个桶中的数据，得到最终的有序序列。
  3. 复杂度：时间复杂度取决于桶的数量和使用的算法>排序算法，平均情况下是O(n+k)，其中n是数组的长度，k是桶的数量。桶排序是稳定的算法>排序算法，并且由于它不需要比较，所以在处理大量数据且数值范围不大时非常高效。然而，桶排序的性能依赖于数据的分布，如果数据分布不均匀，性能可能会下降.
  4. 示例:
#include <iostream>
#include <vector>
#include <algorithm>void bucketSort(std::vector<int>& arr) {if (arr.empty()) {return;}// 找出最大值和最小值int maxVal = *std::max_element(arr.begin(), arr.end());int minVal = *std::min_element(arr.begin(), arr.end());// 计算桶的数量int bucketCount = (maxVal - minVal) / (arr.size() + 1) + 1;// 创建桶std::vector<std::vector<int>> buckets(bucketCount);// 分配数据到桶for (int num : arr) {int index = (num - minVal) / (arr.size() + 1);buckets[index].push_back(num);}// 对每个桶内的数据进行排序int idx = 0; // 用于结果数组的索引for (auto& bucket : buckets) {std::sort(bucket.begin(), bucket.end()); // 对每个桶进行排序for (int num : bucket) {arr[idx++] = num;}}
}int main() {std::vector<int> arr = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3};bucketSort(arr);std::cout << "Sorted array: ";for (int num : arr) {std::cout << num << " ";}std::cout << std::endl;return 0;
}

基数排序 Radix Sort

  1. 定义：是一种非比较型整数算法>排序算法，其基本思想是将整数按位数切割成不同的数字，然后按每个位数分别比较。排序过程从最低位开始，依次对每一位进行排序，直到最高位排序完成。
  2. 基本步骤：
    • 找到最大数：确定数组中的最大数，以确定最大位数。
    • 按位排序：从最低位到最高位，对每一位进行排序。
    • 使用稳定的算法>排序算法：通常使用计数排序或桶排序来对每一位进行排序。
    • 合并结果：经过每一位的排序后，整个数组变为有序。
  3. 复杂度：时间复杂度是O(nk)，其中n是数组的长度，k是数值的最大位数。基数排序是稳定的算法>排序算法，并且由于它不需要比较，所以在处理大量数据且数值范围不大时非常高效。基数排序适用于整数排序，对于非整数数据，需要进行适当的转换。
  4. 示例:
#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>// 计数排序辅助函数，对特定位数进行排序
void countSort(std::vector<int>& arr, int exp) {const int kMax = 10; // 0-9std::vector<int> output(arr.size());std::vector<int> count(kMax, 0);// 统计每个数字的出现次数for (int i = 0; i < arr.size(); ++i) {int index = (arr[i] / exp) % kMax;count[index]++;}// 计算累积出现次数for (int i = 1; i < kMax; ++i) {count[i] += count[i - 1];}// 填充输出数组for (int i = arr.size() - 1; i >= 0; --i) {int index = (arr[i] / exp) % kMax;output[count[index] - 1] = arr[i];count[index]--;}// 将输出数组复制回原数组for (int i = 0; i < arr.size(); ++i) {arr[i] = output[i];}
}// 基数排序
void radixSort(std::vector<int>& arr) {// 找到最大数，确定最大位数int maxVal = *std::max_element(arr.begin(), arr.end());int exp = 1; // 从最低位开始while (maxVal / exp > 0) {countSort(arr, exp); // 对每一位进行排序exp *= 10; // 移动到下一位}
}int main() {std::vector<int> arr = {170, 45, 75, 90, 802, 24, 2, 66};radixSort(arr);std::cout << "Sorted array: ";for (int num : arr) {std::cout << num << " ";}std::cout << std::endl;return 0;
}

http://www.ppmy.cn/news/1545940.html

相关文章

软件工程 软考

软件工程 软考

开发大型软件系统适用螺旋模型或者RUP模型 螺旋模型强调了风险分析&#xff0c;特别适用于庞大而复杂的、高风险的管理信息系统的开发。喷泉模型是一种以用户需求为动力&#xff0c;以对象为为驱动的模型&#xff0c;主要用于描述面向对象的软件开发过程。该模型的各个阶段没有…
阅读更多...
网络安全应急响应(归纳)

网络安全应急响应(归纳)

目录 一、概述二、理论 系统排查 系统基本信息 windowsLinux用户信息 WindowsLinux启动项&#xff1a;开机系统在前台或者后台运行的程序&#xff0c;是病毒等实现持久化驻留的常用方法。 WindowsLinux任务计划&#xff1a;由于很多计算机都会自动加载“任务计划”&#xff0c…
阅读更多...
线上问题的排查之频繁FullGC问题如何排查

线上问题的排查之频繁FullGC问题如何排查

0 详细问题案例 假设我们有一个大型电子商务网站&#xff0c;最近用户反馈系统响应变慢。运维团队发现服务器频繁出现FullGC&#xff0c;严重影响性能。 1.收集日志 首先&#xff0c;我们需要开启详细的GC日志。在JVM参数中添加。 2. 分析GC日志 使用工具(如GCViewer)分析GC…
阅读更多...
NoSQL大数据存储技术测试（1）绪论

NoSQL大数据存储技术测试（1）绪论

写在前面&#xff1a;未完成测试的同学&#xff0c;请先完成测试&#xff0c;此博文供大家复习使用&#xff0c;&#xff08;我的答案&#xff09;均为正确答案&#xff0c;大家可以放心复习 单项选择题 第1题 以下不属于云计算部署模型的是&#xff08; &#xff09; 公…
阅读更多...
Cesium实现雷达效果

Cesium实现雷达效果

目录 项目地址实现效果核心代码 项目地址 https://github.com/zhengjie9510/webgis-demo 实现效果 核心代码 var radar scene.primitives.add(new Primitive({geometryInstances: redCone,appearance: new MaterialAppearance({// 自定义纹理material: new Material({fabri…
阅读更多...
计算机课程管理：Spring Boot与工程认证的整合之道

计算机课程管理：Spring Boot与工程认证的整合之道

3系统分析 3.1可行性分析 通过对本基于工程教育认证的计算机课程管理平台实行的目的初步调查和分析&#xff0c;提出可行性方案并对其一一进行论证。我们在这里主要从技术可行性、经济可行性、操作可行性等方面进行分析。 3.1.1技术可行性 本基于工程教育认证的计算机课程管理平…
阅读更多...
使用 JPA 的 `save()` 方法更新数据库中的数据

使用 JPA 的 `save()` 方法更新数据库中的数据

在开发基于 JPA&#xff08;Java Persistence API&#xff09;的应用时&#xff0c;数据持久化操作中的常见问题是执行 save() 方法后数据库中的数据没有更新。本文将详细介绍 JPA 的 save() 方法如何工作、其可能出现的问题&#xff0c;以及如何解决这些问题&#xff0c;以确保…
阅读更多...
go语言使用总结（持续更新）

go语言使用总结（持续更新）

整理后的内容如下&#xff1a; 1. 先了解函数签名&#xff0c;再了解传入参数以及调用 函数签名是函数的声明部分&#xff0c;包括函数名、参数列表和返回值列表。理解函数签名是理解函数行为的第一步&#xff0c;尤其是在了解参数类型、参数数量和返回值类型等方面。通过了解…
阅读更多...
最新文章

Copyright @ 2022~2023