2023.7.15排序算法合集

排序算法合集

  • 一、概述
  • 二、排序算法
    • 1.冒泡排序
    • 2.插入排序
    • 3.选择排序
    • 4.快速排序
    • 5.归并排序
    • 6.计数排序
  • 三、完整源码

一、概述

  排序算法是计算机科学中的一类常见算法，用于将一组数据按照特定的顺序进行排列；排序算法的应用非常广泛，涉及到数据处理、搜索算法、数据库操作等众多领域。常见的排序算法有以下几种：

  1. 冒泡排序（Bubble Sort）
  2. 插入排序（Insertion Sort）
  3. 选择排序（Selection Sort）
  4. 快速排序（Quick Sort）
  5. 归并排序（Merge Sort）
  6. 堆排序（Heap Sort）
  7. 希尔排序（Shell Sort）
  8. 计数排序（Counting Sort）
  9. 桶排序（Bucket Sort）
  10. 基数排序（Radix Sort）

奈何本人技术不太行，对于树和堆的理解不够透彻，所以涉及到这两种数据结构的排序算法可能要以后再补充

二、排序算法

文章使用 Java语言 进行演示，使用 int数据 类型作为示范，操作的数据结构均以 数组 为准，排序的结果为 从小到大 排列，同时提供随机初始化数据的方法

相关的全局变量和初始化数据方法如下

    public static int number;//用例数据量public static int[] nums;//用例数组/*** 用例随机初始化* @param number 用例数据量* @param start  用例起始范围* @param end    用例结束范围*/public static void initNums(int number, int start, int end) {nums = new int[number];for (int i = 0; i < nums.length; i++) {nums[i] = (int) (Math.random() * (end - start + 1) + start);}}

1.冒泡排序

  冒泡排序是一种简单直观的排序算法，它通过依次比较相邻的元素，并在必要时交换位置，使得每一轮循环后最大（或最小）的元素浮到序列的末尾。冒泡排序的过程可以描述如下：

  1. 从列表的第一个元素开始，依次比较相邻的两个元素。如果前一个元素大于（或小于）后一个元素，则交换它们的位置，使较大（或较小）的元素“冒泡”到后面
  2. 继续对剩余的元素进行相邻比较和交换操作，直到将最大（或最小）的元素移动到列表的最后位置
  3. 对除去最后一个元素的剩余列表重复上述步骤，每次循环将会确定一个最大（或最小）的元素到达正确的位置
  4. 重复上述步骤，直到整个列表排序完成

冒泡排序

    /*** 冒泡排序:从左到右逐个比较相邻的元素，并进行交换，每一轮将最大的元素移到最右侧*/public static void bubbleSort() {int[] bubbleSortNums = nums.clone();for (int i = 1; i < bubbleSortNums.length; i++) {for (int j = 0; j < bubbleSortNums.length - i; j++) {if (bubbleSortNums[j] > bubbleSortNums[j + 1]) {//已经确保两个数不相同，所以异或不会丢失数据bubbleSortNums[j] ^= bubbleSortNums[j + 1];bubbleSortNums[j + 1] ^= bubbleSortNums[j];bubbleSortNums[j] ^= bubbleSortNums[j + 1];}}}System.out.print("冒泡排序： ");System.out.println(Arrays.toString(bubbleSortNums));}

冒泡排序的时间复杂度为O(N2)，其中N为待排序元素的数量

2.插入排序

  插入排序是一种简单直观的排序算法，它的工作原理类似于整理扑克牌的过程。插入排序的基本思想是将待排序的元素逐个插入到已经排序的序列中的正确位置，从而逐步构建有序序列。下面是插入排序的步骤：

  1. 将列表的第一个元素视为已排序序列
  2. 从第二个元素开始，逐个将元素插入到已排序序列的正确位置。插入时，将当前元素与已排序序列中的元素从后向前逐个比较，直到找到合适的位置插入
  3. 重复上述步骤，直到将所有元素插入到正确的位置。

插入排序

    /*** 插入排序：逐个将元素插入到已排序的序列中的正确位置，构建最终有序序列*/public static void insertSort() {int[] insertSortNums = nums.clone();int temp = 0;//记录待插入的值int index = 0;//记录插入的位置boolean isFlag;for (int i = 1; i < insertSortNums.length; i++) {isFlag = false;for (int j = 0; j < i; j++) {if (insertSortNums[i] < insertSortNums[j]) {index = j;temp = insertSortNums[i];isFlag = true;break;}}if (isFlag) {//当需要向前插入的时候才执行，否则不用移动System.arraycopy(insertSortNums, index, insertSortNums, index + 1, i - index);
//                for (int j = i; j > index; j--) {
//                    insertSortNums[j] = insertSortNums[j - 1];
//                }insertSortNums[index] = temp;}}System.out.print("插入排序： ");System.out.println(Arrays.toString(insertSortNums));}

插入排序的时间复杂度为O(N2)，其中N为待排序元素的数量

3.选择排序

  选择排序是一种简单直观的排序算法，其基本思想是每一次从待排序的元素中选择最小（或最大）的元素，放置在已排序序列的末尾，从而逐步构建有序序列。选择排序的步骤如下：

  1. 遍历待排序序列，将第一个元素标记为当前最小（或最大）元素
  2. 从剩余的未排序元素中依次找到最小（或最大）的元素，与当前最小（或最大）元素进行比较
  3. 如果找到比当前最小（或最大）元素更小（或更大）的元素，则更新当前最小（或最大）元素的位置
  4. 继续遍历剩余的未排序元素，重复上述步骤，直到将所有元素排序完成
  5. 重复上述过程，直到所有元素都被排序

选择排序

    /*** 选择排序:每一轮从未排序的部分选择最小（或最大）的元素，放到已排序部分的末尾*/public static void selectSort() {int[] selectionSortNums = nums.clone();for (int i = 0; i < selectionSortNums.length - 1; i++) {//计数int maxNum = 0;//记录极大值的索引for (int j = 0; j < selectionSortNums.length - i; j++) {if (selectionSortNums[maxNum] < selectionSortNums[j]) {maxNum = j;}}//下面的if是用异或交换元素的重点，防止置0if (maxNum != selectionSortNums.length - i - 1) {//如果已经在对应位置就不需要移动，否则会导致异或同一个变量置0selectionSortNums[maxNum] ^= selectionSortNums[selectionSortNums.length - i - 1];selectionSortNums[selectionSortNums.length - i - 1] ^= selectionSortNums[maxNum];selectionSortNums[maxNum] ^= selectionSortNums[selectionSortNums.length - i - 1];}}System.out.print("选择排序： ");System.out.println(Arrays.toString(selectionSortNums));}

选择排序的时间复杂度为O(N2)，其中N为待排序元素的数量

4.快速排序

  快速排序是一种高效的排序算法，它采用分治法的思想。快速排序的基本思想是选择一个基准元素，将待排序序列划分为左右两个子序列，其中左边子序列的元素都小于等于基准元素，右边子序列的元素都大于等于基准元素，然后递归地对左右子序列进行排序，最终得到有序序列。快速排序的步骤如下：

  1. 选择一个基准元素（通常是列表的第一个或最后一个元素）
  2. 遍历整个序列，将小于等于基准元素的元素放到左边，大于等于基准元素的元素放到右边，形成两个子序列
  3. 递归地对左右子序列进行快速排序
  4. 将左子序列、基准元素、右子序列按照顺序连接起来，得到最终的有序序列

快速排序（双指针法）动画演示


快速排序（双指针法）动画演示 

    /*** 快速排序：选择一个基准元素，将数组分为小于基准值和大于基准值的两部分，递归地对这两部分进行排序(默认首元素为基准)*/public static void quickSort() {int[] quickSortNums = nums.clone();quick(quickSortNums, 0, quickSortNums.length - 1);System.out.print("快速排序： ");System.out.println(Arrays.toString(quickSortNums));}/*** 快速排序：选择一个基准元素，将数组分为小于基准值和大于基准值的两部分，递归地对这两部分进行排序(默认首元素为基准)* @param quickSortNums 待排序数组* @param start 左起点* @param end 右起点*/public static void quick(int[] quickSortNums, int start, int end) {if (start < end) {//直到序列内只有一个元素时，无需排序，结束递归int left = start;int right = end;int pivotIndex = start;//基准元素的索引值(选择第一个元素作为基准元素)//寻找基轴位置while (left < right) {//右侧扫描while (left < right && quickSortNums[right] >= quickSortNums[pivotIndex]) {//找到第一个小于基准的元素right--;}//和基轴交换位置if (left < right) {//保证小于基准的元素在右侧quickSortNums[right] ^= quickSortNums[pivotIndex];quickSortNums[pivotIndex] ^= quickSortNums[right];quickSortNums[right] ^= quickSortNums[pivotIndex];pivotIndex = right;}//左侧扫描while (left < right && quickSortNums[left] <= quickSortNums[pivotIndex]) {//找到第一个大于基准的元素left++;}//和基轴交换位置if (left < right) {//保证大于基准的元素在左侧quickSortNums[left] ^= quickSortNums[pivotIndex];quickSortNums[pivotIndex] ^= quickSortNums[left];quickSortNums[left] ^= quickSortNums[pivotIndex];pivotIndex = left;}}//左右子序列递归排序quick(quickSortNums, start, pivotIndex - 1);quick(quickSortNums, pivotIndex + 1, end);}}

快速排序的时间复杂度为O(NlogN)，其中N为待排序元素的数量

5.归并排序

  归并排序是一种高效的排序算法，它采用分治法的思想。归并排序的基本思想是将待排序序列分成两个较小的子序列，递归地对子序列进行排序，然后将两个有序子序列合并成一个有序序列。以下是归并排序的算法实现步骤：

  1. 分解：将待排序序列递归地分解为两个较小的子序列，直到每个子序列只剩下一个元素或为空
  2. 合并：将两个有序子序列合并成一个有序序列。比较两个子序列的首个元素，将较小的元素放入临时的辅助数组中，并将相应子序列的指针向后移动，重复此过程，直到两个子序列中的元素全部放入辅助数组中
  3. 将辅助数组中的有序序列复制回原始序列的对应位置
  4. 递归地对两个子序列重复上述步骤，直到整个序列排序完成

归并排序

    /*** 归并排序：将数组递归地分成两半，对每个子数组进行排序，然后将两个有序子数组合并成一个有序数组*/public static void mergeSort() {int[] mergeSortNums = nums.clone();merge(mergeSortNums, 0, mergeSortNums.length - 1);System.out.print("归并排序： ");System.out.println(Arrays.toString(mergeSortNums));}/*** 归并排序：将数组递归地分成两半，对每个子数组进行排序，然后将两个有序子数组合并成一个有序数组* @param mergeSortNums 子序列* @param start 子序列起点* @param end 子序列终点*/public static void merge(int[] mergeSortNums, int start, int end) {if (start < end) {int middle = (end - start) / 2 + start;merge(mergeSortNums, start, middle);merge(mergeSortNums, middle + 1, end);//合并两个子序列，暂存到临时数组int num = start;int i = start;int j = middle + 1;int[] temp = new int[mergeSortNums.length];while (i <= middle && j <= end) {if (mergeSortNums[i] <= mergeSortNums[j]) {temp[num++] = mergeSortNums[i++];} else {temp[num++] = mergeSortNums[j++];}}while (i <= middle) {temp[num++] = mergeSortNums[i++];}while (j <= end) {temp[num++] = mergeSortNums[j++];}//拷贝回初始数组System.arraycopy(temp, start, mergeSortNums, start, end - start + 1);}}

归并排序的时间复杂度为O(NlogN)，其中N为待排序元素的数量

6.计数排序

  计数排序是一种非比较的排序算法，它通过统计待排序序列中每个元素出现的次数，进而确定每个元素在有序序列中的位置。计数排序适用于待排序序列中的元素都是非负整数，并且元素的范围相对较小的情况。计数排序的步骤如下：

  1. 找出待排序序列中的最大元素，并确定计数数组的大小。计数数组的大小为最大元素值加1
  2. 统计待排序序列中每个元素出现的次数，并将统计结果存储在计数数组中。计数数组的下标表示元素的值，数组中存储的值表示该元素出现的次数
  3. 对计数数组进行顺序求和操作。将计数数组中的每个元素与前一个元素相加，得到每个元素在有序序列中的最后位置的索引
  4. 创建一个与待排序序列大小相同的辅助数组
  5. 从后往前遍历待排序序列，根据元素的值找到其在计数数组中对应的索引，将元素放入辅助数组中的正确位置
  6. 将辅助数组中的元素复制回原始序列，完成排序。

计数排序

    /*** 计数排序：对每个输入元素进行计数，然后根据计数值的顺序重构有序数组* @param start 数据左起始范围* @param end 数据右起始范围*/public static void countSort(int start, int end) {int[] countSortNums = nums.clone();int[][] numCount = new int[Math.abs(start) + Math.abs(end) + 1][2];//计数int temp = start;for (int i = 0; i < numCount.length; i++) {numCount[i][0] = temp++;}for (int i = 0; i < countSortNums.length; i++) {numCount[countSortNums[i] + Math.abs(start)][1]++;}int index = 0;int indexNum = 0;for (int i = 0; i < numCount.length; i++) {if (numCount[i][1] != 0 && indexNum != 0) {numCount[i][1] += numCount[index][1];index = i;} else if (numCount[i][1] != 0 && indexNum == 0) {indexNum++;index = i;}}//计算排序位置int left = 0;int right = -1;for (int j = 0; j < numCount.length; j++) {if (numCount[j][1] != 0) {right = numCount[j][1];for (int i = left; i < right; i++) {countSortNums[i] = numCount[j][0];}left = right;}}System.out.print("计数排序： ");System.out.println(Arrays.toString(countSortNums));}

三、完整源码

package Yskysoar;import java.util.Arrays;
import java.util.Scanner;/*** @author Yskysoar* @createTime 2023-07-12 19:29* @description 排序算法* 1.所有测试对象为数组、链表或者树，默认为数组* 2.提供用例随机初始化方法* 3.排序结果从小到大排列*/
public class SortAlgorithm {public static int number;//用例数据量public static int[] nums;//用例数组public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.print("请输入数据量，数据起点，数据终点：");number = scanner.nextInt();int start = scanner.nextInt();int end = scanner.nextInt();
//        nums = new int[] {3, 8, 10, 5, 10, 10, 3, 4, 2, 9};initNums(number, start, end);System.out.print("初始数据： ");System.out.println(Arrays.toString(nums));//冒泡排序bubbleSort();//选择排序selectSort();//插入排序insertSort();//快速排序quickSort();//归并排序mergeSort();//计数排序countSort(start, end);}/*** 用例随机初始化* @param number 用例数据量* @param start  用例起始范围* @param end    用例结束范围*/public static void initNums(int number, int start, int end) {nums = new int[number];for (int i = 0; i < nums.length; i++) {nums[i] = (int) (Math.random() * (end - start + 1) + start);}}/*** 冒泡排序:从左到右逐个比较相邻的元素，并进行交换，每一轮将最大的元素移到最右侧*/public static void bubbleSort() {int[] bubbleSortNums = nums.clone();for (int i = 1; i < bubbleSortNums.length; i++) {for (int j = 0; j < bubbleSortNums.length - i; j++) {if (bubbleSortNums[j] > bubbleSortNums[j + 1]) {//已经确保两个数不相同，所以异或不会丢失数据bubbleSortNums[j] ^= bubbleSortNums[j + 1];bubbleSortNums[j + 1] ^= bubbleSortNums[j];bubbleSortNums[j] ^= bubbleSortNums[j + 1];}}}System.out.print("冒泡排序： ");System.out.println(Arrays.toString(bubbleSortNums));}/*** 选择排序:每一轮从未排序的部分选择最小（或最大）的元素，放到已排序部分的末尾*/public static void selectSort() {int[] selectionSortNums = nums.clone();for (int i = 0; i < selectionSortNums.length - 1; i++) {//计数int maxNum = 0;//记录极大值的索引for (int j = 0; j < selectionSortNums.length - i; j++) {if (selectionSortNums[maxNum] < selectionSortNums[j]) {maxNum = j;}}//下面的if是用异或交换元素的重点，防止置0if (maxNum != selectionSortNums.length - i - 1) {//如果已经在对应位置就不需要移动，否则会导致异或同一个变量置0selectionSortNums[maxNum] ^= selectionSortNums[selectionSortNums.length - i - 1];selectionSortNums[selectionSortNums.length - i - 1] ^= selectionSortNums[maxNum];selectionSortNums[maxNum] ^= selectionSortNums[selectionSortNums.length - i - 1];}}System.out.print("选择排序： ");System.out.println(Arrays.toString(selectionSortNums));}/*** 插入排序：逐个将元素插入到已排序的序列中的正确位置，构建最终有序序列*/public static void insertSort() {int[] insertSortNums = nums.clone();int temp = 0;//记录待插入的值int index = 0;//记录插入的位置boolean isFlag;for (int i = 1; i < insertSortNums.length; i++) {isFlag = false;for (int j = 0; j < i; j++) {if (insertSortNums[i] < insertSortNums[j]) {index = j;temp = insertSortNums[i];isFlag = true;break;}}if (isFlag) {//当需要向前插入的时候才执行，否则不用移动/*public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)src:源数组srcPos:源数组要复制的起始位置dest:目的数组destPos:目的数组放置的起始位置length:复制的长度*/System.arraycopy(insertSortNums, index, insertSortNums, index + 1, i - index);
//                for (int j = i; j > index; j--) {
//                    insertSortNums[j] = insertSortNums[j - 1];
//                }insertSortNums[index] = temp;}}System.out.print("插入排序： ");System.out.println(Arrays.toString(insertSortNums));}/*** 快速排序：选择一个基准元素，将数组分为小于基准值和大于基准值的两部分，递归地对这两部分进行排序(默认首元素为基准)*/public static void quickSort() {int[] quickSortNums = nums.clone();quick(quickSortNums, 0, quickSortNums.length - 1);System.out.print("快速排序： ");System.out.println(Arrays.toString(quickSortNums));}/*** 快速排序：选择一个基准元素，将数组分为小于基准值和大于基准值的两部分，递归地对这两部分进行排序(默认首元素为基准)* @param quickSortNums 待排序数组* @param start 左起点* @param end 右起点*/public static void quick(int[] quickSortNums, int start, int end) {if (start < end) {//直到序列内只有一个元素时，无需排序，结束递归int left = start;int right = end;int pivotIndex = start;//基准元素的索引值(选择第一个元素作为基准元素)//寻找基轴位置while (left < right) {//右侧扫描while (left < right && quickSortNums[right] >= quickSortNums[pivotIndex]) {//找到第一个小于基准的元素right--;}//和基轴交换位置if (left < right) {//保证小于基准的元素在右侧quickSortNums[right] ^= quickSortNums[pivotIndex];quickSortNums[pivotIndex] ^= quickSortNums[right];quickSortNums[right] ^= quickSortNums[pivotIndex];pivotIndex = right;}//左侧扫描while (left < right && quickSortNums[left] <= quickSortNums[pivotIndex]) {//找到第一个大于基准的元素left++;}//和基轴交换位置if (left < right) {//保证大于基准的元素在左侧quickSortNums[left] ^= quickSortNums[pivotIndex];quickSortNums[pivotIndex] ^= quickSortNums[left];quickSortNums[left] ^= quickSortNums[pivotIndex];pivotIndex = left;}}//左右子序列递归排序quick(quickSortNums, start, pivotIndex - 1);quick(quickSortNums, pivotIndex + 1, end);}}/*** 归并排序：将数组递归地分成两半，对每个子数组进行排序，然后将两个有序子数组合并成一个有序数组*/public static void mergeSort() {int[] mergeSortNums = nums.clone();merge(mergeSortNums, 0, mergeSortNums.length - 1);System.out.print("归并排序： ");System.out.println(Arrays.toString(mergeSortNums));}/*** 归并排序：将数组递归地分成两半，对每个子数组进行排序，然后将两个有序子数组合并成一个有序数组* @param mergeSortNums 子序列* @param start 子序列起点* @param end 子序列终点*/public static void merge(int[] mergeSortNums, int start, int end) {if (start < end) {int middle = (end - start) / 2 + start;merge(mergeSortNums, start, middle);merge(mergeSortNums, middle + 1, end);//合并两个子序列，暂存到临时数组int num = start;int i = start;int j = middle + 1;int[] temp = new int[mergeSortNums.length];while (i <= middle && j <= end) {if (mergeSortNums[i] <= mergeSortNums[j]) {temp[num++] = mergeSortNums[i++];} else {temp[num++] = mergeSortNums[j++];}}while (i <= middle) {temp[num++] = mergeSortNums[i++];}while (j <= end) {temp[num++] = mergeSortNums[j++];}//拷贝回初始数组System.arraycopy(temp, start, mergeSortNums, start, end - start + 1);}}/*** 计数排序：对每个输入元素进行计数，然后根据计数值的顺序重构有序数组* @param start 数据左起始范围* @param end 数据右起始范围*/public static void countSort(int start, int end) {int[] countSortNums = nums.clone();int[][] numCount = new int[Math.abs(start) + Math.abs(end) + 1][2];//计数int temp = start;for (int i = 0; i < numCount.length; i++) {numCount[i][0] = temp++;}for (int i = 0; i < countSortNums.length; i++) {numCount[countSortNums[i] + Math.abs(start)][1]++;}int index = 0;int indexNum = 0;for (int i = 0; i < numCount.length; i++) {if (numCount[i][1] != 0 && indexNum != 0) {numCount[i][1] += numCount[index][1];index = i;} else if (numCount[i][1] != 0 && indexNum == 0) {indexNum++;index = i;}}//计算排序位置int left = 0;int right = -1;for (int j = 0; j < numCount.length; j++) {if (numCount[j][1] != 0) {right = numCount[j][1];for (int i = left; i < right; i++) {countSortNums[i] = numCount[j][0];}left = right;}}System.out.print("计数排序： ");System.out.println(Arrays.toString(countSortNums));}
}

本人技术水平一般，各位大佬如果发现我的不足之处或者有好的建议可以指出，谢谢大家

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

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

相关文章

【iOS】对象的本质探索

【iOS】对象的本质探索

OC对象的底层结构 问题&#xff1a;一个NSObject对象在内存中是如何布局的&#xff1f;NSObject的内存布局1 通过 lldb命令 窥探NSObject内存布局2 通过 View Memory 窥探NSObject内存布局3 通过 底层函数API 窥探NSObject内存布局总结 通过继承关系进一步了解NSObject1 运行项…
阅读更多...
智慧数据驱动：基于smardaten构建多维数据可视化大屏

智慧数据驱动：基于smardaten构建多维数据可视化大屏

&#x1f935;‍♂️ 个人主页&#xff1a;艾派森的个人主页 ✍&#x1f3fb;作者简介&#xff1a;Python学习者 &#x1f40b; 希望大家多多支持&#xff0c;我们一起进步&#xff01;&#x1f604; 如果文章对你有帮助的话&#xff0c; 欢迎评论 &#x1f4ac;点赞&#x1f4…
阅读更多...
【DC-DC】APS54083 降压恒流驱动器大功率深度调光 舞台 RGB 汽车照明 台灯驱动芯片

【DC-DC】APS54083 降压恒流驱动器大功率深度调光 舞台 RGB 汽车照明 台灯驱动芯片

产品描述 APS54083 是一款 PWM 工作模式,高效率、外围简单、外置功率 MOS 管&#xff0c;适用于 5-220V 输入高精度降压 LED 恒流驱动芯片。输出最大功率150W最大电流 6A。APS54083 可实现线性调光和 PWM 调光&#xff0c;线性调光脚有效电压范围 0.5-2.5V.PWM 调光频率范围 1…
阅读更多...
算法训练营第四十三天||● 1049. 最后一块石头的重量 II ● 494. 目标和 ● 474.一和零

算法训练营第四十三天||● 1049. 最后一块石头的重量 II ● 494. 目标和 ● 474.一和零

● 1049. 最后一块石头的重量 II 这道题和昨天的分割等和子集一样&#xff0c;只是最后返回值不一样 class Solution { public:int lastStoneWeightII(vector<int>& stones) {int sum 0;for(int i 0;i<stones.size();i){sum stones[i];}int target sum / 2;…
阅读更多...
喝汽水问题:1瓶汽水1元。2个空瓶可以换1瓶汽水，给20元，可以买多少汽水 （7.19）

喝汽水问题:1瓶汽水1元。2个空瓶可以换1瓶汽水，给20元，可以买多少汽水 （7.19）

泪目&#xff01;&#xff01;&#xff01;终于是自己完完整整写出的代码了&#xff0c;不翻资料也没看参考代码 &#xff08;之前的要么和老师练习&#xff0c;要么找教材东拼西凑&#xff09; 方法2&#xff1a;数学角度看bottle价值0.5 元&#xff0c;20元最多可换40bottl…
阅读更多...
docker服务启动过程分析

docker服务启动过程分析

How docker.service start&#xff1f; just by ref 我们先了解docker的各个核心组件的介绍 runc&#xff1a;runc实现了容器的底层功能&#xff0c;例如创建、运行等。runc通过调用内核接口为容器创建和管理cgroup、namespace等Linux内核功能&#xff0c;来实现容器的核心特…
阅读更多...
vuecli5.x 配置图片输出为base64

vuecli5.x 配置图片输出为base64

解释&#xff1a;webpack的默认配置是小于一定的文件大小就要将图片转为base64, 所以尽量将这个阈值调大你的图片就可以转为base64; 当然这种做法不好, 会导致代码文件变大, 不过为了满足需求也没得办法。这年头大家都用 vite 了, 网上没有 vuecli5.x 这方面的记录, 写篇文章记…
阅读更多...
Halcon 深度学习初探

Halcon 深度学习初探

什么是深度学习&#xff1f; 深度学习是一系列机器学习的方法集合&#xff0c;其算法结构类似于多层级的神经网络。通过对大量的训练样本图像的学习&#xff0c;提取其各个层次的特征&#xff0c;使网络具有判别和推理能力。 关于halcon中的深度学习&#xff1a; 自halcon17…
阅读更多...
【C语言】文件操作

【C语言】文件操作

目录 前言&#xff1a; 一、为什么使用文件 二、什么是文件 &#xff08;一&#xff09;程序文件 &#xff08;二&#xff09;数据文件 &#xff08;三&#xff09;文件名 三、文件的打开和关闭 &#xff08;一&#xff09;文件指针 &#xff08;二&#xff09;文件的…
阅读更多...
基于VUE的音乐qq网站设计与实现（Java+spring boot+MySQL+VUE）

基于VUE的音乐qq网站设计与实现（Java+spring boot+MySQL+VUE）

获取源码或者论文请私信博主 演示视频&#xff1a; 基于VUE的音乐qq网站设计与实现&#xff08;Javaspring bootMySQLVUE&#xff09; 使用技术&#xff1a; 前端&#xff1a;html css javascript jQuery ajax thymeleaf 微信小程序 后端&#xff1a;Java springboot框架 my…
阅读更多...
东莞-戴尔R540服务器故障告警处理方法

东莞-戴尔R540服务器故障告警处理方法

DELL PowerEdge R540服务器故障维修案例&#xff1a;&#xff08;看到文章就是缘分&#xff09; 客户名称&#xff1a;东莞市某街道管理中心 故障机型&#xff1a;DELL R540服务器 故障问题&#xff1a;DELL R540服务器无法开机&#xff0c;前面板亮黄灯&#xff0c;工程师通过…
阅读更多...
功能丰富的 Markdown 笔记工具:FSNotes Mac中文版图文安装教程

功能丰富的 Markdown 笔记工具:FSNotes Mac中文版图文安装教程

FSNotes Mac版是Mac平台上一款纯文本笔记本管理器&#xff0c;FSNotes for mac中文版支持Markdown、RTF等格式&#xff0c;轻松查看和编辑数据&#xff0c;还可以将数据存储在文件系统中&#xff0c;同时具备iCloud同步功能&#xff0c;使用非常便捷。 FSNotes for mac官方介绍…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023