算法笔记第四章总结

最新推荐文章于 2023-08-07 08:30:00 发布
最新推荐文章于 2023-08-07 08:30:00 发布
阅读量1k 收藏 4
点赞数 2
分类专栏： 晴神宝典 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43072968/article/details/107574941
版权

排序

选择排序

void selectSort(){
    for(int i=0;i<=n;i++){
        int k=i;
        for(int j=i;j<=nlj++){
            if(A[j]<A[K]){
                k=j;
            }
        }
        int temp=A[i];
        A[i]=A[k];
        A[k]=temp;
    }
}

插入排序

int A[maxn],n;
void insertSort(){
    for(int i=2;i<=n;i++){//进行n-1趟排序
        int temp=A[i],j=i;//temp临时存放A[i]，j从i往前枚举
        while(j>1&&temp<A[j-1]){//只要temp小于前一个元素A[j-1]
            A[j]=A[j-1];//将A[j-1]后移一位
            j--;
        }
        A[j]=temp;//插入位置为j
    }
}

排序题目与sort函数应用

注意：strcmp函数返回值不一定是+1，-1，这与编译器有关，应该判断>0，<0。

分数相同排名一致且占用一个排位

stu[0].rank=1;//第一个排名记为1
for(int i=1,i<n;i++){
    if(stu[i].score==stu[i-1].score){
        stu[i].rank=stu[i-1].rank;
    }else{
        stu[i].rank=i+1;
    }
}

散列

散列的定义与整数散列

整数散列

#include<cstdio>
const int maxn=100010;
int hashTable[maxn]={0};
int main(){
    int n,m,x;
    scanf("%d%d",&n,&m);
    for(int i=0;i<n;i++){
        scanf("%d",&x);
        hashTable[x]++;
    }
    for(int i=0;i<m;i++){
        scanf("%d",&x);
        printf("%d\n",hashTable[x]);
    }
    return 0;
}

散列

将元素通过一个函数转换为证书，使得该证书可以尽量唯一地代表这个元素，转换函数成为散列函数H，元素在转换前为key，转换后为H(key)。

常用的散列函数，上面整数散列使用直接定址法，恒等变换。

线性变换：H（key)=a*key+b；

平方取中法：key的平方的中间若干位作为hash值，很少用；

除留余数法：较为常用，H（key）=key%mod。表长TSize必须不小于mod，不然会产生越界。

取TSize为一个素数，mod直接取成与TSize相等。

解决冲突的方法

  1. 线性探查法

    不断+1，判断后一个是否已被占用。

  2. 平方探查法

    H(key)+1平方；H(key)-1平方；H(key)+2平方；H(key)-2平方；按照这个顺序。如果超出表长，则对表长取模。为避免负数的麻烦，也可以只进行正向的平方取模。

  3. 链地址法

    哈希值相同的连成链表。

字符串hash初步

A-Z转换为十进制，26-10
int hashFunc(char S[],int len){
    int id=0;
    for(int i=0;i<len;i++){
        id=id*26+(S[i]-'A');
    }
    return id;
}
A-Za-z转化为10进制，52-10
int hashFunc(char S[],int len){
    int id=0;
    for(int i=0;i<len;i++){
        if(S[i]>='A'&&S[i]<='Z'){
            id=id*52+(S[i]-'A');
        }else if(S[i]>='a'&&S[i]<='z'){
            id=id*52+(S[i]-'a')+26;//后面放小写字母
        }
    }
    return id;
}
如果出现了数字：
  • 增大进制数到62；
  • 如果保证末尾为确定个数的数字，即数字的个数和位置确定，可以分开转换然后拼接。
int hashFunc(char S[],int len){
    int id=0;
    for(int i=0;i<len-1;i++){
        id=id*26+S[i]-'A';
    }
    id=id*10+S[len-1]-'0';//最后一位为数字
    return id;
}
问题

N个字符串，由恰好三位大写字母组成，在给出M个查询字符串，问每个查询字符串在N个字符串中出现的次数。

#include <cstdio>
const int manx=100;
char S[maxn][5],temp[5];
int hashTable[26*26*26+10];
int hashFunc(char S[],int len){//hash函数，将S转化为整数
    int id=0;
    for(int i=0;i<len;i++){
        id=id*26+(S[i]-'A');
    }
    return id;
}
int main(){
    //接收M,N输入
    int n,m;
    scanf("%d%d",&n,&m);
    //接收N个字符串，储存在二维数组S中
    for(int i=0;i<n;i++){
        scanf("%s",S[i]);
        int id=hashFunc(S[i],3);//将字符串转为整数
        hashTable[id]++;//哈希表中，该字符串出现次数加一
    }
    for(int i=0;i<m;i++){
        scanf("%s",temp);
        int id=hashFunc(temp,3);
        printf("%d\n",hashTable[id]);//输出该字符串的出现次数
    }
    return 0;
}

递归

分治

分治法的三个步骤

  1. 分解，分解成与原问题有相似或相同结构的子问题。子问题之间应该是相互独立、没有交叉的。
  2. 解决，递归解决所有子问题。
  3. 合并，子问题的解合并为原问题的解。

子问题个数为1的情况成为减治，子问题个数大于1的情况成为分治。

可以通过递归来实现，也可以通过非递归实现。

递归

递归来实现分治的思想。递归逻辑中的两个重要概念：递归边界，递归式（递归调用）

递归求阶乘
#include<stdio.h>
int F(int n){
    if(n==0)return 1;
    else return F(n-1)*n;
}
递归求斐波那契数列
#include<stdio.h>
int F(int n){
    if(n==0||n==1)return 1;
    else return F(n-1)+F(n-2);
}
递归求全排列

输出1-n这n个整数的全排列

#include<cstdio>
const int maxn=11;
//p为当前排列，hashTable记录整数X是否已经在P中
int n,P[manx],hashTable[maxn]={false};
//当前处理排列的第index号位
void generateP(int index){
    if(index==n+1){//递归边界，已经处理完排列的1~n位
        for(int i=1;i<=n;i++){//输出当前排列
            printf("%d",P[i]);
        }
        printf("\n");
        return;
    }
    for(int x=1;x<=n;;x++){//枚举1-n,试图将x填入P中
        P[index]=x;//另P的第index位为x,把x加入当前序列
        hashTable[x]=true;//记录x已经在P中
        generateP(index+1);//处理排列的第n+1号位
        hashTable[x]=false;//处理完P[index]为x的子问题之后，还原状态
    }
}
int main(){
    n=3;
    generateP(1);//从P[1]开始填
    return 0；
}
递归解决N皇后问题
int count=0;
void generateP(int index){
    if(index==n+1){//递归边界
        bool flag=true;//当前排列为一个合法方案
        for(int i=1;i<=n;i++){
            for(int j=i+1;j<=n;j++){
                if(abs(i-j)==abs(P[i]-P[j])){//两个点位于对角线
                    flag=false;//不合法
                }
            }
        }
        if(flag){
            count++;
        }
        return;
    }
    for(int x=1;x<=n;x++){
        if(hashTable[x]==false){
            P[index]=x;
            hashTable[x]=true;
            generateP(index+1);
            hashTable[x]=false;
        }
    }
}
回溯法解决N皇后问题

到达递归边界前的某层，由于某些事实已经不需要往任何一个子问题回归，就可以直接返回上一层。这种方法成为回溯法。

void generateP(int index){
    if(index==n+1){
        count++;
        return;
    }
    for(int x=1;x<=n;x++){
        if(hashTable[x]==false){
            bool flag=true;
            for(int pre=1;pre<index;pre++){//遍历之前的皇后
                //第index列皇后的行号为x,第pre列的皇后的行号为P[pre]
                if(abs(index-pre)==abs(x-P[pre])){
                    flag=false;//冲突了
                    break;
                }
            }
            if(flag){
                P[index]=x;
                hashTable[x]=true;
                generateP(index+1);
                hashTable[x]=false;
            }
        }
    }
}

贪心

简单贪心

贪心法

局部最优解，从而达到全局最优。需要严谨使用贪心法求阶最优化问题需要对采取的策略进行证明。证明方法一般为反证法和数学归纳法。如果想到某个似乎可行的策略，并且自己无法举出反例，那么就勇敢地实现它。

例子：月饼 B1020

#include<cstdio>
#include<algorithm>
using namespace std;
//月饼结构体，静态链表？
struct mooncake{
    double store;//库存
    double sell;//总售价
    double price;//单价
}cake[1010];
//排序，比较函数
bool cmp(mooncake a,mooncake b){
    return a.price>b.price;
}

int main(){
    int n;//n种月饼
    double D;//市场需求量D
    scanf("%d%lf",&n,&D);
    //接收输入库存
    for(int i=0;i<n;i++){
        scanf("%lf",&cake[i].store);
    }
    //接收输入总售价
    for(int i=0;i<n;i++){
        scanf("%lf",&cake[i].sell);
        //算出单价
        cake[i].price=cake[i].sell/cake[i].store;
    }
    //数据填充完整后
    //单价排序
    sort(cake,cake+n,cmp);//价格从高到低排序
    //计算收益
    double ans=0;
    //自高到低遍历每个品种
    for(int i=0;i<n;i++){
        if(cake[i].store<=D){//如果需求高于月饼库存
            D-=cake[i].store;//月饼全部卖出，需求减少
            ans+=cake[i].sell;//该月饼总售价全部变为收益
            cake[i].store=0;//该月饼库存改为0，此步骤不需要
        }else{//月饼的需求低于库存
            ans+=cake[i].price*D;//能赚到的收益
            cake[i].store-=D;
            break;
        }
    }
    printf("%.2f\n",ans);
    return 0;
}

例子：组个最小数 B1023

#include<cstdio>
int main(){
    int count[10];//记录10个数字的个数
    for(int i=0;i<10;i++){
        scanf("%d",&count[i]);
    }
    for(int i=1;i<10;i++){//从0-9种选出不为0的最小数字
        if(count[i]>0){
            printf("%d",i);
            count[i]--;
            break;
        }
    }
    for(int i=0;i<10;i++){
        for(int j=0;j<count[i];j++){
            printf("%d",i);
        }
    }
    return 0;
}

区间贪心

所谓贪心选择性质是指所求问题的整体最优解可以通过一系列局部最优的选择，换句话说，当考虑做何种选择的时候，我们只考虑对当前问题最佳的选择而不考虑子问题的结果。这是贪心算法可行的第一个基本要素。贪心算法以迭代的方式作出相继的贪心选择，每作一次贪心选择就将所求问题简化为规模更小的子问题。对于一个具体问题，要确定它是否具有贪心选择性质，必须证明每一步所作的贪心选择最终导致问题的整体最优解。
当一个问题的最优解包含其子问题的最优解时，称此问题具有最优子结构性质。问题的最优子结构性质是该问题可用贪心算法求解的关键特征。

区间

给出N个开区间，选择尽可能多的开区间，使它们两两没有交集。

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn=110;
struct Inteval{
    int x,y;//开区间左右端点
}I[maxn];
bool cmp(Inteval a,Inteval b){
    if(a.x!=b.x)return a.x>b.x;//左端点从大到小
    else return a.y<b.y;//右端点从小到大
}
int main(){
    int n;
    while(scanf("%d",&n),n!=0){
        for(int i=0;i<n;i++){
            scanf("%d%d",&I[i].x,&I[i].y);
        }
        sort(I,I+n,cmp);//区间排序
        //ans记录不相交区间个数，lastX记录上一个被选中区间的左端点
        int anx=1,lastX=I[0].x;
        for(int i=0;i<n;i++){
            if(I[i].y<=lastX){//该区间的右端点在lastX的左边
                lastX=I[i].x;//以I[i]作为新选中的区间
                ans++;//不相交区间个数加一
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

二分

二分查找

在严格递增序列中找到给定的数x

//left为二分下界，right为二分上届，x为想要查询的数字
#include<cstdio>
//区间[left,right]，初始值为[1,n-1]
int binarySearch(int A[],int left,int right,int x){
    int mid;
    while(left<=right){
        mid=(left+right)/2;
        if(A[mid]==x)return mid;
        else if(A[mid]>x){
            right=mid-1;
        }else{
            left=mid+1;
        }
    }
    return -1;//查找失败，返回-1
}

mid=left+(right-left)/2可以避免溢出。

在严格递增序列中找到第一个大于等于x元素的位置

此时元素x存在的位置，存在区间是一个左闭右开的区间[left,right)

//初始值[left,right],传入0，n
int lower_bound(int A[],int left,int right,int x){
    int mid;
    while(left<right){//如果是left=right时，找到了唯一的位置
        mid=(left+right)/2;
        if(A[mid]>=x){//中间的数>=x
            right=mid;
        }else{
            left=mid+1;
        }
    }
    return left;
}

假设它存在，则它应该在的位置

序列中第一个大于x的元素的位置

//初始值[left,right],传入0，n
int upper_bound(int A[],int left,int right,int x){
    int mid;
    while(left<right){//如果是left=right时，找到了唯一的位置
        mid=(left+right)/2;
        if(A[mid]>x){//中间的数>=x
            right=mid;
        }else{
            left=mid+1;
        }
    }
    return left;
}

以上问题的解决模板

//解决“寻找有序序列第一个满足某条件的元素的位置的固定模板”
//二分区间为左闭右闭的[left,right]，初始值必须是能够覆盖解的所有可能的值
int solve(int left,int right){
    int mid;
    while(left<right){//如果left=right，则找到了唯一位置
        mid=(left+right)/2;
        if(条件成立){//条件成立，则第一个满足条件的元素位置<=mid
            right=mid;//往左子区间查找
        }else{//条件不成立，则第一个满足该条件的元素>mid
            left=mid+1;//往右子区间查找
        }
    }
    return mid;//返回夹出来的位置
}

其他左开右闭的写法与之等价。

二分法拓展

计算根号2的值

const double eps=1e-5;
double f(double x){
    return x*x;
}
double calSqrt(){
    double left=1,right=2,mid;
    while(right=left>eps){
        mid=(left+right)/2;
        if(f(mid)>2){
            right=mid;
        }else{
            left=mid;
        }
    }
    return mid;
}

在闭区间上的单调函数f(x)，求f(x)=0的根

const double eps=1e-5;
double f(double x){
    return ...;
}
double calSqrt(double L,double R){
    double left=L,right=R,mid;
    while(right=left>eps){
        mid=(left+right)/2;
        if(f(mid)>2){
            right=mid;
        }else{
            left=mid;
        }
    }
    return mid;
}

半圆形储水装置的装水问题

#include<cstdio>
#include<cmath>
const double PI=acos(-1.0)；
const double eps=1e-5;
double f(double R,double h){
    double alpha=2*acos((R-h)/R);
    double L=2*sqrt(R*R-(R-h)*(R-h));
    double S1=alpha*R*R/2-L*(R-h)/2;
    double S2=PI*R*R/2;
    return S1/S2;
}
double solve(double R,double r){
    double left=0,right=R,mid;
    while(right-left>eps){
        mid=(left+right)/2;
        if(f(R,mid)>r){
            right=mid;
        }else{
            left=mid;
        }
    }
    return mid;
}
int main(){
    double R,r;
    scanf("%lf%lf",&R,&r);
    printf("%.4f\n",solve(R,r));
    return 0;
}

其他问题略

快速幂

快速幂的递归写法

typedef long long LL;
LL binaryPow(LL a,LL,b,LL m){
    if(b==0){
        return 1;
    }
    if(b%2==1){
        return a*binaryPow(a,b-1,m)%m;
    }else{
        LL mul=binaryPow(a,b/2,m);
        return mul*mul%m;
    }
}

快速幂的迭代写法

typedef long long LL;
LL binaryPow(LL a,LL b,LL m){
    LL ans=1;
    while(b>0){
        if(b&1){//如果b的二进制末尾为1，奇数
            ans=ans*a%m;
        }
        a=a*a%m;
        b>>=1;//二进制右移一位，即b=b/2
    }
    return ans;
}

two pointers

什么是two pointers

序列求合相等问题

求一个递增序列中的两个位置的数，它们的和恰好等于M

while(i<j){
    if(a[i]+a[j]==m){
        printf("%d %d\n",i,j);
        i++;
        j--;
    }else if(a[i]+a[j]<m){
        i++;
    }else{
        j--;
    }
}

序列合并问题

两个递增序列A和B，要求合并为一个递增序列C

int merge(int A[],int B[],int n,int m){
    int i=0,j=0,index=0;
    while(i<n&&j<m){
        if(A[i]<=B[j]){
            C[index++]=A[i++];//如果A小，则把A的元素加进去
        }else{
            C[index++]=B[j++];
        }
    }
    while(i<n)C[index++]=A[i++];//将A剩余元素加入C中
    while(j<m)C[index++]=B[j++];
    return index;
}

归并排序

这里主要讲2路归并排序：将序列凉凉分组，将序列归并为n/2（向上取整）个组，组内单独排序，然后再将组两两归并，生成n/4(向上取整)个组，再组内单独排序，以此类推，直到剩下一个组未知。

递归实现

const int maxn=100;
int merge(int A[],int L1,int R1,int L2,int R2){
    int i=L1,j=L2;
    int temp[maxn],index=0;//临时数组
    while(i<=R1&&j<=R2){
        if(A[i]<=A[j]){
            temp[index++]=A[i++];//如果A小，则把A的元素加进去
        }else{
            temp[index++]=A[j++];
        }
    }
    while(i<R1)A[index++]=A[i++];//将A剩余元素加入C中
    while(j<R2)A[index++]=A[j++];
    for(i=0;i<index;i++){
        A[L1+i]=temp[i];//合并后的序列赋值给A
    }
}
//将array数组当前区间[left,right]进行归并
void mergeSort(int A[],int left,int right){
    if(left<right){
        int mid=(left+right)/2;
        mergeSort(A,left,mid);
        mergeSort(A,mid+1,right);
        merge(A,left,mid,mid+1,right);//左右子区间合并
    }
}

非递归实现

如果只要求给出归并排序每一趟结束时的序列，那么可以使用sort函数代替merge函数，时间允许的情况下。

void mergeSort(int A[]){
    //step为组内元素个数，step/2为左子区间的元素个数，注意等号可以不取
    for(int step=2;step/2<=n;step*=2){
        //每step个元素一组，组内前step/2和组内后step/2个元素进行合并
        for(int i=1;i<=n;i+=step){
            int mid=i+step/2-1;//左子区间元素个数为step/2
            if(mid+1<=n){//右子区间存在元素即合并
                merge(A,i,mid,mid+1,min(i+step-1,n));
            }
        }
    }
}

快速排序

划分区间
//对区间[left,right]进行划分
int Partition(int A[],int left,int right){
    int temp=A[left];//将A[left]保存至临时变量
    while(left<right){//left和right不相遇
        while(left<right&&A[right]>temp){
            right--;//反复左移right
        }
        A[left]=A[right];
        while(left<right&&A[left]<=temp){
            left++;
        }
        A[right]=A[left];
    }
    A[left]=temp;//把temp放在相遇的位置
    return left;//返回相遇的下标
}
快速排序过程
  1. 调整序列中的元素，使当前序列最左端的元素在调整后满足左侧所有元素均不超过该元素，右侧所有元素均大于该元素。
  2. 对该元素的左侧和右侧分别递归进行1的调整，知道当前调整区间的长度不超过1。
快速排序实现
//left和right初始值为序列首尾下标
void quickSort(int A[],int left,int right){
    if(left<right){
        //将[left,right]按照A[left]一分为二
        int pos=Partition(A,left,right);
        quickSort(A,left,pos-1);
        quickSort(A,pos+1,right);
    }
}

生成随机数

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
int main(){
    srand((unsigned)time(NULL));
    for(int i=0;i<10;i++){
        printf("%d ",rand());
        printf("%d",rand()%2);//[0,1]
        printf("%d",rand()%5+3);//[3,7]
        printf("%d ",(int)(round(1.0*rand()/RAND_MAX*50000+10000));
    }
    return 0;
}
随机主元划分
//对区间[left,right]进行划分
int randPartition(int A[],int left,int right){
    //生成[left,right]内的随机数p
    int p=(round(1.0*rand()/RAND_MAX*(right-left)+left);
    swap(A[p],A[left]);//交换A[p],A[left]
    //以下是原先的划分过程，不需要改变
    int temp=A[left];//将A[left]保存至临时变量
    while(left<right){//left和right不相遇
        while(left<right&&A[right]>temp){
            right--;//反复左移right
        }
        A[left]=A[right];
        while(left<right&&A[left]<=temp){
            left++;
        }
        A[right]=A[left];
    }
    A[left]=temp;//把temp放在相遇的位置
    return left;//返回相遇的下标
}

其他

打表

略

活用递推

PAT B1040

#include<cstdio>
#include<cstring>
const int MAXN=100010;
const int MOD=1000000007;
char str[MAXN];//字符串
int leftNumP[MAXN]={0};//每一位左边含P的个数
int main(){
    gets(str);//读入字符串
    //遍历填充左边P的个数
    int len=strlen(str);//长度
    for(int i=0;i<len;i++){//遍历字符串
        if(i>0){//除了0号位以外，先继承上一位的结果
            leftNumP[i]=leftNumP[i-1];
        }
        if(str[i]=='P'){
            leftNumP[i]++;//当前位是P，则加一
        }
    }
    int ans=0,rightNumT=0;
    for(int i=len-1;i>=0;i--){//遍历获取右边T个数以及计算结果
        if(str[i]=='T'){
            rightNumT++;
        }else if(str[i]=='A'){
            ans=(ans+leftNumP[i]*rightNumT)%MOD;//直接算出结果
        }
    }
    printf("%d\n",ans);
    return 0;
}

随机选择算法

略

难锅先生
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法课堂笔记4—贪心算法
dbvz4901的博客
01-03 249
第四章 贪心算法 这里需要注意的便是如何证明贪心算法得到的是最优解。 下面来一些例子： 1. 活动选择问题 现在感觉贪心算法真的是目前遇到过实现起来最简单的一个，但是问题在于用贪心算法得到的解是不是最优解呢？下面来证明： 第一步要证明问题具有最优子结构性质： 还是利用了这种先假设，再反证这种策略。对于最优解，如果这个解中所对应于子...
算法设计与分析——第四章贪心算法复习
qq_46126258的博客
04-16 828
文章目录4.1 贪心概述4.2 活动安排问题4.3 最优装载问题4.4 最优前缀码及哈夫曼算法4.5 多机调度问题 4.1 贪心概述 4.2 活动安排问题 4.3 最优装载问题 4.4 最优前缀码及哈夫曼算法 4.5 多机调度问题 ...
算法知识点整理——第4章 贪心算法（未完）
冲冲冲
02-15 360
第 4 章 贪心算法 顾名思义，贪心算法总是作出在当前看来是最好的选择。也就是说贪心算法并不从整体最优 上加以考虑，它所作出的选择只是在某种意义上的局部最优选择。 往往是局部最优
算法笔记第四章——算法初步
weixin_44972129的博客
10-11 423
排序 选择排序 void select_sort() { for(int i=1;i<=n;i++) { int k=i; for(int j=i;j<=n;j++) //选出[i,n]中最小的元素，下标为k { if(A[j]<A[k]) { k=j; } } //交换A[i]和A[k]
《算法笔记》的一些错误
wordnice2003的博客
08-02 348
《算法笔记》的一些错误 本人研读了晴神的《算法笔记》一书，发现有些错误在勘误中没有指出来，所以在这里列举一下(当然有的可能就是印刷错误) 1、261页上面，应该是node[11111].next=22222;node[22222].next=33333; node[33333].next=-1; 2、264页中间有一段： while(p=-1){ XXX=1； //XXX改成node[i].XXX=1 count++; p=node[p]->next; } 3
c语言 实用基础 算法 笔记 指针
09-19
总结，这份笔记集合了C语言的基础语法、指针操作和算法实践，特别适合初学者。通过阅读和练习，可以逐步建立起对C语言的理解，并提升编程技能。在学习过程中，结合实例代码和注释，能够更好地加深对知识点的把握，为...
第二章笔记和案例.rar
11-14
在本压缩包“第二章笔记和案例.rar”中，我们可以推测其内容主要围绕某一教材或课程的第二章展开，可能包含课堂笔记、讲解案例、练习题解答等多种学习资源。由于没有具体的标签信息，我们将根据一般的学习资料组织...
CISSP学习笔记 CISSP关键知识点总结汇总.zip
01-05
第四章 法律、法规和合规性 第五章 保护资产的安全 第六章 密码学与对称加密算法 第七章 PKI和密码学应用 第八章 安全模型的原则、设计和功能 第九章 安全脆弱性、威胁和对策 第十章 物理安全需求 第十一章 网络安全...
《labuladong算法小抄》2021完整版 共666页
06-17
《labuladong算法小抄》压缩整理-第零章：框架结构之数据结构 一、存储方式 1、根本存储方式：数组（顺序存储）、链表（链式存储） 2、【队列】、【栈】 3、【图】 4、【散列表】：用散列函数把键映射到一个大数组 5...
操作系统原理知识总结.zip
10-05
这份"操作系统原理知识总结.zip"文件显然是为了帮助学习者深入理解操作系统的工作原理，并且特别适用于准备计算机四级考试和考研复习的人。以下是对这份资料可能包含的关键知识点的详细解释： 1. **进程管理**：...
【C语言】二分查找算法代码介绍
Goforyouqp的博客
08-07 1万+
二分法查找是一种在有序数组中查找目标元素的高效算法。它的原理是通过将数组不断地分成两半，然后确定目标元素在哪一半中，从而缩小查找范围，直到找到目标元素或者确定目标元素不存在为止。
浙大版数据结构学习笔记
DanielSYC的博客
06-22 1633
浙大版数据结构学习笔记
6-1 用函数实现插入数到数列指定位置
i_kun_的博客
11-13 1281
PTA6-1 用函数实现插入数到数列指定位置
杭电2034
u010300052的专栏
05-03 506
将处理后的结果存放在另一个数组里面然后输出，注意：输出的每个元素都要跟一个空格，是输出剩下的元素 #include using namespace std; int main() {  void paixu(int n,int a[]);  int a[100],b[100],c[100]={0},m,n,i,j,k,l;  while(cin>>n>>m&&(n!=0||m!=0)
前端面试题
xiaoritai7803的博客
04-08 1100
请写出一个符合 W3C 规范的 HTML 文件，要求 页面标题为「我的页面」 页面中引入了一个外部 CSS 文件，文件路径为 /style.css 页面中引入了另一个外部 CSS 文件，路径为 /print.css，该文件仅在打印时生效 页面中引入了另一个外部 CSS 文件，路径为 /mobile.css，该文件仅在设备宽度小于 500 像素时生效 页面中引入了一个外部 JS 文件，路径为 /...
图类算法总结
热门推荐
ntt5667781的博客
10-06 1万+
图算法
将一个给定的整数插到原本有序的整数序列中，使结果序列仍然有序。
weixin_43912065的博客
05-18 1万+
#include <stdio.h> int main() { int a[7],x,i; printf(“输入一个长度为6的有序数组:\n”); for(i=0;i<=5;i++) scanf("%d",&a[i]); printf(“输入待插入数:”); scanf("%d “,&x); for(i=5;i>=0;i–) { if(a[i]>x) ...
【算法笔记】第四章：算法初步
grefwfdxz
02-24 468
【算法笔记】第四章：入门篇（2）——算法初步 标签（空格分隔）：【算法笔记】 第四章：入门篇（2）——算法初步 文章目录4.1 排序4.1.1 选择排序4.1.2 插入排序4.1.3 排序题与sort函数的应用4.2 散列4.2.1 散列的定义与整数散列4.2.2 字符串hash初步4.3 递归4.3.1 分治4.3.2 递归4.4 贪心4.4.1 简单贪心4.4.2 区间贪心4.5 二分4.5...
基础算法——第四章总结
memoryjdch的博客
05-25 193
4-1 2 查找问题 1.查找有无 使用set，存储只有键 2.查找对应关系，键值对查找，使用map or 字典 set和map的操作： insert find erase change(map) 练习题 349 求两个数组的公共元素，重复的不算（用set） 练习题 350 求两个数组的交集，重复的要算（用map记录频次） 思考：如果两个数组本身有序，是否能利用。 4-3 ...
数据结构与算法第三章笔记
最新发布
04-04
当然，我可以给你介绍一下数据结构与算法第三章的笔记。第三章主要讲解了栈和队列这两种常用的数据结构。 1. 栈（Stack）是一种后进先出（LIFO）的数据结构。它的特点是只能在栈顶进行插入和删除操作。栈的基本操作...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值