C++-排序

文章目录

        • 常数操作
        • 时间复杂度
        • 空间复杂度
          • O(N^2) O(1) 数据情况发生变化不影响流程
    • 选择排序
    • 冒泡排序
          • 使用抑或运算
            • 提取出不为零的数最右边的1
        • 1. 实现两个变量交换值
        • 2. 数组中一种数字出现奇数次,other是偶数次,找到那一种数字
        • 3. 数组中有两种数字出现奇数次,other是偶数次,找到那两种数字
          • O(N^2) O(1) 数据情况发生变化影响流程
    • 插入排序(码牌)
        • 二分法
        • 对数器
    • 归并排序
          • 最小和问题
            • 不漏算
            • 不重复计算
        • 荷兰国旗问题
    • 快排
          • version1
          • version2
          • version3
          • 扩容
          • 使用系统提供的堆-黑盒测试
    • 桶排序
      • 计数排序
      • 基数排序
          • 数据结构如何实现入桶出桶模拟?
    • 稳定性
          • 选择排序-否-O(n^2)
          • 冒泡排序-是-O(n^2)
          • 插入排序-O(n^2)
          • 归并-是-O(nlogn)
          • 快排-否-O(nlogn)
          • 堆排-否-O(nlogn)
        • 改进
          • 冒泡排序-是-O(n^2)
          • 插入排序-O(n^2)
          • 归并-是-O(nlogn)
          • 快排-否-O(nlogn)
          • 堆排-否-O(nlogn)
        • 改进

动图帮助理解网站

排序方法平均情况最好情况最坏情况辅助空间稳定性
冒泡排序O(n^2)O(n)O(n^2)O(1)稳定
简单选择排序O(n^2)O(n^2)O(n^2)O(1)不稳定
直接插入排序O(n^2)O(n)O(n^2)O(1)稳定
希尔排序O(nlogn)~O(n^2)O(n^1.3)O(n^2)O(1)不稳定
堆排序O(nlogn)O(nlogn)O(nlogn)O(1)不稳定
归并排序O(n*logn)O(n*logn)O(n*logn)O(n)稳定
快速排序O(n*logn)O(n*logn)O(n^2)O(logn)~O(n)不稳定

常数操作

一个操作如果和样本的数据量没有关系,每次都是固定时间内完成的操作,叫做常数操作

数组获取值:固定时间,常数操作.连续空间,距离和偏移量可以直接确认.链表不是连续空间

时间复杂度

具体来说,先要对一个算法流程非常熟悉,然后去写出这个算法流程中,发生了多少常数操作,
进而总结出常数操作数量的表达式。

在表达式中,只要高阶项,不要低阶项,也不要高阶项的系数,剩下的部分如果为f(N),那
么时间复杂度为O(f(N))。

先看时间复杂度指标,如果指标可以决出优劣即可,如果不能决出优劣指标相同,就需要再比较不同数据样本下的时间,常数项时间.

空间复杂度

另外开辟空间大小.

O(N^2) O(1) 数据情况发生变化不影响流程

选择排序

void SelectSort(int* a, int n){if (a == nullptr || n < 2)return;for (int i = 0; i < n - 1; i++){int minIndex = i;for (int j = i + 1; j < n; j++){minIndex = a[minIndex] > a[j] ? j : minIndex;}swap(a[minIndex], a[i]);}}

冒泡排序

void BubbleSort(int* a, int n){if (a == nullptr || n < 2)return;for (int e = n - 1; e > 0; e--)//右区间边界,一直向左缩小(因为一次遍历将最大值交换到最后){for (int i = 0; i < e; i++){if (a[i] > a[i + 1])swap(a[i], a[i + 1]);}}}
使用抑或运算
提取出不为零的数最右边的1
int rightOne=num&(~num+1);

image-20230601223400786

1. 实现两个变量交换值

不开辟另外的空间,但是两个变量必须指向两个空间,否则就会将这个位置的数值改为0.

抑或运算性质:

  1. 可理解为无进位相加
  2. 满足交换律 结合律

2. 数组中一种数字出现奇数次,other是偶数次,找到那一种数字

从头抑或到尾,得到的就是那个数字.

3. 数组中有两种数字出现奇数次,other是偶数次,找到那两种数字

从头抑或到尾得到eor,eor某一位必然不相同为1.根据这一位对数组进行分类,

再从新从头抑或一遍那一位为1的数字,偶数次的直接没,最后得到的一个不是a,就是b.

最后eor^eor’就是另一个数字.

O(N^2) O(1) 数据情况发生变化影响流程

插入排序(码牌)

数据情况发生变化影响流程.如果是想要的有序状态,就是O(N).按照算法最差情况估计时间复杂度O(N^2).

	//想让0~i的范围内有序void InsertSort(vector<int>& a, int n){if (a.size()==0 || n < 2)return;for (int i = 1; i < n-1; i++){for (int j = i - 1; j >= 0 && a[j] > a[j + 1]; j--){swap(a[j], a[j + 1]);}}}

二分法

image-20230607113552401

class BS
{
public://有序bool BSExist(int* a, int n, int x){if (a == nullptr || n < 2)return false;int l = 0, r = n - 1;while (l < r){int mid = l + ((r-l) >> 2);if (a[mid] > x)r = mid - 1;else if (a[mid] < x)l = mid + 1;elsereturn true;}return a[l]==x;}//有序//找到最左侧大于等于x的位置值int BSNearLeft(int* a, int n,int x){if (a == nullptr || n < 2)return -1;int l = 0, r = n - 1;int index = -1;while (l < r){int mid = l + (r - l) / 2;if (a[mid] >= x){index = mid;r = mid - 1;}else if (a[mid] < x){l = mid + 1;}}return index;}//无序//找局部最小值int FindOneLessValue(int* a, int n){if (a == nullptr || n == 0)return -1;//0位置if (n == 1 || a[0] < a[1])return a[0];//n-1位置if (a[n - 1] < a[n - 2])return a[n - 1];//[0,n-1]位置上必存在拐点,也就是局部最小值,直接取midint l = 0, r = n - 1;int mid = 0;while (l < r){mid = l + (r - l) / 2;if (a[mid] < a[mid + 1] && a[mid] < a[mid - 1])return mid;else if (a[mid - 1] < a[mid])r = mid - 1;else if (a[mid + 1] < a[mid])l = mid + 1;}return l;}
};

对数器

image-20230607113528436

归并排序

image-20230607130040457

class MergeSort
{
public://拆分为二分,则b=2 a=2 log(b,a)==d==1 // d:其他操作是将N个数据->tmp中,tmp->arr原数组所以是2*T(N)是O(N)//T(N)=N^1*logN//O(N^2)的选择冒泡,几乎比较了将近N次才完成一个数位置的确定//归并:左有序区间开始和右边有序区间依次比较,没有浪费比较次数void mergeSort(vector<int>& arr){if (arr.size() < 2)return;merageSortHelper(arr,0,arr.size()-1);}void merageSortHelper(vector<int>& arr, int l, int r){if (l == r)return;int mid = l + ((r - l) >> 1);merageSortHelper(arr,l,mid);merageSortHelper(arr,mid+1,r);merge(arr,l,mid,r);}void merge(vector<int>& arr, int l, int mid, int r){vector<int>tmp(r-l+1);int i = 0;int p1 = l;int p2 = mid + 1;while (p1 <= mid && p2 <= r){tmp[i++] = arr[p1] > arr[p2] ? arr[p2++] : arr[p1++];}while (p1 <= mid)tmp[i++] = arr[p1++];while (p2 <= r)tmp[i++] = arr[p2++];for (i = 0; i < tmp.size(); i++)arr[l + i] = tmp[i];}
};

image-20230607133500698

最小和问题

转化为右边有多少个数比我大,我就累加几次的问题.

不漏算

任何一个数x的历程,左侧区间先和自己比然后合并为一个部分,计算产生小和,右侧区间再与自己所在有序区间合并,然后组成更大的部分,再和这一更大的部分右边更大的部分合并计算小和…

不重复计算

只有在左组和右组合并时才会产生小和的计算,组成的有序区间内部是不会有小和的计算的.

class SmallSum
{
public:int smallSum(vector<int>& arr){if (arr.size() < 2)return 0;return mergeSort(arr,0,arr.size()-1);}int mergeSort(vector<int>& arr, int l, int r){if (l == r)return 0;int mid = l + ((r - l)) >> 1;return mergeSort(arr,l,mid)+mergeSort(arr,mid+1,r)+merge(arr,l,mid,r);}int merge(vector<int>& arr, int l, int mid, int r){vector<int>tmp(r-l+1);int i = 0;int p1 = l, p2 = mid + 1;int res = 0;while (p1 <= mid && p2 <= r){res += arr[p1] < arr[p2] ? arr[p1] * (r - p2 + 1) : 0;tmp[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];//相等时一定是p2++,保证后续最小和正确性}while (p1 <= mid)tmp[i++] = arr[p1++];while (p2<=r)tmp[i++] = arr[p2++];for (i = 0; i < tmp.size(); i++)arr[l + i] = tmp[i];return res;}
};

荷兰国旗问题

image-20230607134950866

class NetherlandsFlag
{
public://1. [i]<num [i]和less区间右边的数字交换,less区间右扩,i++//2. [i]>num [i]和more区间左边的数字交换,more区间左扩,i不变,因为此时i位置值是刚交换过来的,还不知道是啥值//3. [i]==num[i],i++即可,不做交换处理//动态观察就是less区间推着==区间向右挤压待定区域接近more区间,反之亦然.//如何推?相等区间最左(右)边值和[i](<num)交换,然后i++,实现的,反之亦然.pair<int,int> partition(vector<int>& arr,int l,int r,int p){int less = l-1;int more = r + 1;while (l<more){if (arr[l] < p){swap(arr[l], arr[less + 1]);less++;l++;}else if (arr[l] > p){swap(arr[l], arr[more - 1]);more--;}else{l++;}}return std::make_pair(less+1,more-1);//返回中间=区域的左边界和右边界}
};

快排

version1

就是将最后一个数当作num,让前n-1个数,[0,n-2]进行区间划分,最后将num和more区间最左边的值进行交换即可,这样搞定num一个数…然后划分左区间(<=num),右区间(>num)各自重复刚才的操作,取区间最后一个值作为num…;

version2

进行荷兰国旗问题,num和more区间最左值交换之后和前面的=num的区间合并,=num的区间一批数就不用再处理了,效率相对于version1更快点.再依次将less和more进行处理.

不管哪个版本,当是升序且不重复值的时候,每次partition只能搞定一个num值,即划分值num打的很极端,要么是最大要么是最小,最坏情况即T(N)=O(N^2).只有num是中间值1/2时才是最好的即

T(N)=2*T(N/2)+O(N)=>T(N)=O(N*logN)

version3

那么我随机选择一个数字作为num,然后对区间进行划分,可能我就选中那个使得数组一半一半的一种情况,也可能造成T(N/3)+T(2N/3)+O(N),选值也可能造成T(N/4)+T(3N/4)+O(N),每一种可能的概率是等价的1/N,因为我是在N个数中随机选择一个值进行对区间的划分,所有可能情况求期望就是O(N*logN)

class QuickSort
{
public:void quickSort(vector<int>& arr){if (arr.size() < 2)return;quickSortHelper(arr, 0, arr.size() - 1);}void quickSortHelper(vector<int>& arr, int l, int r){if (l < r){swap(arr[l + (int)(rand() * (r - l + 1))], arr[r]);pair<int, int>p = partition(arr,l,r);quickSortHelper(arr,l,p.first-1);quickSortHelper(arr,p.second+1,r);}}pair<int, int>partition(vector<int>& arr, int l, int r){int less = l - 1;int more = r + 1;while (l < more){if (arr[l] > arr[r]){swap(arr[less + 1], arr[l]);l++;less++;}else if (arr[l] < arr[r]){swap(arr[more - 1], arr[l]);more--;}elsel++;}swap(arr[r],arr[more]);return make_pair(less+1,more-1);}
};

空间复杂度

需要记录划分区间的中间值的位置,最差情况是O(N),当取到值正好二分区间时,情况就是O(logN)

只有记录了中点信息,才能确定右区间的范围,所以这个点需要记录,因为递归栈的存在记录了这个点的信息.

image-20230607222920687

数组从0出发连续的数字,可以想象为一个完全二叉树,左孩子2*i+1,右孩子是2*i+2,父亲节点是(i-1)/2

image-20230607222953303

class Heap
{
public://我们认为前heapSize个值作为堆来看待// //需求: 一个个在index位置添加值,如何建立大堆//向上调整void HeapInsert(vector<int>& arr, int index){//index=0时,(index-1)/2=0,依然不满足条件while (arr[index] > arr[(index - 1) >> 1]){swap(arr[index],arr[(index-1)>>1]);index = (index - 1) >> 1;}}//	需求: 返回堆中最大值,并将他移除之后,仍然保持大堆// 将第heapSize-1位置的值放在0位置处,从顶开始向下调整// 选出两个孩子中较大值,比较之后交换位置// 交换跳出条件://1. 交换之后没有孩子节点继续向下//2. 父亲节点大于max孩子节点//向下调整void HeapIfy(vector<int>& arr, int index, int heapSize){int left = 2 * index + 1;while (left < heapSize){int largest = left + 1 < heapSize && arr[left + 1] > arr[left] ? left + 1 : left;largest = arr[index] > arr[largest] ? index : largest;if (largest == index)break;swap(arr[largest], arr[index]);index = largest;left = index * 2 + 1;}}//在某一个位置发生值的改变,要么是变小了,如果保持大根堆,向下调整,变大了就向上调整//调整代价均为LogN级别//需求: 将已知数组中整理为大跟堆,我们初始化heapSize=0,认为[0,heapSize]认为是堆空间//就相当于一个个heapInsert操作void heapSort(vector<int>& arr){if (arr.size() < 2)return;for (int i = 0; i < arr.size(); i++)//O(N){HeapInsert(arr,i);//经历调整确定位置O(logN)}int heapSize = arr.size();swap(arr[0],arr[--heapSize]);while (heapSize > 0)//O(N){HeapIfy(arr,0,heapSize);	//O(log(N))swap(arr[0],arr[--heapSize]);//O(1)}}//额外空间复杂度是O(1) 只需要申请几个变量空间即可
};
	//需求:将整个数组调整为大跟堆,从最后一个父亲节点开始向下调整heapIfy//最底层占将近一半,N/2,无法向下再调整,只看一眼,代价是1//倒数第二层N/4个,可以向下操作,看一眼,代价是2//倒数第二层N/8个,可以向下操作2次,看一眼,代价是3//....//整体复杂度就是T(N)=N/2*1+N/4*2+N/8*3....//从heapInsert的O(N*logN)=>O(N)//for (int i = (arr.size() - 1) / 2; i >= 0; i--)//O(N)//{//		HeapIfy(arr, i,heapSize);//经历调整确定位置O(logN)//}

image-20230607222715862

image-20230607223122048

选择小根堆,将K+1个数字插入到小跟堆中,堆顶就是最小值放到数组0的位置,继续向后遍历将值放入小跟堆,得到堆顶元素,再放到1的位置,全部入堆之后依次弹出堆顶元素即可.

O(N*logK)

#include<iostream>
#include<vector>
#include<queue>
using namespace std;
class SortArrDistanceLessK
{
public:void sortArrDistanceLessK(vector<int>& arr, int k){priority_queue<int,vector<int>,greater<int>> heap;int index = 0;int n = arr.size();for (; index < min(k, n); index++){heap.push(arr[index]);}int i = 0;for (; index < n; i++,index++){heap.push(arr[index]);arr[i] = heap.top();heap.pop();}while (!heap.empty()){arr[i++] = heap.top();heap.pop();}}
};
int main()
{//priority_queue<int, vector<int>, less<int>> heap;//大堆//priority_queue<int> heap;//大堆priority_queue<int, vector<int>, greater<int>> heap;//大堆heap.push(8);heap.push(4);heap.push(6);heap.push(1);heap.push(3);while (!heap.empty()){cout << heap.top() << " ";heap.pop();}
}
扩容

每次扩容的代价是O(N)的,因为成倍的扩容需要将源数据拷贝到新数组中,但是扩容的次数是O(logN)

整体扩容代价就是O(N*logN),均摊到单点扩容时就是O(N*logN)/N=>O(logN)

使用系统提供的堆-黑盒测试

你add一个值,它弹出栈顶值返回一个值此时就不需要手写堆.

系统自身维护好的堆结构,想更改堆中值并想让他自己调整为合法堆结构是不支持的,只能采用遍历的方式决定怎么调整,效率很低.

自己手写的支持某一个位置值开始,效率较高的决定向上或者向下调整.

所以你想更改堆结构中的某一个值并让他自己高效率调整回堆结构时,还是自己手写一个更好.

image-20230608114940477

桶排序

image-20230608115019749

不进行数值比较的排序都会受到数据状况的影响.

计数排序

思想:统计数字出现情况开辟多大空间,然后O(N)遍历数组统计词频,输出数字即可.

#include<iostream>
#include<vector>
using namespace std;
class CountSort
{
public:void countSort(vector<int>& arr){if (arr.size() == 0)return;int max_num = INT_MIN;for (int i = 0; i < arr.size(); i++)max_num = max(max_num, arr[i]);vector<int>bucket(max_num+1);for (int i = 0; i < arr.size(); i++){bucket[arr[i]]++;}int i = 0;for (int j = 0; j < bucket.size(); j++)while (bucket[j]--)arr[i++] = j;}};

基数排序

进制的存在10进制 ,就安排10个桶(可以是任何容器,数组,链表,队列),先让数字按照个位数字区分,分别进入到0~9编号的桶中,然后依次出桶;再按照十位数字依次入桶出桶…最后数组中完成排序.

最大数字的位数决定了入桶出桶的次数

数据结构如何实现入桶出桶模拟?

统计数组中每个数字个位数字出现的频次,入count数组中

然后做成前缀和,i位置表示个位数字小于等于i的数字一共有几个,从arr数组末尾向前遍历做出桶动作,得到数字num,他的个位数字是i,入桶时count数组下标i位置这个桶中,进桶肯定是最后一个进的,所以我们将他放在help数组中,那么他在辅助数组help中的下标就是数组count[i]-1,count[i]--,依次类推完成了一次根据个位数字的入桶出桶操作.

image-20230608130347549

#include<iostream>
#include<vector>
using namespace std;
class RadixSort
{
public://基数排序void radixSort(vector<int>& arr){if (arr.size() == 0)return;radixSorthelper(arr, 0, arr.size() - 1,maxDigits(arr));}int maxDigits(vector<int>& arr){int max_num = INT_MIN;for (int i = 0; i < arr.size(); i++){max_num = max(max_num,arr[i]);}int res = 0;while (max_num != 0){res++;max_num /= 10;}return res;}int getDigit(int num, int d){return ((num / ((int)pow(10, d - 1))) % 10);}void radixSorthelper(vector<int>& arr, int begin, int end,int digit)//多少位{int radix = 10;int i = 0, j = 0;vector<int>bucket(end-begin+1);//helpfor (int d = 1; d <= digit; d++)//位数决定入桶出桶多少次//d=1代表这次循环是个位{vector<int>count(radix);for (i = begin; i <= end; i++){j = getDigit(arr[i],d);count[j++];}//10个桶,计算每个桶的前缀和for (i = 1; i < radix; i++){count[i] = count[i] + count[i - 1];}for (int i = end; i >= begin; i--){j = getDigit(arr[i],d);bucket[count[j] - 1] = arr[i];count[j]--;}for (i = begin, j = 0; i <= end; i++, j++){arr[i] = bucket[j];}}}
};
//int main()
//{
//	RadixSort rs;
//	cout<<rs.getDigit(123,2)<<endl;
//	cout << pow(10, 1 - 1) << endl;
//	cout << (123 / ((int)pow(10, 2 - 1))) << endl;
//	cout << ((123 / ((int)pow(10, 2 - 1))) % 10) << endl;
//}

稳定性

值相同的元素排完之后能否保证相对顺序不发生改变.

基础类型之间稳定性不重要.自定义类型为了稳定性选归并不选快排.

情景:先根据商品的价格由高到低排序,再根据好评率从低到高排序,如果稳定性好,这样开头的就是物美价廉的商品.

选择排序-否-O(n^2)

在[0,n-1]上选择最小的放在0位置处,如果是3 3 3 3 3 3 13 3 3 3 3 ,会将第一个3与1交换,第一个3和1之间的几个3的相对位置发生改变,所以不稳定

冒泡排序-是-O(n^2)

相等值时不交换就完了

插入排序-O(n^2)

[0,i]区间上做到有序,往前看相等的时候,我就不换就完了呗.

归并-是-O(nlogn)

merge时,我让前区间相等值先拷贝到tmp数组中就可以了.

那么之前的最小和问题必须先让后区间相等值考入,那么就没有稳定性了.

快排-否-O(nlogn)

partition时遇到<5的就需要和<区前一个交换

image-20230608142956420

堆排-否-O(nlogn)

很轻易就可以破坏稳定性即相对位置.

不基于比较的排序很容易可以维持稳定性.

image-20230608143610290

image-20230608143642120

image-20230608143853282

经典快排partition是01标准,可以实现奇数在前偶数在后,但是无法实现稳定性,并且空间复杂度O(1)

改进

image-20230608144227920

大样本调度按照快排O(nlogn),小范围比如<=60,就让它小区间直接插入排序O(n^2)混着用就行->综合排序.

在[0,n-1]上选择最小的放在0位置处,如果是3 3 3 3 3 3 13 3 3 3 3 ,会将第一个3与1交换,第一个3和1之间的几个3的相对位置发生改变,所以不稳定

冒泡排序-是-O(n^2)

相等值时不交换就完了

插入排序-O(n^2)

[0,i]区间上做到有序,往前看相等的时候,我就不换就完了呗.

归并-是-O(nlogn)

merge时,我让前区间相等值先拷贝到tmp数组中就可以了.

那么之前的最小和问题必须先让后区间相等值考入,那么就没有稳定性了.

快排-否-O(nlogn)

partition时遇到<5的就需要和<区前一个交换

[外链图片转存中…(img-f2PF5BCk-1691664383774)]

堆排-否-O(nlogn)

很轻易就可以破坏稳定性即相对位置.

不基于比较的排序很容易可以维持稳定性.

[外链图片转存中…(img-qxzV5zE8-1691664383775)]

[外链图片转存中…(img-ZorBBZL9-1691664383775)]

[外链图片转存中…(img-P9EHRawr-1691664383775)]

经典快排partition是01标准,可以实现奇数在前偶数在后,但是无法实现稳定性,并且空间复杂度O(1)

改进

[外链图片转存中…(img-uq2tsAV6-1691664383776)]

大样本调度按照快排O(nlogn),小范围比如<=60,就让它小区间直接插入排序O(n^2)混着用就行->综合排序.

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

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

相关文章

如何理解MySQL隔离性---3个记录隐藏字段、undo日志、Read View

目录 一、3个记录隐藏字段 二、undo 日志 三、read view 一、3个记录隐藏字段 本片文章是帮助理解上篇文章Mysql隔离性的辅助知识。 mysql在建表时&#xff0c;不仅仅创建了表的结构&#xff0c;还创建了3个隐藏字段。 DB_TRX_ID &#xff1a;6 byte&#xff0c;最近修改( 修…

iOS开发-JsonModel的学习及使用

IOS JsonModel的学习及使用 当我们从服务端获取到json数据后的时候&#xff0c;我们需要在界面上展示或者保存起来&#xff0c;下面来看下直接通过NSDictionary取出数据的情况。 NSDictionary直接取出数据的诟病。 NSString *name [self.responseObj objectForKey:"nam…

巧用Maya轴心操作技巧,让工作事半功倍!

Maya 是一款专业的三维软件&#xff0c;可以用于创建规模宏大的世界、复杂的角色和炫酷的特效。Maya的用户遍布动画行业、影视特效、广告和片头、平面设计行业&#xff0c;用户数量十分庞大。本文分享了maya轴心操作的小技巧&#xff0c;让设计师工作事半功倍&#xff0c;一起来…

一分钟了解自动化测试

目前自动化测试并不属于新鲜的事物&#xff0c;或者说自动化测试的各种方法论已经层出不穷&#xff0c;但是&#xff0c;能够明白自动化测试并很好落地实施的团队还不是非常多&#xff0c;我们接来下用通俗的方式来介绍自动化测试…… 首先我们从招聘岗位需求说起。看近期的职…

基于Java+SpringBoot制作一个社区宠物登记小程序

制作一个社区宠物登记小程序,帮助社区居民登记和管理他们的宠物信息,以便更好地跟踪和维护社区中的宠物状况,通过社区宠物信息登记系统,社区居民可以更好地管理自己的宠物信息,并与其他宠物所有者共享资源和信息。这将有助于提高社区宠物的福利和安全,促进社区成员之间的…

班级事务管理系统设计与实现

班级事务管理系统 后端采用Spring Boot开发。 cloud分支版本正在开发中&#xff0c;后端采用Spring Cloud进行改造。 系统架构 项目采用B/S架构&#xff0c;前后端通讯采用RESTful API&#xff0c;数据格式使用Json&#xff0c;认证Token格式采用JWT。 身份认证使用Spring …

jmeter性能测试常见的一些问题

一、request 请求超时设置 timeout 超时时间是可以手动设置的&#xff0c;新建一个 http 请求&#xff0c;在“高级”设置中找到“超时”设置&#xff0c;设置连接、响应时间为2000ms。 1. 请求连接超时&#xff0c;连不上服务器。 现象&#xff1a; Jmeter表现形式为&#xff…

安防监控视频汇聚EasyCVR平台的FLV视频流在VLC中无法播放的原因排查

众所周知&#xff0c;TSINGSEE青犀视频汇聚平台EasyCVR可支持多协议方式接入&#xff0c;包括主流标准协议国标GB28181、RTSP/Onvif、RTMP等&#xff0c;以及厂家私有协议与SDK接入&#xff0c;包括海康Ehome、海大宇等设备的SDK等。在视频流的处理与分发上&#xff0c;视频监控…

Mac 安装不在 Apple 商店授权的应用程序

文章目录 一、场景介绍二、实操说明 一、场景介绍 在日常的工作生活中&#xff0c;发现一些好用的应用程序&#xff0c;但是出于某些原因&#xff0c;应用程序的开发者并没有将安装包上架到苹果商店。 那么这些优秀的应用程序下载安装以后就会出现如下弹框被拒之门外 二、实操…

【论文阅读】基于深度学习的时序预测——Informer

系列文章链接 论文一&#xff1a;2020 Informer&#xff1a;长序列数据预测 论文二&#xff1a;2021 Autoformer&#xff1a;长序列数据预测 文章地址&#xff1a;https://arxiv.org/abs/2012.07436 github地址&#xff1a;https://github.com/zhouhaoyi/Informer2020 参考解读…

比特鹏哥5-数组【自用笔记】

比特鹏哥5-数组【自用笔记】 1.数组的概念2.一维数组的创建和初始化创建的语句结构初始化的语句结构 3.一维数组的使用数组的下标&#xff1a;从0开始&#xff0c;n个数组&#xff0c;最后一个的下标是n-1 4.一维数组在内存中的存储5.sizeof计算数组元素个数可以计算元素个数并…

计算机工作原理:进程调度

在计算机中&#xff0c;什么是进程&#xff1f;一个跑起来的程序就是一个进程&#xff0c;没跑起来就只能算一个程序。 在windows的任务管理器中&#xff0c;可以很清楚的看到有哪一些进程。 进程&#xff08;progress&#xff09;也叫任务&#xff08;task&#xff09;。 每…

侯捷 C++面向对象编程笔记——10 继承与虚函数

10 继承与虚函数 10.1 Inheritance 继承 语法&#xff1a;:public base_class_name public 只是一种继承的方式&#xff0c;还有protect&#xff0c;private 子类会拥有自己的以及父类的数据 10.1.1 继承下的构造和析构 与复合下的构造和析构相似 构造是由内而外 Container …

UML-活动图

目录 一.活动图概述: 1.活动图的作用&#xff1a; 2.以下场合不使用活动图&#xff1a; 3.活动图的基本要素&#xff1a; 4.活动图的图符 4.1起始状态 4.2终止状态 4.3状态迁移 4.4决策点 4.5同步条:表示活动之间的不同 5.活动图: 二.泳道&#xff1a; 1.泳道图&a…

有人管一管小天才电话手表吗?

作者 | 张未 来源 | 洞见新研社 潮流果然是个圈&#xff0c;曾经风靡2008年的“摇一摇”重回我们的视野当中。 这个对于成年人有些过时的产物&#xff0c;以儿童手表为载体&#xff0c;正入侵着小学生的社交圈&#xff0c;成为儿童的“社交密码”。 “碰一碰”加好友&#x…

亚马逊公告:订单存档政策调整,超过两年将于9月起存档

站斧浏览器获悉&#xff1a; 亚马逊新公告&#xff1a;2023年9月起&#xff0c;亚马逊美国站和欧洲站宣布将调整订单数据存档政策。这一政策的调整旨在保护客户的个人隐私和数据安全&#xff0c;从而提高客户的购物体验。据悉&#xff0c;所有历时超过两年以上的订单将按月进行…

【高频面试题】多线程篇

文章目录 一、线程的基础知识1.线程与进程的区别2.并行和并发有什么区别&#xff1f;3.创建线程的方式有哪些&#xff1f;3.1.Runnable 和 Callable 有什么区别&#xff1f;3.2.run()和 start()有什么区别&#xff1f; 4.线程包括哪些状态&#xff0c;状态之间是如何变化的4.1.…

如何将Linux上的cpolar内网穿透设置成 - > 开机自启动

如何将Linux上的cpolar内网穿透设置成 - > 开机自启动 文章目录 如何将Linux上的cpolar内网穿透设置成 - > 开机自启动前言一、进入命令行模式二、输入token码三、输入内网穿透命令 前言 我们将cpolar安装到了Ubuntu系统上&#xff0c;并通过web-UI界面对cpolar的功能有…

如何维护自己的电脑

目录 1、关于电脑选择的建议 1.1、价格预算 1.2、明确需求 1.3、电脑配置 1.4、分辨率 1.5、续航能力 1.6、品牌选择 1.7、用户评测 1.8、各个电商平台对比 1.9、最后决策 2、我的选择 3、电脑保养 3.1 外部清洁 3.2 安装软件 3.3 优化操作系统 3.4 维护硬件设…

web前端之CSS

文章目录 一、CSS简介1.1 CSS语法规则 二、CSS的引用方法2.1 定义行内样式表2.2定义内部样式表2.3链入外部样式表2.4导入外部样式表 三、CSS选择符3.1 基本选择符3.1.1 标签选择符3.1.2 class类选择符3.1.3 id选择符 3.2 复合选择符3.2.1 交集选择符&#xff08;合并选择器&…