【数据结构—排序—交换排序】

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言

一、排序的概念及其运用

1、排序的概念

2、排序运用

3、 常见的排序算法

二、交换排序

1、冒泡排序

1.1算法讲解

1.2冒泡排序的实现：

1.2.1头文件的实现—(Sort.h)

1.2.2源文件的实现—(Sort.c)

1.2.3测试文件的实现—(test.c)

1.2.4数据测试展示

2、快速排序

2.1算法讲解

2.2各大算法的代码实现

2.2.1快速排序hoare版本

2.2.2快速排序hoare改进版三数取中选key法

2.2.3快速排序hoare版本改进版小区间优化法

2.2.4快速排序挖坑法（快速排序的单躺排序）

2.2.5快速排序前后指针（快速排序的单躺排序）

2.2.6快速排序非递归版

总结

前言

世上有两种耀眼的光芒，一种是正在升起的太阳，一种是正在努力学习编程的你!一个爱学编程的人。各位看官，我衷心的希望这篇博客能对你们有所帮助，同时也希望各位看官能对我的文章给与点评，希望我们能够携手共同促进进步，在编程的道路上越走越远！

提示：以下是本篇文章正文内容，下面案例可供参考

一、排序的概念及其运用

1、排序的概念

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

稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

2、排序运用

3、 常见的排序算法

二、交换排序

基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

1、冒泡排序

1.1算法讲解

以下是冒泡排序的动图，想具体了解冒泡排序，请点击这里！

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

1.2冒泡排序的实现：

1.2.1头文件的实现—(Sort.h)
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
#include <time.h>//打印数组
void PrintArray(int* a, int n);//插入排序(最坏的情况下：逆序，才是等差数列)
void InsertSort(int* a, int n);
//冒泡排序(等差数列)
void BubbleSort(int* a, int n);//希尔排序
void ShellSort(int* a, int n);//选择排序
void SelectSort(int* a, int n);
//快速排序(有序的情况下，快速排序会很吃亏)
void QuickSort(int* a, int begin, int end);//快速排序非递归
void QuickSortNonR(int* a, int begin, int end);
1.2.2源文件的实现—(Sort.c)
#define _CRT_SECURE_NO_WARNINGS 1
#include"Sort.h"
#include"Stack.h"//打印数组
void PrintArray(int* a, int n)
{for (int i = 0; i < n; i++){printf("%d ", a[i]);}printf("\n");
}//交换
void Swap(int* p1, int* p2)
{int tmp = *p1;*p1 = *p2;*p2 = tmp;
}//冒泡排序
void BubbleSort(int* a, int n)
{for (int j = 0; j < n; j++){bool exchange = false;//单趟for (int i = 1; i < n-j; i++){if (a[i - 1] > a[i]){Swap(&a[i - 1], &a[i]);exchange = true;}			}if (exchange == false)break;}
}
1.2.3测试文件的实现—(test.c)
#define _CRT_SECURE_NO_WARNINGS 1
#include"Sort.h"void TestBubbleSort()
{int a[] = { 3,2,6,8,4,6,0,9,5,1,7 };BubbleSort(a, sizeof(a) / sizeof(int));PrintArray(a, sizeof(a) / sizeof(int));
}int main()
{//TestInsertSort();TestBubbleSort();//TestShellSort();//TestSelectSort();//TestQuickSort();//TestOP();return 0;
}
1.2.4数据测试展示

2、快速排序

2.1算法讲解

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

1. hoare版本

对于快速排序来说有两个优化方法。（三数取中、小区间优化）

对于快速排序的单趟排序有三种方法。(hoare、挖坑法、前后指针法)

对于快速排序的实现有两种方法：递归和非递归（用栈实现）

2.2各大算法的代码实现

2.2.1快速排序hoare版本
Sort.h
//快速排序hoare版本(如果左边有序，右边也有序，那么整体就有序)
//闭区间【begin,end】
void QuickSort(int* a, int begin, int end);
Sort.c
//打印数组
void PrintArray(int* a, int n)
{for (int i = 0; i < n; i++){printf("%d ", a[i]);}printf("\n");
}//交换
void Swap(int* p1, int* p2)
{int tmp = *p1;*p1 = *p2;*p2 = tmp;
}//快速排序hoare版本(如果左边有序，右边也有序，那么整体就有序)
//闭区间【begin,end】
void QuickSort(int* a, int begin, int end)
{//当只剩最后一个数的时候就排序成功了 和 右区间不存在的时候if (begin >= end)return;int left = begin, right = end;//left:必须要初始化成begin,不能初始化成begin+1int keyi = begin;//key一般取最左边的数值，记录keyi所在位置的下标//为什么要记录keyi下标所在的位置？//是因为keyi是局部变量，我们期望的是数组中的值进行交换，而不是数组中的值与局部变量的值进行交换//单趟排序while (left < right){//右边找小while (left < right && a[right] >= a[keyi]){//加入left < right的条件是为了防止left和right停不下来right--;}//左边找大while (left < right && a[left] <= a[keyi]){left++;}Swap(&a[left], &a[right]);}//左右两边相遇的时候，所对应的值一定比keyi小，为什么呢？因为右边先走Swap(&a[left], &a[keyi]);keyi = left;//left == right,此时左右两边相遇//【begin,keyi-1】 keyi 【keyi+1,end】//      左边       keyi       右边//递归QuickSort(a, begin, keyi - 1);QuickSort(a, keyi + 1, end);}

左右两边相遇的时候，所对应的值一定比keyi小，为什么呢？因为右边先走

2.2.2快速排序hoare改进版三数取中选key法

快速排序：有序的情况下，快速排序会很吃亏，比插入都慢，为什么呢？
因为我们在这使用了一个固定选keyi，比如：在升序的情况下，还要排升序，右边找小，左边找大，因为开始是升序的，所以右边找小找不到，所以keyi只能自己跟自己交换。

正常情况下，快排的时间复杂度：近似认为每一层都是O(N)，所以是O(N^2)。

快排最理想的情况下，每次选keyi，都是二分，类似于递归（根、左子树、右子树）那么时间复杂度：近似的认为每一层都是O(N),总共右LogN层，合计O(N*LogN)

快排有两种优化的方法：

优化一：三数取中法选key
左边、右边和中间下标所对应的数值，三数值取中，去选不是最大，也不是最小的那个数值作keyi。

优化二：小区间优化

递归有一个问题：如果是满二叉树的最后一层占%50的节点，倒数第二层占%25的节点，倒数第三层占%12.5的节点快排这里用递归的话，当区间的数据量小于一定程度后，我们在这里就可以不用递归了，一般到最后3到4层后，我们用插入排序，因为最后三层占据了%87.5的递归。（不过这种优化一般效果几乎没有）

Sort.h
//快速排序hoare改进版三数取中选key法(如果左边有序，右边也有序，那么整体就有序)
//闭区间【begin,end】
void QuickSort(int* a, int begin, int end);
Sort.c
//打印数组
void PrintArray(int* a, int n)
{for (int i = 0; i < n; i++){printf("%d ", a[i]);}printf("\n");
}//交换
void Swap(int* p1, int* p2)
{int tmp = *p1;*p1 = *p2;*p2 = tmp;
}//优化一：三数取中：左边、右边和中间下标所对应的数值，三数值取中，去选不是最大，也不是最小的那个数值作keyi
int GetMidi(int* a, int begin, int end)
{//如果是有序的情况下，就从最坏变成最好了int midi = (begin + end) / 2;//如果是无序的情况下if (a[begin] < a[midi]){if (a[midi] < a[end])return midi;else if (a[begin] > a[end])return begin;elsereturn end;}else  //a[begin] > a[midi]{if (a[midi] > a[end])return midi;else if (a[begin] < a[end])return begin;elsereturn end;}
}//快速排序hoare改进版三数取中选key法(如果左边有序，右边也有序，那么整体就有序)
//闭区间【begin,end】
void QuickSort(int* a, int begin, int end)
{//当只剩最后一个数的时候就排序成功了 和 右区间不存在的时候if (begin >= end)return;//优化一：三数取中int midi = GetMidi(a, begin, end);Swap(&a[midi], &a[begin]);int left = begin, right = end;//left:必须要初始化成begin,不能初始化成begin+1int keyi = begin;//key一般取最左边的数值，记录keyi所在位置的下标//为什么要记录keyi下标所在的位置？//是因为keyi是局部变量，我们期望的是数组中的值进行交换，而不是数组中的值与局部变量的值进行交换while (left < right){//右边找小while (left < right && a[right] >= a[keyi]){//加入left < right的条件是为了防止left和right停不下来right--;}//左边找大while (left < right && a[left] <= a[keyi]){left++;}Swap(&a[left], &a[right]);}//左右两边相遇的时候，所对应的值一定比keyi小，为什么呢？因为右边先走Swap(&a[left], &a[keyi]);keyi = left;//left == right,此时左右两边相遇//【begin,keyi-1】 keyi 【keyi+1,end】//      左边       keyi       右边//递归QuickSort(a, begin, keyi - 1);QuickSort(a, keyi + 1, end);}
2.2.3快速排序hoare版本改进版小区间优化法
Sort.h
//快速排序hoare版本(如果左边有序，右边也有序，那么整体就有序)
//闭区间【begin,end】
void QuickSort(int* a, int begin, int end);
Sort.c
//打印数组
void PrintArray(int* a, int n)
{for (int i = 0; i < n; i++){printf("%d ", a[i]);}printf("\n");
}//交换
void Swap(int* p1, int* p2)
{int tmp = *p1;*p1 = *p2;*p2 = tmp;
}//优化一：三数取中：左边、右边和中间下标所对应的数值，三数值取中，去选不是最大，也不是最小的那个数值作keyi
int GetMidi(int* a, int begin, int end)
{//如果是有序的情况下，就从最坏变成最好了int midi = (begin + end) / 2;//如果是无序的情况下if (a[begin] < a[midi]){if (a[midi] < a[end])return midi;else if (a[begin] > a[end])return begin;elsereturn end;}else  //a[begin] > a[midi]{if (a[midi] > a[end])return midi;else if (a[begin] < a[end])return begin;elsereturn end;}
}//快速排序hoare版本(如果左边有序，右边也有序，那么整体就有序)
//闭区间【begin,end】
void QuickSort(int* a, int begin, int end)
{//当只剩最后一个数的时候就排序成功了 和 右区间不存在的时候if (begin >= end)return;//优化二：小区间优化if (end - begin + 1 <= 10){InsertSort(a+begin, end - begin + 1);//插入排序是：从a+begin的位置开始到end-begin+1的区间开始排序//因为递归(根、左右子树)的原因，插入排序的起始位置不一定是从a开始的。}else{//优化一：三数取中int midi = GetMidi(a, begin, end);Swap(&a[midi], &a[begin]);int left = begin, right = end;//left:必须要初始化成begin,不能初始化成begin+1int keyi = begin;//key一般取最左边的数值，记录keyi所在位置的下标//为什么要记录keyi下标所在的位置？//是因为keyi是局部变量，我们期望的是数组中的值进行交换，而不是数组中的值与局部变量的值进行交换while (left < right){//右边找小while (left < right && a[right] >= a[keyi]){//加入left < right的条件是为了防止left和right停不下来right--;}//左边找大while (left < right && a[left] <= a[keyi]){left++;}Swap(&a[left], &a[right]);}//左右两边相遇的时候，所对应的值一定比keyi小，为什么呢？因为右边先走Swap(&a[left], &a[keyi]);keyi = left;//left == right,此时左右两边相遇//【begin,keyi-1】 keyi 【keyi+1,end】//      左边       keyi       右边//递归QuickSort(a, begin, keyi - 1);QuickSort(a, keyi + 1, end);}
}
2.2.4快速排序挖坑法（快速排序的单躺排序）

Sort.h
//快速排序挖坑法
void QuickSort1(int* a, int begin, int end);
Sort.c
//打印数组
void PrintArray(int* a, int n)
{for (int i = 0; i < n; i++){printf("%d ", a[i]);}printf("\n");
}//交换
void Swap(int* p1, int* p2)
{int tmp = *p1;*p1 = *p2;*p2 = tmp;
}//挖坑法(单趟)
int PartSort1(int* a, int begin, int end)
{//三数取中int midi = GetMidi(a, begin, end);Swap(&a[midi], &a[begin]);int key = a[begin];int holei = begin;while (begin < end){//右边找小，填左边的坑while (begin < end && a[end] >= key){--end;}a[holei] = a[end];holei = end;//左边找大，填到右边的坑while (begin < end && a[begin] <= key){begin++;}a[holei] = a[begin];holei = begin;}a[holei] = key;return holei;
}//快速排序挖坑法
void QuickSort1(int* a, int begin, int end)
{//当只剩最后一个数的时候就排序成功了 和 右区间不存在的时候if (begin >= end)return;int keyi = PartSort1(a, begin, end);//单趟QuickSort1(a, begin, keyi - 1);QuickSort1(a, keyi + 1, end);
}
2.2.5快速排序前后指针（快速排序的单躺排序）

Sort.h
//快速排序前后指针版本
void QuickSort2(int* a, int begin, int end);
Sort.c
void Swap(int* p1, int* p2)
{int tmp = *p1;*p1 = *p2;*p2 = tmp;
}//前后指针版本
int PartSort2(int* a, int begin, int end)
{//三数取中int midi = GetMidi(a, begin, end);Swap(&a[midi], &a[begin]);int keyi = begin;int prev = begin;int cur = prev + 1;while (cur <= end){//cur找小if (a[cur] < a[keyi]){prev++;Swap(&a[prev], &a[cur]);}cur++;}Swap(&a[prev], &a[keyi]);keyi = prev;return keyi;
}//快速排序前后指针版本
void QuickSort2(int* a, int begin, int end)
{//当只剩最后一个数的时候就排序成功了 和 右区间不存在的时候if (begin >= end)return;int keyi = PartSort2(a, begin, end);//单趟QuickSort2(a, begin, keyi - 1);QuickSort2(a, keyi + 1, end);
}
2.2.6快速排序非递归版

递归->非递归
1、循环
2、借助栈(后进先出)，改循环（栈里面存两个值，也就是栈里面存整个区间，比如：栈存0~9，0~9出栈，出来以后进行单趟排序，key在5的位置，分成两个子区间；栈里面存6~9和0~4，取出0~4，进行单趟排序，key在2的位置，分成3~4和0~1两个子区间入栈；0~1出栈，分成0~0和2~1两个子区间，这只剩下一个值了，可以不入栈，不进行处理；以此类推）

Stack.h
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>typedef int STDataType;
typedef struct stack
{STDataType* a;int top;//标识栈顶的位置int capacity;
}ST;//初始化
void STInit(ST* pst);
//销毁
void STDestory(ST* pst);//压栈
void STPush(ST* pst, STDataType x);
//出栈
void STPop(ST* pst);//获取栈顶元素
STDataType STTop(ST* pst);//判空
bool STEmpty(ST* pst);//统计栈内元素个数
int STSize(ST* pst);
Stack.c
#define _CRT_SECURE_NO_WARNINGS 1
#include "Stack.h"//初始化
void STInit(ST* pst)
{assert(pst);pst->a = NULL;//表示top指向栈顶元素的下一个位置pst->top = 0;//表示top指向栈顶元素//pst->top = -1;pst->capacity = 0;
}
//销毁
void STDestory(ST* pst)
{assert(pst);free(pst->a);pst->a = NULL;pst->capacity = pst->top = 0;
}//压栈
void STPush(ST* pst, STDataType x)
{assert(pst);//判断数组栈空间是否足够if (pst->top == pst->capacity){int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;STDataType* tmp = (STDataType*)realloc(pst->a, sizeof(STDataType) * newcapacity);if (tmp == NULL){perror("realloc fail");return;}pst->a = tmp;pst->capacity = newcapacity;}pst->a[pst->top] = x;pst->top++;
}
//出栈
void STPop(ST* pst)
{assert(pst);assert(pst->top > 0);pst->top--;
}//获取栈顶元素
STDataType STTop(ST* pst)
{assert(pst);assert(pst->top > 0);return pst->a[pst->top - 1];
}//判空
bool STEmpty(ST* pst)
{assert(pst);//判断数组栈为空//1、如果top是指向栈顶元素的下一个位置，那当top == 0时，栈为空//2、如果top时指向栈顶元素，那当top == -1时，栈为空/*if (pst->top == 0){return true;}else{return false;}*/return pst->top == 0;
}//统计栈内元素个数
int STSize(ST* pst)
{assert(pst);//1、如果top指向栈顶元素的话，栈内元素的个数为top+1；//2、如果top指向栈顶元素的下一个位置的话，栈内元素的个数为top；return pst->top;
}
Sort.h
//快速排序非递归
void QuickSortNonR(int* a, int begin, int end);

Sort.c
/快速排序非递归
//考察非递归的两种意义：1、有没有掌握快排；2、递归理解深不深刻
void QuickSortNonR(int* a, int begin, int end)
{ST s;STInit(&s);STPush(&s, end);STPush(&s, begin);while (!STEmpty(&s)){int left = STTop(&s);STPop(&s);int right = STTop(&s);STPop(&s);int keyi = PartSort2(a, left, right);//[left,keyi-1] keyi [keyi+1,right]if (left < keyi - 1)//不加等于号是等剩下一个值的时候，就不进栈了{//跟前面保持一直，先右后左STPush(&s, keyi - 1);STPush(&s, left);}if (keyi + 1 < right){STPush(&s, right);STPush(&s, keyi + 1);}}STDestory(&s);
}

总结

好了，本篇博客到这里就结束了，如果有更好的观点，请及时留言，我会认真观看并学习。
不积硅步，无以至千里；不积小流，无以成江海。

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

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

相关文章

web前端开发技术复习问答题

web前端开发技术复习问答题

目录 1.简述常见单标签和双标签有哪些&#xff1f; 2.常见块级元素和行级元素有哪些&#xff1f; 3.简述常见的列表有哪些&#xff1f;他们有什么区别&#xff1f; 4.简述超链接的href属性值如何设置&#xff1f;有什么区别 5.CSS基本语法 6. css中常见的引入方式有几种&…
阅读更多...
找不到模块 “path“ 或其相对应的类型声明

找不到模块 “path“ 或其相对应的类型声明

src别名的配置 在开发项目的时候文件与文件关系可能很复杂&#xff0c;因此我们需要给src文件夹配置一个别名 // vite.config.ts import {defineConfig} from vite import vue from vitejs/plugin-vue import path from path export default defineConfig({plugins: [vue()],r…
阅读更多...
程序员做私活赚外快的好地方，今天推荐几个

程序员做私活赚外快的好地方，今天推荐几个

你们当程序员不会都拿着几千、万把块钱的死工资吧&#xff0c;今天为大家分享一些可以接私单的平台&#xff0c;我反正已经赚麻了。 如果你的工作相对没那么费时间&#xff0c;可以空闲的时候去接点私活。或者是还没有找工作之前&#xff0c;可以通过一些平台接一些兼职&#…
阅读更多...
【STM32】PWR电源控制

【STM32】PWR电源控制

1 PWR简介 PWR&#xff08;Power Control&#xff09;电源控制 PWR负责管理STM32内部的电源供电部分&#xff0c;可以实现可编程电压监测器和低功耗模式的功能 可编程电压监测器&#xff08;PVD&#xff09;可以监控VDD电源电压&#xff0c;当VDD下降到PVD阀值以下或上升到P…
阅读更多...
167. 木棒(dfs剪枝，经典题）

167. 木棒(dfs剪枝，经典题）

167. 木棒 - AcWing题库 乔治拿来一组等长的木棒&#xff0c;将它们随机地砍断&#xff0c;使得每一节木棍的长度都不超过 50 个长度单位。 然后他又想把这些木棍恢复到为裁截前的状态&#xff0c;但忘记了初始时有多少木棒以及木棒的初始长度。 请你设计一个程序&#xff0…
阅读更多...
回首2023，厉兵秣马，启航2024

回首2023，厉兵秣马，启航2024

目录 回首风波的20232023&#xff0c;感恩相遇暂停发文发文狂潮感恩有你备战2024学习之余跆拳道比赛做手工diy 学习心路年初学习伊始心路其后学习后来心路 必须看配图说明 未知的2024Flag 回首风波的2023 2023&#xff0c;感恩相遇 还记得&#xff0c;22年末&#xff0c;23年…
阅读更多...
基于gitlab 12.8.0版本的完整镜像过程

基于gitlab 12.8.0版本的完整镜像过程

目前已在一台服务器上安装了gitlab 12.8.0&#xff0c;并且稳定运行了有几年了&#xff0c;其上面也创建了大量的项目。目前要求对该gitlab及其上面的所有仓库做一个完整的镜像。具体操作过程如下&#xff1a; 1、确认现有的gitlab的版本号 2、到gitlab官网下载相同版本号的gi…
阅读更多...
GitLab添加SSH key

GitLab添加SSH key

SSH 为 Secure Shell 的缩写&#xff0c;SSH 为建立在应用层基础上的安全协议。 SSH 是目前较可靠&#xff0c;专为远程登录会话和其他网络服务提供安全性的协议。 利用 SSH 协议可以有效防止远程管理过程中的信息泄露问题。 ssh-keygen 从客户端来看&#xff0c;SSH提供两种级…
阅读更多...
线程间的通信方式

线程间的通信方式

线程间通信是多线程编程中非常重要的⼀个概念。在多线程编程中&#xff0c;有时候需要让线程之间进⾏数据交换、协作⼯ 作。以下是几种线程间通信的方式&#xff1a; 共享内存&#xff1a;线程之间通过访问同⼀块共享内存区域来实现数据交换 消息队列&#xff1a;⼀个线程向消…
阅读更多...
寒假刷题记录，第一天（重刷题目）

寒假刷题记录，第一天（重刷题目）

PTA甲级&#xff1a; 1003 Emergency 经典迪杰斯特拉算法 #include<iostream> #include<cstring>using namespace std;const int N 510 , INF 0x3f3f3f3f; int dist[N] , cnt[N] , g[N][N]; int helper[N] , way[N]; bool st[N]; int n , m , c1 , c2;int mai…
阅读更多...
Triple Fault的捕获与处理

Triple Fault的捕获与处理

前面有文章说Triple Fault无法捕获&#xff0c;经过几天资料搜寻&#xff0c;对于这个问题还是有办法的。如果可以&#xff0c;对于捕获Triple Fault&#xff0c;最简便的方法就是使用虚拟机来进行操作&#xff0c;这样在发生Triple Fault时影响的只是虚拟机&#xff0c;在host…
阅读更多...
优化Vue首页加载速度的实用方法

优化Vue首页加载速度的实用方法

引言&#xff1a; Vue.js是一种流行的前端开发框架&#xff0c;但在实际应用中&#xff0c;有时会遇到Vue首页加载慢的问题。由于首页是用户首次接触到网站或应用的页面&#xff0c;加载速度对用户体验至关重要。本文将深入探讨如何优化Vue首页的加载速度&#xff0c;提供实用方…
阅读更多...
Vue2和Vue3各自的优缺点以及区别对比

Vue2和Vue3各自的优缺点以及区别对比

Vue2和Vue3各自的优缺点以及区别对比 Vue2的优点&#xff1a; 成熟稳定&#xff1a;Vue2是一个经过长时间发展和测试的成熟版本&#xff0c;广泛应用于各种项目中。 生态系统丰富&#xff1a;由于Vue2的流行程度&#xff0c;它的生态系统相对较为完善&#xff0c;有大量的插件…
阅读更多...
【信息论与编码】习题-判断题-第三部分

【信息论与编码】习题-判断题-第三部分

目录 判断题48. 利用状态极限稳态分布概率和符号的状态一步转移概率来求m阶马尔可夫信源的极限熵。49. 连续信源或模拟信号的信源编码的理论基础是限失真信源编码定理 。50. 具有一一对应关系的无噪信道的信道容量CH(X)。51. 在游程编码过程中&#xff0c;“0”游程和“1”游程…
阅读更多...
使用pytorch构建图卷积网络预测化学分子性质

使用pytorch构建图卷积网络预测化学分子性质

在本文中&#xff0c;我们将通过化学的视角探索图卷积网络&#xff0c;我们将尝试将网络的特征与自然科学中的传统模型进行比较&#xff0c;并思考为什么它的工作效果要比传统的方法好。 图和图神经网络 化学或物理中的模型通常是一个连续函数&#xff0c;例如yf(x₁&#xff…
阅读更多...
定展中2024上海国际智慧工地展览会

定展中2024上海国际智慧工地展览会

2024第十五届上海国际智慧工地展览会 2024 Shanghai International Smart Site Equipment Expo 时间&#xff1a;2024年03月26日-28日 地点&#xff1a;上海跨国采购会展中心 政策指导: 中华人民共和国国家发展和改革委员会 中华人民共和国工业和信息化部 上海城市数字转型应用…
阅读更多...
企业级 npm 私有仓库部署方案

企业级 npm 私有仓库部署方案

本文作者系360奇舞团前端开发工程师 淘宝 NPM 镜像站切换新域名时&#xff0c;放了一张知乎博主天猪的图片&#xff0c;如下&#xff1a; _图片来源&#xff1a;https://zhuanlan.zhihu.com/p/432578145 看着逐年增长的访问量&#xff0c;不禁让人感慨&#xff0c;npm 的出现&a…
阅读更多...
python爬虫实现获取招聘信息

python爬虫实现获取招聘信息

使用的python版本&#xff1a; 3.12.1 selenium版本&#xff1a;4.8.0 urllib版本&#xff1a;1.26.18 from selenium import webdriver from selenium.webdriver import ActionChains import timeimport re import xlwt import urllib.parsedef get_html(url):chrome_drive…
阅读更多...
系列十三、查询数据库中某个库、表、索引等所占空间的大小

系列十三、查询数据库中某个库、表、索引等所占空间的大小

一、information_schema数据库 1.1、概述 information_schema数据库是MySQL出厂默认带的一个数据库&#xff0c;不管我们是在Linux中安装MySQL还是在Windows中安装MySQL&#xff0c;安装好后都会有一个数据库information_schema&#xff0c;这个库中存放了其他库的所有信息。 …
阅读更多...
【数据结构】队列

【数据结构】队列

简单不先于复杂&#xff0c;而是在复杂之后。 文章目录 1. 队列1.1 队列的概念及结构1.2 队列的实现 2.栈和队列面试题3.概念选择题 1. 队列 1.1 队列的概念及结构 队列&#xff1a;只允许在一端进行插入数据操作&#xff0c;在另一端进行删除数据操作的特殊线性表&#xff0c…
阅读更多...
最新文章

Copyright @ 2022~2023