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

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

  • 一.交换排序
    • 1.基本思想
    • 2.冒泡排序
      • 2.1.算法讲解
      • 2.2.代码实现
        • 2.2.1.函数定义
        • 2.2.2.算法接口实现
        • 2.2.3.测试代码实现
        • 2.2.4.测试展示
    • 3.快速排序
      • 3.1.算法讲解
      • 3.2.各大算法分别单独实现
        • 3.2.1快速排序hoare版本
        • 3.2.2.快速排序hoare改进版三数取中选key法
        • 3.2.3.快速排序hoare版本改进版小区间优化法
        • 3.2.4.快速排序挖坑法
        • 3.2.5.快速排序双指针法
        • 3.2.6.快速排序非递归版
      • 3.3.算法完整源码分享
        • 3.3.1函数定义
        • 3.3.2.算法接口实现
        • 3.3.3.测试代码实现
        • 3.3.4.测试展示

一.交换排序

1.基本思想

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

2.冒泡排序

2.1.算法讲解

以下只讲解冒泡排序代码的简单实现 ，想要更详细的了解冒泡排序的可以前往我之前的博客冒泡排序及其优化 （点击即可跳转），里面详细讲解了冒泡排序及其优化。

在这里插入图片描述

冒泡排序的特性总结：

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

2.2.代码实现

2.2.1.函数定义
Sort.h

#pragma once#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
#include<string.h>
#include<time.h>//打印
void PrintArray(int* a, int n);
//冒泡排序
void BublleSort(int* a, int n);
2.2.2.算法接口实现
Sort.c

#include"Sort.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 BublleSort(int* a, int n)
{for (int i = 0; i < n - 1; i++){int flag = 1;for (int j = 0; j < n - i - 1; j++){if (a[j + 1] < a[j]){Swap(&a[j + 1], &a[j]);flag = 0;}}if (flag == 1)break;}
}
2.2.3.测试代码实现
test.c

#include"Sort.h"void TestBublleSort()
{int a[] = { 2,4,5,7,8,0,9,6,3,1 };printf("排序前：");PrintArray(a, sizeof(a) / sizeof(int));printf("\n");printf("冒泡排序：");BublleSort(a, sizeof(a) / sizeof(int));PrintArray(a, sizeof(a) / sizeof(int));
}int main()
{TestBublleSort();return 0;
}
2.2.4.测试展示

在这里插入图片描述

3.快速排序

3.1.算法讲解

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

快速排序递归实现的主框架，发现与二叉树前序遍历规则非常像，在写递归框架时可想想二叉树前序遍历规则即可快速写出来，后序只需分析如何按照基准值来对区间中数据进行划分的方式即可。

将区间按照基准值划分为左右两半部分的常见方式有：
1. hoare版本

在这里插入图片描述
2.hoare改进版
1. 三数取中法选key
2. 递归到小的子区间时，可以考虑使用插入排序
3.挖坑法
在这里插入图片描述
4.前后指针版本
在这里插入图片描述
5.非递归版
非递归需要借助栈来实现，将大区间划分成子区间的递归过程，需要循环实现，如果有小伙伴不懂栈的实现和使用，可以前往我之前的博客数据结构—— 栈的实现（数组栈）（点击即可跳转）了解栈的相关只是。
在这里插入图片描述

快速排序的特性总结：

  1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
  2. 时间复杂度：O(N*logN)
    在这里插入图片描述
  3. 空间复杂度：O(logN)
  4. 稳定性：不稳定

3.2.各大算法分别单独实现

3.2.1快速排序hoare版本
Sort.h

//快速排序hoare版本
void QuickSortHoare(int* a, int begin, int end);

Sort.c

void Swap(int* p1, int* p2)
{int tmp = *p1;*p1 = *p2;*p2 = tmp;
}
//快速排序hoare版本
void QuickSortHoare(int* a, int begin, int end)
{if (begin >= end)return;int left = begin, right = end;int keyi = begin;while (left < right){while (left < right && a[right] >= a[keyi]){right--;}while (left < right && a[left] <= a[keyi]){left++;}Swap(&a[left], &a[right]);}Swap(&a[left], &a[keyi]);keyi = left;QuickSortHoare(a, begin, keyi - 1);QuickSortHoare(a, keyi + 1, end);
}
3.2.2.快速排序hoare改进版三数取中选key法
Sort.h

//1.快速排序hoare改进版三数取中选key法
void QuickSortMid(int* a, int begin, int end);

Sort.c

void Swap(int* p1, int* p2)
{int tmp = *p1;*p1 = *p2;*p2 = tmp;
}
//三数取中
int GetMidi(int* a, int begin, int end)
{int midi = (begin + end) / 2;if (a[begin] < a[midi]){if (a[end] > a[midi])return midi;else if (a[end] < a[midi])return a[begin] > a[end] ? begin : end;}else if (a[begin] > a[midi]){if (a[end] < a[midi])return midi;else if (a[end] > a[midi])return a[begin] < a[end] ? begin : end;}return midi;}//1.快速排序hoare版本改进版三数取中选key法
void QuickSortMid(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;int keyi = begin;while (left < right){while (left < right && a[right] >= a[keyi]){right--;}while (left < right && a[left] <= a[keyi]){left++;}Swap(&a[left], &a[right]);}Swap(&a[left], &a[keyi]);keyi = left;QuickSortMid(a,begin,keyi-1);QuickSortMid(a, keyi + 1, end);
}
3.2.3.快速排序hoare版本改进版小区间优化法
Sort.h

//2.快速排序hoare改进版小区间优化法
void QuickSortSmall(int* a, int begin, int end);

Sort.c

void Swap(int* p1, int* p2)
{int tmp = *p1;*p1 = *p2;*p2 = tmp;
}
//三数取中
int GetMidi(int* a, int begin, int end)
{int midi = (begin + end) / 2;if (a[begin] < a[midi]){if (a[end] > a[midi])return midi;else if (a[end] < a[midi])return a[begin] > a[end] ? begin : end;}else if (a[begin] > a[midi]){if (a[end] < a[midi])return midi;else if (a[end] > a[midi])return a[begin] < a[end] ? begin : end;}return midi;}
//2.快速排序hoare版本改进版小区间优化法
void QuickSortSmall(int* a, int begin, int end)
{if (begin >= end)return;//递归到小的子区间时，可以考虑使用插入排序//小区间可以随意取，一般取为10if (end - begin + 1 <= 10){InsertSort(a + begin, end - begin + 1);}else{int midi = GetMidi(a, begin, end);Swap(&a[midi], &a[begin]);int left = begin, right = end;int keyi = begin;while (left < right){// 右边找小while (left < right && a[right] >= a[keyi]){--right;}// 左边找大while (left < right && a[left] <= a[keyi]){++left;}Swap(&a[left], &a[right]);}Swap(&a[left], &a[keyi]);keyi = left;// [begin, keyi-1] keyi [keyi+1, end]QuickSortSmall(a, begin, keyi - 1);QuickSortSmall(a, keyi + 1, end);}
}
3.2.4.快速排序挖坑法
Sort.h

//快速排序挖坑法
void QuickSort1(int* a, int begin, int end);

Sort.c

void Swap(int* p1, int* p2)
{int tmp = *p1;*p1 = *p2;*p2 = tmp;
}
//三数取中
int GetMidi(int* a, int begin, int end)
{int midi = (begin + end) / 2;if (a[begin] < a[midi]){if (a[end] > a[midi])return midi;else if (a[end] < a[midi])return a[begin] > a[end] ? begin : end;}else if (a[begin] > a[midi]){if (a[end] < a[midi])return midi;else if (a[end] > a[midi])return a[begin] < a[end] ? begin : end;}return midi;}
//挖坑法
int PartSort1(int* a, int begin, int end)
{int midi = GetMidi(a, begin, end);Swap(&a[midi], &a[begin]);int key = a[begin];int hole = begin;while (begin < end){//右边找小，填到左边坑while (begin < end && a[end] >= key){end--;}a[hole] = a[end];hole = end;while (begin < end && a[begin] <= key){begin++;}a[hole] = a[begin];hole = begin;}a[hole] = key;return hole;
}
//快速排序挖坑版
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);
}
3.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 GetMidi(int* a, int begin, int end)
{int midi = (begin + end) / 2;if (a[begin] < a[midi]){if (a[end] > a[midi])return midi;else if (a[end] < a[midi])return a[begin] > a[end] ? begin : end;}else if (a[begin] > a[midi]){if (a[end] < a[midi])return midi;else if (a[end] > a[midi])return a[begin] < a[end] ? begin : end;}return midi;}
//双指针法
int PartSort2(int* a, int begin, int end)
{int midi = GetMidi(a, begin, end);Swap(&a[midi], &a[begin]);int key = begin;int prev = begin;int cur = prev + 1;while (cur <= end){if (a[cur] < a[key] && ++prev != cur)Swap(&a[cur], &a[prev]);cur++;}Swap(&a[key], &a[prev]);key = prev;return key;
}
//快速排序双指针版
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);
}
3.2.6.快速排序非递归版
Strck.h

#pragma once#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>typedef int STDataType;
typedef struct Strck
{STDataType* a;int top; int capacity;
}ST;//初始化/销毁
void STInit(ST* pst);
void STDestroy(ST* pst);//压栈/出栈
void STPush(ST* pst, STDataType x);
void STPop(ST* pst);
//获取栈顶元素
STDataType STTop(ST* pst);//判空
bool STEmpty(ST* pst);
//统计栈内元素个数
int STSize(ST* pst);

Strck.c

#include"Strck.h"//初始化/销毁
void STInit(ST* pst)
{assert(pst);pst->a = NULL;pst->top = pst->capacity = 0;
}
void STDestroy(ST* pst)
{assert(pst);free(pst->a);pst->a = NULL;pst->top = pst->capacity = 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);return pst->top == 0;
}
//统计栈内元素个数
int STSize(ST* pst)
{assert(pst);return pst->top;
}

Sort.h

//快速排序非递归版
void QuickSortNonR(int* a, int begin, int end);

Sort.c

//快速排序非递归版
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);}}STDestroy(&s);
}

3.3.算法完整源码分享

3.3.1函数定义
Strck.h

#pragma once#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>typedef int STDataType;
typedef struct Strck
{STDataType* a;int top; int capacity;
}ST;//初始化/销毁
void STInit(ST* pst);
void STDestroy(ST* pst);//压栈/出栈
void STPush(ST* pst, STDataType x);
void STPop(ST* pst);
//获取栈顶元素
STDataType STTop(ST* pst);//判空
bool STEmpty(ST* pst);
//统计栈内元素个数
int STSize(ST* pst);

Strck.c

#include"Strck.h"//初始化/销毁
void STInit(ST* pst)
{assert(pst);pst->a = NULL;pst->top = pst->capacity = 0;
}
void STDestroy(ST* pst)
{assert(pst);free(pst->a);pst->a = NULL;pst->top = pst->capacity = 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);return pst->top == 0;
}
//统计栈内元素个数
int STSize(ST* pst)
{assert(pst);return pst->top;
}

Sort.h

#pragma once#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
#include<string.h>
#include<time.h>//快速排序hoare版本
void QuickSortHoare(int* a, int begin, int end);
//1.快速排序hoare改进版三数取中选key法
void QuickSortMid(int* a, int begin, int end);
//2.快速排序hoare改进版小区间优化法
void QuickSortSmall(int* a, int begin, int end);
//快速排序挖坑法
void QuickSort1(int* a, int begin, int end);
//快速排序双指针法
void QuickSort2(int* a, int begin, int end);
//快速排序非递归版
void QuickSortNonR(int* a, int begin, int end);
3.3.2.算法接口实现
Sort.c

#include"Sort.h"
#include"Strck.h"void Swap(int* p1, int* p2)
{int tmp = *p1;*p1 = *p2;*p2 = tmp;
}
//快速排序hoare版本
void QuickSortHoare(int* a, int begin, int end)
{if (begin >= end)return;int left = begin, right = end;int keyi = begin;while (left < right){while (left < right && a[right] >= a[keyi]){right--;}while (left < right && a[left] <= a[keyi]){left++;}Swap(&a[left], &a[right]);}Swap(&a[left], &a[keyi]);keyi = left;QuickSortHoare(a, begin, keyi - 1);QuickSortHoare(a, keyi + 1, end);
}
//三数取中
int GetMidi(int* a, int begin, int end)
{int midi = (begin + end) / 2;if (a[begin] < a[midi]){if (a[end] > a[midi])return midi;else if (a[end] < a[midi])return a[begin] > a[end] ? begin : end;}else if (a[begin] > a[midi]){if (a[end] < a[midi])return midi;else if (a[end] > a[midi])return a[begin] < a[end] ? begin : end;}return midi;}//1.快速排序hoare版本改进版三数取中选key法
void QuickSortMid(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;int keyi = begin;while (left < right){while (left < right && a[right] >= a[keyi]){right--;}while (left < right && a[left] <= a[keyi]){left++;}Swap(&a[left], &a[right]);}Swap(&a[left], &a[keyi]);keyi = left;QuickSortMid(a,begin,keyi-1);QuickSortMid(a, keyi + 1, end);
}
//2.快速排序hoare版本改进版小区间优化法
void QuickSortSmall(int* a, int begin, int end)
{if (begin >= end)return;//递归到小的子区间时，可以考虑使用插入排序//小区间可以随意取，一般取为10if (end - begin + 1 <= 10){InsertSort(a + begin, end - begin + 1);}else{int midi = GetMidi(a, begin, end);Swap(&a[midi], &a[begin]);int left = begin, right = end;int keyi = begin;while (left < right){// 右边找小while (left < right && a[right] >= a[keyi]){--right;}// 左边找大while (left < right && a[left] <= a[keyi]){++left;}Swap(&a[left], &a[right]);}Swap(&a[left], &a[keyi]);keyi = left;// [begin, keyi-1] keyi [keyi+1, end]QuickSortSmall(a, begin, keyi - 1);QuickSortSmall(a, keyi + 1, end);}
}//挖坑法
int PartSort1(int* a, int begin, int end)
{int midi = GetMidi(a, begin, end);Swap(&a[midi], &a[begin]);int key = a[begin];int hole = begin;while (begin < end){//右边找小，填到左边坑while (begin < end && a[end] >= key){end--;}a[hole] = a[end];hole = end;while (begin < end && a[begin] <= key){begin++;}a[hole] = a[begin];hole = begin;}a[hole] = key;return hole;
}
//快速排序挖坑版
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);
}
//双指针法
int PartSort2(int* a, int begin, int end)
{int midi = GetMidi(a, begin, end);Swap(&a[midi], &a[begin]);int key = begin;int prev = begin;int cur = prev + 1;while (cur <= end){if (a[cur] < a[key] && ++prev != cur)Swap(&a[cur], &a[prev]);cur++;}Swap(&a[key], &a[prev]);key = prev;return key;
}
//快速排序双指针版
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);
}
//快速排序非递归版
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);}}STDestroy(&s);
}
3.3.3.测试代码实现
test.c

#include"Sort.h"void TestQuickSortHoare()
{int a[] = { 2,4,5,7,8,0,9,6,3,1 };printf("排序前：");PrintArray(a, sizeof(a) / sizeof(int));printf("快速排序hoaer版：");QuickSortHoare(a, 0,sizeof(a) / sizeof(int)-1);PrintArray(a, sizeof(a) / sizeof(int));printf("\n");
}
void TestQuickSortMid()
{int a[] = { 2,4,5,7,8,0,9,6,3,1 };printf("排序前：");PrintArray(a, sizeof(a) / sizeof(int));printf("快速排序hoare改进版三数取中选key法：");QuickSortMid(a, 0, sizeof(a) / sizeof(int) - 1);PrintArray(a, sizeof(a) / sizeof(int));printf("\n");
}
void TestQuickSortSmall()
{int a[] = { 2,4,5,7,8,0,9,6,3,1 };printf("排序前：");PrintArray(a, sizeof(a) / sizeof(int));printf("快速排序hoare改进版小区间优化法：");QuickSortSmall(a, 0, sizeof(a) / sizeof(int) - 1);PrintArray(a, sizeof(a) / sizeof(int));printf("\n");
}
void TestQuickSort1()
{int a[] = { 2,4,5,7,8,0,9,6,3,1 };printf("排序前：");PrintArray(a, sizeof(a) / sizeof(int));printf("快速排序挖坑版：");QuickSort1(a, 0, sizeof(a) / sizeof(int) - 1);PrintArray(a, sizeof(a) / sizeof(int));printf("\n");
}
void TestQuickSort2()
{int a[] = { 2,4,5,7,8,0,9,6,3,1 };printf("排序前：");PrintArray(a, sizeof(a) / sizeof(int));printf("快速排序双指针版：");QuickSort2(a, 0, sizeof(a) / sizeof(int) - 1);PrintArray(a, sizeof(a) / sizeof(int));printf("\n");
}
void TestQuickSortNonR()
{int a[] = { 2,4,5,7,8,0,9,6,3,1 };printf("排序前：");PrintArray(a, sizeof(a) / sizeof(int));printf("快速排序非递归版：");QuickSortNonR(a, 0, sizeof(a) / sizeof(int) - 1);PrintArray(a, sizeof(a) / sizeof(int));printf("\n");
}int main()
{TestQuickSortHoare();TestQuickSortMid();TestQuickSortSmall();TestQuickSort1();TestQuickSort2();TestQuickSortNonR();return 0;
}
3.3.4.测试展示

在这里插入图片描述

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

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

相关文章

低多边形3D建模动画风格纹理贴图

低多边形3D建模动画风格纹理贴图

在线工具推荐&#xff1a; 3D数字孪生场景编辑器 - GLTF/GLB材质纹理编辑器 - 3D模型在线转换 - Three.js AI自动纹理开发包 - YOLO 虚幻合成数据生成器 - 三维模型预览图生成器 - 3D模型语义搜索引擎 当谈到游戏角色的3D模型风格时&#xff0c;有几种不同的风格&#xf…
阅读更多...
排序算法之七：归并排序（递归）

排序算法之七：归并排序（递归）

基本思想 基本思想&#xff1a; 归并排序&#xff08;MERGE-SORT&#xff09;是建立在归并操作上的一种有效的排序算法,该算法是采用分治法&#xff08;Divide and Conquer&#xff09;的一个非常典型的应用。将已有序的子序列合并&#xff0c;得到完全有序的序列&#xff1…
阅读更多...
【Proteus仿真】【51单片机】光照强度检测系统

【Proteus仿真】【51单片机】光照强度检测系统

文章目录 一、功能简介二、软件设计三、实验现象联系作者 一、功能简介 本项目使用Proteus8仿真51单片机控制器&#xff0c;使共阴数码管&#xff0c;PCF8591 ADC模块、光敏传感器等。 主要功能&#xff1a; 系统运行后&#xff0c;数码管显示光传感器采集光照强度值&#xff…
阅读更多...
C# 使用CancellationTokenSource 取消Task执行

C# 使用CancellationTokenSource 取消Task执行

写在前面 在Task创建并执行后&#xff0c;如果状态发生了变化&#xff0c;需要取消正在执行中的Task&#xff0c;除了使用主线程上的共享变量来判断之外&#xff0c;更优雅的方式就是就是用CancellationTokenSource来取消任务的执行。 代码实现 public static void CancelTas…
阅读更多...
Linux和Windows环境下如何使用gitee？

Linux和Windows环境下如何使用gitee？

1. Linux 1.1 创建远程仓库 1.2 安装git sudo yum install -y git 1.3 克隆远程仓库到本地 git clone 地址 1.4 将文件添加到git的暂存区&#xff08;git三板斧之add&#xff09; git add 文件名 # 将指定文件添加到git的暂存区 git add . # 添加新文件和修改过的…
阅读更多...
Java毕业设计—vue+SpringBoot图书借阅管理系统

Java毕业设计—vue+SpringBoot图书借阅管理系统

图书管理系统 1. 开发目的 实现图书的智能化、信息化和简单化&#xff1b;实现图书信息的增加、删除、修改、查找、借阅、还书、收藏的显示操作及实时数据库的提交和更改和对普通用户的增、删、改、查&#xff1b;提高图书管理员工作信息报送及反馈的工作效率&#xff0c;减轻…
阅读更多...
基于Solr的全文检索系统的实现与应用

基于Solr的全文检索系统的实现与应用

文章目录 一、概念1、什么是Solr2、与Lucene的比较区别1&#xff09;Lucene2&#xff09;Solr 二、Solr的安装与配置1、Solr的下载2、Solr的文件夹结构3、运行环境4、Solr整合tomcat1&#xff09;Solr Home与SolrCore2&#xff09;整合步骤 5、Solr管理后台1&#xff09;Dashbo…
阅读更多...
Redis高效恢复策略：内存快照与AOF

Redis高效恢复策略：内存快照与AOF

第1章&#xff1a;Redis宕机恢复的重要性和挑战 大家好&#xff0c;我是小黑。今天咱们来聊聊Redis宕机后的恢复策略。想象一下&#xff0c;你的网站突然宕机了&#xff0c;所有的数据都飘了&#xff0c;这种情况下&#xff0c;快速恢复数据就显得尤为重要。Redis作为一个高性…
阅读更多...
深入了解UDP协议：特点、应用场景及市面上常见软件案例

深入了解UDP协议：特点、应用场景及市面上常见软件案例

目录 引言 UDP的特点 UDP的应用场景 市面上使用UDP的软件案例 结论 引言 在计算机网络中&#xff0c;UDP&#xff08;User Datagram Protocol&#xff09;是一种面向无连接、无状态的传输层协议。与TCP相比&#xff0c;UDP具有独特的特点和适用场景。本文将深入探讨UDP协…
阅读更多...
专业mac投屏软件AirServer v7.2.7 mac中文版

专业mac投屏软件AirServer v7.2.7 mac中文版

专业mac投屏软件AirServer v7.2.7 mac中文版是一款好用的投屏工具&#xff0c;它可以将您的Mac变成通用镜像接收器&#xff0c;允许您使用内置的AirPlay或基于Google Cast的屏幕投影功能镜像设备的显示器。您可以通过任何AirPlay或Google Cast兼容设备镜像或投射屏幕&#xff0…
阅读更多...
YOLOV3 SPP 目标检测项目(针对xml或者yolo标注的自定义数据集)

YOLOV3 SPP 目标检测项目(针对xml或者yolo标注的自定义数据集)

1. 目标检测的两种标注形式 项目下载地址：YOLOV3 SPP网络对自定义数据集的目标检测(标注方式包括xml或者yolo格式) 目标检测边界框的表现形式有两种： YOLO(txt) ： 第一个为类别，后面四个为边界框，x，y中心点坐标以及h，w的相对值 xml文件：类似于网页的标注文件，里面会…
阅读更多...
Java数据结构《二叉排序树的插入删除和查找》(难度系数100)

Java数据结构《二叉排序树的插入删除和查找》(难度系数100)

一、前言&#xff1a; 这是怀化学院的&#xff1a;Java数据结构中的一道难度偏难(偏难理解)的一道编程题(此方法为博主自己研究与学习一名叫qing影的博主&#xff0c;问题基本解决&#xff0c;若有bug欢迎下方评论提出意见&#xff0c;我会第一时间改进代码&#xff0c;谢谢&am…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023