嵌入式学习一阶段——C语言：数据结构（7）

最新推荐文章于 2024-10-10 22:17:17 发布
最新推荐文章于 2024-10-10 22:17:17 发布
阅读量85 收藏
点赞数 1
文章标签： 数据结构 学习 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liu1526246800/article/details/132777414
版权

图

图的基本概念

定义：图（graph）是一种非线性结构，形式化的描述：
    graph  = （V，R）
其中，V = {vi | vi 属于某种数据类型 i=0,1,2,3,4,5.....}是图中的元素，vi就是图中的顶点，V就是顶点一个集合！！！
    就是图中的顶点，V就是顶点的集合，n代表 图中的顶点个数
        如果n = 0 , 就说明是一个空集
其中，R代表V集合中任意两个顶点之间的关系。 p(vi，vj)标识顶点vi到vj的路径
    如果两个顶点之间存在路径，我们说关系（vi，vj）是属于R

图的分类

有向图：
    两个顶点之间的路径，“弧”
​
无向图：
    如P（vi,vj）存在，则一定P（vj，vi）也存在
    两点之间的关系，”边“
​
网：
    如果给图的关系<vi,vj>加上一个值w（权值）,称w为弧或边上的权值。带权的图我们叫网
    权值w的具体含义：根据图在不同的领域的应用而定
    如：我们建立一个网。网中每一个顶点代表一个城市，权值就是代表每个城市之间的距离！！
​
顶点度：
    顶点的边或者弧的数量
    有向图： 入度和出度

连通图/非连通图
    在无向图中，若从顶点vi到顶点vj有路径存在，则称vi和vj是连通
    若图G中任意两个顶点都是连通的，我们则可以说G是连通图，否则非连通图
​
路径：
    从某个顶点到另外一个顶点是否存在一个路径
    直接路径，间接路径

图的存储方式

”数组表示法“：邻接矩阵
”链接法“：邻接表
”十字链表“
”邻接多重表“

邻接矩阵（数组表示法）

G(V,R); // V表示的是顶点的集合，R表示的关系的集合
可以用两个数组来存储一个图！！
一个数组用来存储V 存每一个顶点
一个数组用来存储R 存储两个顶点之间的关系，两个顶点之间的权值

int data 100; //用来存储两个顶点之间的关系 char v[6] = {'A','B','C','D','E','F'}; //图中的顶点集合 <v0,v1> data0 = 6; ...... 第i行，表示从那个顶点出发（边的起始点） 第j列，表示一个路径上的终点

创建一个图：
    #define MAX 100
    struct graph
    {
            char v[MAX];   //表示这个图里面最多可以存储100个顶点
            int data[MAX][MAX]; //表示两个顶点之间的权值
            int num;   //表示图中顶点的个数
    };

邻接表

用链式结构去存储一个图！！ 所谓的邻接表，就是将图中的每一个顶点V与由V发出的边或者弧构成一个单链表

数据类型：

    终点元素结构体
    struct Endnode
    {
        int stop_index; //终点元素的下标
        int w;   //代表边上的权值
        struct Endnode * next;   //指向下一条边
    }
​
    顶点元素的结构体
    struct vertex
    {
        char data ;   //顶点元素的数据值
        struct * first;   //指向终点元素的第一条边
    }
​

图的遍历

广度优先搜索和深度优先搜索 图的遍历就是树的遍历的推广，是按照某种规则（或次序）访问图中各个顶点一次，有且仅有一次的操作，也是将网状解决按照某种规则线性化的过程 对图的遍历通常有两种“深度优先”和”广度优先“，这两者都是人工智能（AI）的基础 int visit[]; //用来表示图中的一个顶点还没有被访问 visit[i] == 0; //表示i对应的顶点还没有被访问 visit[i] == 1; //表示i对应的顶点已经被访问过了

深度优先搜索（DFS：depth first search）

初始时，图中的各个顶点都还没有被访问过，假设以图中V0这个顶点出发，先访问V0，在visit数组中标识V0这个顶点已经被访问过了。接下来要去找V0的邻接点vi（先判断vi有没有被访问过），如果被访问过，访问vi，在visit数组中标识vi这个顶点已经被访问了，再去找vi的邻接点...........如果vi的所有的邻接点都被访问了，返回v0，找到v0下一个邻接点

判断这个点能不能去（如果没有路径就不能去吧） 判断这个点该不该去（如果有路径但是被访问过了，就不能去吧）

算法是如何实现的： int visit[p->num] ={0} ; //表示所有顶点都没有被访问过 1： 表示被访问了 0： 表示没有被访问 DFS(p,vo) //p表示图，v0顶点的下标 (1)、先去访问v0，并标记v0 printf p->v[v0]; visit[v0] = 1;

(2)、找v0的下一个邻接点vi
for(vi=0;vi<p->num;vi++)
{
    p->data[v0][vi]
    判断这个点能不能去（如果没有路径就不能去吧）
    判断这个点该不该去（如果有路径但是被访问过了，就不能去吧）
    DFS(p,vi);
​
}
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAX 100
#define VER_BIG 999999999

int visit[MAX];//表示顶点是否被访问，
//0：未被访问，1：已被访问
//图类型
typedef struct graph
{
    char v[MAX];//表示这个图里面最多可以存放MAX个顶点
    int data[MAX][MAX];//表示两个顶点之间的权值
    int num;//图里面的顶点个数
}graph;

//找到字符x的下标
int find_i(graph* g,char x)
{
    if(g==NULL)
    {
        return -1;
    }
    int i;
    for(i=0;i<g->num;i++)
    {
        if(g->v[i]==x)
        {
            return i;
        }
    }
    return -1;
}


//创建一个邻接矩阵
graph* initgraph(void)
{ 
    int i,j,d,n;
    graph* g=malloc(sizeof(graph));
    g->num=0;
    printf("输入顶点\n");
    char ch;
    while(1)
    {
       scanf("%c",&ch);
       
       if(ch=='#')
       {
            break;
       }    
        g->v[g->num]=ch; //把顶点存储到一维数组里面去
        g->num+=1;   
    }
    getchar();
    n=g->num;
    for(i=0;i<g->num;i++)
    {
        visit[i]=0;
    }
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {          
        g->data[i][j]=VER_BIG;
                       
        }
    }

    char start,stop;
    int w;
    int start_i,stop_i;
    while(1)
    {
        printf("输入边<a,b>及边权\n");
        scanf("%c%c%d",&start,&stop,&w);        
        if(start=='#'||stop=='#'||w==0)
        {
            break;
        }
        getchar();
        start_i=find_i(g,start);
        stop_i=find_i(g,stop);
        if(stop_i==-1||start_i==-1)
        {
            continue;
        }
        //无向图
        g->data[start_i][stop_i]=w;
        g->data[stop_i][start_i]=w;
        
    }

    return g;
}



//输出邻接矩阵
void print_graph(graph* g)
{
    printf("------邻接矩阵------\n");
    int i,j;
    printf("  ");
    for(i=0;i<g->num;i++)
    {
        printf("%c ",g->v[i]);
    }
    printf("\n");
    for(i=0;i<g->num;i++)
    {
        printf("%c ",g->v[i]);
        for(j=0;j<g->num;j++)
        {
            if(g->data[i][j]==VER_BIG)
            {
                printf("# ");
            }
            else
            {
                printf("%d ",g->data[i][j]);
            }
           
        }
        printf("\n");
    }
    printf("------------\n");
}
//深度优先搜索
//i:顶点下标
void DFS(graph* g,int i)
{
    //访问vi
    printf("%c",g->v[i]);
    visit[i]=1; 

    //访问下一个邻接点
    int j;
    for(j=0;j<g->num;j++)
    {
        //(1)判断这个点能不能去(是否有路径)
        //(2)判断这个点该不该去(是否已访问)
        if(g->data[i][j]!=VER_BIG&&visit[j]==0)
        {
            printf("->");
            DFS(g,j);
        }
    }
}


int main()
{  
    graph* g=initgraph(); 
    print_graph(g);
    DFS(g,0);
}

广度优先搜索(BFS:Breadth first search)

广度优先搜索类似于树的层次遍历，初始时图中的各个顶点都没有被访问 从图中的一个顶点v0出发，先让v0入队 while(队列不为空) { 让队首元素出队 接下来就是找队首元素的所有邻接点 { 判断这个点能不能去（如果没有路径就不能去吧） 判断这个点该不该去（如果有路径但是被访问过了，就不能去吧） 如果这两个条件都满足的话，将这个点进行入队操作 } }

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAX 100
#define VER_BIG 999999999

int visit[MAX];//表示顶点是否被访问，
//0：未被访问，1：已被访问
int q[MAX];//队列，先进先出

//图类型
typedef struct graph
{
    char v[MAX];//表示这个图里面最多可以存放MAX个顶点
    int data[MAX][MAX];//表示两个顶点之间的权值
    int num;//图里面的顶点个数
}graph;

//找到字符x的下标
int find_i(graph* g,char x)
{
    if(g==NULL)
    {
        return -1;
    }
    int i;
    for(i=0;i<g->num;i++)
    {
        if(g->v[i]==x)
        {
            return i;
        }
    }
    return -1;
}


//创建一个邻接矩阵
graph* initgraph(void)
{ 
    int i,j;
    graph* g=malloc(sizeof(graph));
    g->num=0;
    printf("输入顶点\n");
    char ch;
    while(1)
    {
       scanf("%c",&ch);     
       if(ch=='#')
       {
            break;
       }    
        g->v[g->num]=ch; //把顶点存储到一维数组里面去
        g->num+=1;   
    }
    getchar();
   
    for(i=0;i<g->num;i++)
    {
        visit[i]=0;
    }
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {          
        g->data[i][j]=VER_BIG;
                       
        }
    }

    char start,stop;
    int w;
    int start_i,stop_i;
    while(1)
    {
        printf("输入边<a,b>及边权\n");
        scanf("%c%c%d",&start,&stop,&w);        
        if(start=='#'||stop=='#'||w==0)
        {
            break;
        }
        getchar();
        start_i=find_i(g,start);
        stop_i=find_i(g,stop);
        if(stop_i==-1||start_i==-1)
        {
            continue;
        }
        g->data[start_i][stop_i]=w;
        g->data[stop_i][start_i]=w;
        
    }

    return g;
}



//输出邻接矩阵
void print_graph(graph* g)
{
    printf("------邻接矩阵------\n");
    int i,j;
    printf("  ");
    for(i=0;i<g->num;i++)
    {
        printf("%c ",g->v[i]);
    }
    printf("\n");
    for(i=0;i<g->num;i++)
    {
        printf("%c ",g->v[i]);
        for(j=0;j<g->num;j++)
        {
            if(g->data[i][j]==VER_BIG)
            {
                printf("# ");
            }
            else
            {
                printf("%d ",g->data[i][j]);
            }
           
        }
        printf("\n");
    }
    printf("------------\n");
}


//广度优先搜索
//i:顶点下标
void BFS(graph* g,int i)
{
    //q[MAX] //队列,先进先出
    int head;//队首元素
    //访问vi
    visit[i]=1; 
    int front=0,rear=0,sum=0;//队头，队尾以及队列元素个数
    q[front]=i;//入队
    sum+=1;
    int ans;
    while(sum>0)
    {
        head=q[front];//访问队头
         //访问下一个邻接点
        int j;
        for(j=0;j<g->num;j++)
        {
            //(1)判断这个点能不能去(是否有路径)
            //(2)判断这个点该不该去(是否已访问)
            if(g->data[head][j]!=VER_BIG&&visit[j]==0)
            {
               q[++rear]=j;//入队
               sum++;//队列元素+1
               visit[j]=1;//标记已被访问
            }
        }
        ans=q[front++];//出队
        sum-=1;//队列元素-1
        if(sum==0)//队列的最后一个元素
        {
            printf("%c",g->v[ans]);
        }
        else
        {
            printf("%c->",g->v[ans]);
        }
        
    }
   
}


int main()
{  
    graph* g=initgraph(); //创建邻接矩阵
    print_graph(g);//输出邻接矩阵
    BFS(g,0);//广度优先搜索，从下标0开始
}

最短路径问题

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAX 100
#define VER_BIG 9999999
//图类型
typedef struct graph
{
    char v[MAX];//表示这个图里面最多可以存放MAX个顶点
    int data[MAX][MAX];//表示两个顶点之间的权值
    int num;//图里面的顶点个数
}graph;

//找到字符x的下标
int find_i(graph* g,char x)
{
    if(g==NULL)
    {
        return -1;
    }
    int i;
    for(i=0;i<g->num;i++)
    {
        if(g->v[i]==x)
        {
            return i;
        }
    }
    return -1;
}


//创建一个邻接矩阵
graph* initgraph(void)
{ 
    int i,j;
    graph* g=malloc(sizeof(graph));
    g->num=0;
    printf("输入顶点\n");
    char ch;
    while(1)
    {
       scanf("%c",&ch);     
       if(ch=='#')
       {
            break;
       }    
        g->v[g->num]=ch; //把顶点存储到一维数组里面去
        g->num+=1;   
    }
    getchar();
    for(i=0;i<g->num;i++)
    {
        for(j=0;j<g->num;j++)
        {          
        g->data[i][j]=VER_BIG;
                       
        }
    }

    char start,stop;
    int w;
    int start_i,stop_i;
    while(1)
    {
        printf("输入边<a,b>及边权\n");
        scanf("%c%c%d",&start,&stop,&w);        
        if(start=='#'||stop=='#'||w==0)
        {
            break;
        }
        getchar();
        start_i=find_i(g,start);//获取顶点下标，弧的头顶点
        stop_i=find_i(g,stop);//获取顶点下标，弧的尾顶点
        if(stop_i==-1||start_i==-1)//没有找到顶点位置
        {
            continue;
        }
        g->data[start_i][stop_i]=w;//存放有向图邻接关系
        //g->data[stop_i][start_i]=w;
        
    }

    return g;
}

//输出邻接矩阵
void print_graph(graph* g)
{
    printf("------邻接矩阵------\n");
    int i,j;
    printf("  ");
    for(i=0;i<g->num;i++)
    {
        printf("%c ",g->v[i]);
    }
    printf("\n");
    for(i=0;i<g->num;i++)
    {
        printf("%c ",g->v[i]);
        for(j=0;j<g->num;j++)
        {
            if(g->data[i][j]==VER_BIG)
            {
                printf("# ");
            }
            else
            {
                printf("%d ",g->data[i][j]);
            }
           
        }
        printf("\n");
    }
    printf("------------\n");
}

//Dijkstra 有三个辅助向量
int S[MAX]; 
/*
    s[i]=0  源点V 到 Vi的最短路径没有求出
    s[i]=1  源点V 到 Vi的最短路径已经求出
*/
int Dist[MAX];             //保存的是v到vi的最短路径的长度

char Path[MAX][MAX];  
//Path[i]   保存是从源点V0 到 Vi 的最短路径上所经历的“顶点”
//Path[i][0] = 'A'
//Path[i][1] = 'B'
//Path[i][2] = 'C'
//.......
//Path[i][n] = 'vi'
//Path[i][n+1] = '\0'
//求最短路径，Dijsktra算法
void Dijkstra(graph* g,int v0)
{
    int i,j;
    int n=1;//已经找到的边数
    //1.初始化,三个辅助数组
    for (i=0;i<g->num;i++)
    {
        S[i]=(i==v0?1:0);

        Dist[i]=g->data[v0][i];//从源点v0到vi的距离(初始时不借助其他点)
        Path[i][0]=g->v[v0];//从源点v0出发
        if(Dist[i]!=VER_BIG)//如果源点v0可以直接到达点vi
        {
            Path[i][1]=g->v[i];
            Path[i][2]='\0';//字符串末尾加一个'\0'标识结束
        }
        else//如果源点v0不可以直接到达点vi
        {
            Path[i][1]='\0';
        }
    }
    //有g->num的点，找g->num-1条边
    while(n++<g->num)
    {
         //2.找到S[i]==0的Dist[i]的最小值
        int Dist_min=VER_BIG;//Dist[i]最小值
        int w;//记录Dist最小值的下标
        for(i=0;i<g->num;i++)
        {
            if(S[i]==0)//最短路径未被求出
            {
                if(Dist[i]<Dist_min)
                {
                    Dist_min=Dist[i];
                    w=i;//当前最短路径的记录下标
                }
            }
        }
        S[w]=1;//w最短路径已被找到
        //3.更新，如果Dist[w]+<w,u><Dist[u]；
        //即通过w点可以有一条更短的路径到达目标点vu；
        for(int u=0;u<g->num;u++)
        {
            if(S[u]==0)//点u未找到最短路径
            {   //检查源点到点u的当前路径长度
            //与源点到当前最短路径的点的长度+该点到点u的路径长度的大小关系
                if(Dist[w]+g->data[w][u]<Dist[u])
                {
                    Dist[u]=Dist[w]+g->data[w][u];
                    //path[u]---->path[w]+u
                    strcpy(Path[u],Path[w]);
                    int l=strlen(Path[u]);
                    Path[u][l]=g->v[u];
                    Path[u][l+1]='\0';
                }
            }
        }
    }
    //输出最短路径
    for(i=0;i<g->num;i++)
    {
        printf("%c -> %c=%d :",g->v[v0],g->v[i],Dist[i]);
        for(j=0;Path[i][j]!='\0';j++)
        {        
            printf("%c ",Path[i][j]);
        }
        printf("\n");
    }
       
}



int main()
{  
    graph* g=initgraph(); //创建邻接矩阵
    print_graph(g);//输出邻接矩阵    
    Dijkstra(g,0);//输出最短路径
}

独孤旅人1412
关注
嵌入式学习阶段总结 ———— C语言基础部分
J_u_n_e_s_的博客
01-06 77
本文的写作基于前段时间开始的嵌入式学习，对一定阶段做出的个人小结。
专插本————C语言笔记
04-29
C语言是一种广泛使用的编程语言，尤其适合系统编程和嵌入式开发。它的语法简洁明了，但同时也包含了一些复杂的概念。以下是对C语言基础知识的详细解释： 1. **程序结构**： - **顺序结构**：按照代码的顺序逐行...
嵌入式学习一阶段——C语言：排序（二）
liu1526246800的博客
07-19 77
【代码】嵌入式学习一阶段——C语言：排序（二）
嵌入式面试——C语言和数据结构篇（二）
yxun403的博客
10-09 1304
在C语言中，关键字static有三个明显的作用： 1>在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。 2>在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。 3>在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。
嵌入式开发之路——C语言阶段（华清远见）
weixin_44081053的博客
03-23 1040
为什么会选择嵌入式开发？ 我现在已经毕业两年了，大学的专业是软件工程，学习的课程有软件前段和后端，主要学习的是JAVA方向。到毕业之后开始找工作发现，虽然基础知识学习的不错，但是距离企业开发的标准还有很大的距离。多次求职未果之后，我选择了非对口的工作。工作两年之后我发现这样的工作和生活不是我想要的，每月四五千块的工资一个人生活还是无忧的，但是男人的肩膀未来是要扛起一个家的，现实的问题一下让我清醒，所以我果断辞去现有的工作，准备报班深造自己的技术。 --------------------...
嵌入式学习第9天——C语言运算符，程序设计结构，输入输出缓冲机制
weixin_64313142的博客
07-25 1171
C语言学习，运算符，顺序结构、选择结构、循环结构，输入输出缓存机制
嵌入式linux C整理——C语言基础
bill-zhao的博客
10-25 562
  最近秋招刚拿了几个offer，想记录一下秋招时期个人整理的一些笔/面试笔记，作为备份供自己回顾，同时也分享给学习嵌入式相关行业的其他需要的同行者~ 一.数组 1.定义   int a[5]，表示数组有5个int类型元素，首元素是a[0]。 1.1输入输出 int a[100]; scanf("%d", &n); for(i=0; i<n; i++) scanf(“%d”, &a[i]); for(i=0; i<n; i++) printf(“%d”, a[i]); 2
嵌入式八股文（一）——C语言基础篇【理论干货，复习好用】运算符、关键字
qq_57568928的博客
04-28 2201
嵌入式八股文——C语言基础，内容包含对运算符、关键字的解释和相关常见面试题，希望对你有所帮助
嵌入式C语言——学习笔记
m0_52867233的博客
01-15 498
笔记——嵌入式C语言
嵌入式学习路线
热门推荐
QWERT520的专栏
06-05 4万+
任何学习一定要有路线图，根据同学，网上搞C和搞硬件的，结合自己的思考整理了一份嵌入式学习路线，之前整理了一份不是很满意，现在又整理了一份。 嵌入式开发学习路线份三个阶段
《嵌入式C语言自我修养：从芯片、编译器到操作系统》读书笔记
szxhcljyjsjdff的博客
05-30 807
在CPU内部，Cache和寄存器的电路比内存DRAM复杂了很多，会占用很大的芯片面积，如果大量使用，芯片发热量会急剧上升，所以在CPU内部寄存器一般也就几十个，靠近CPU的一级Cache也就几十千字节。在CPU内部也是如此，CPU内部的数字电路是靠时钟驱动来工作的，既然每条指令的执行时钟周期数不变，即执行每条指令都需要3个时钟周期，但是我们可以通过缩短一个时钟周期的时间来提升效率，即减少每条指令所耗费的时间。流水线是靠指令的并行来提升性能的，第一条指令还没有执行完，下面的第二条指令就开始取指、译码了。
程序设计入门——C语言：C语言基础
随着UNIX操作系统的普及，C语言也逐渐流行开来，成为了广泛应用于系统编程和应用程序开发的语言之一。 ## 1.2 C语言在编程领域的应用 C语言在操作系统、嵌入式系统、游戏开发、数据库系统等方面有着广泛的应用。...
程序设计入门——C语言：指针基础知识
# 1. C语言简介 ## 1.1 程序设计和编程语言的基础概念 在程序设计中，编程语言是程序员和计算机交流的工具。编程语言由一组规则和符号组成，用于定义计算机...现今，C语言在系统软件、应用软件、嵌入式系统等领域有着
java-02 数据结构-队列
wyh106115的博客
10-09 725
在Java中，队列是一种常见的数据结构，用于在保持顺序的同时存储和检索数据。Java提供了java.util.Queue接口，它的常见实现包括ArrayDeque、LinkedList和PriorityQueue等。
算法与数据结构--二分查找
bjjx123456的博客
10-03 423
简单说就是每次二分取中间值，然后将中间值与我们要找的值比较，如果比它大就移动左边界到其右侧，如果比它小就移动右边界到其左侧。
数据结构（排序）
最新发布
m0_74859128的博客
10-10 480
一、定义排序是将一组数据元素按照某个关键字的值递增或递减的次序重新排列的过程。这个关键字是数据元素中的某个数据项，通过比较关键字的大小来确定数据元素的先后顺序。二、目的便于查找例如在一个有序数组中查找某个元素，使用二分查找等算法效率更高。如果数据是无序的，可能只能进行顺序查找，时间复杂度较高。数据呈现的有序性在很多应用场景中，如成绩排名、文件按时间顺序排列等，需要数据以有序的形式展示，以便于人们理解和分析。三、分类内部排序和外部排序内部排序指待排序的数据元素全部存放在计算机内存中的排序算法。
【数据结构】顺序表应用---删除偶数
2301_79982543的博客
10-10 176
如果两个偶数是连在一起的，那移动过后第i位依旧是偶数，所以需要i--检查再次检查第i位的情况 ，如图所示。你的任务是创建一个顺序表，输入多个整数存入表中，删除其中的偶数，然后输出表中的所有数据。今天的分享就到这里啦~~希望对您有所帮助！下次再见啦~~ヾ(￣▽￣)Bye~Bye~样例输入： 10 34 23 9 10 10 17 31 32 1 15。采用顺序表存储一批整数，去掉其中所有的偶数。第2行：顺序表中的数据，每个整数用空格隔开。第1行：顺序表中数据个数。第2行：输入n个整数。
【数据结构-栈】【位运算优化】力扣3170. 删除星号以后字典序最小的字符串
sjsjs11的博客
10-10 209
我们按顺序遍历字符串，在遍历过程中，如果字符不为*，那么就在栈数组对应的栈推入这个字符的位置。在循环字符串s的过程中，字符不为星号，则让mask对应位置变为1，说明这个字母存在。我们查找到字典序最小的字符所处的栈后，栈顶的元素代表这当前最靠右的字符的位置，我们在字符串s中将这个字符。：O(n+∣Σ∣)，其中 n 是 s 的长度，∣Σ∣ 为字符集合的大小，本题字符均为小写字母，所以 ∣Σ∣=26。：O(n∣Σ∣)，其中 n 是 s 的长度，∣Σ∣ 为字符集合的大小，本题字符均为小写字母，所以 ∣Σ∣=26。
C语言：结构化、高效与可移植性——谭浩强经典解析
此外，C语言的数据结构设计也非常灵活，程序员可以根据需求创建复杂的数据结构，实现功能强大的程序。 C语言的另一个显著特性是高度的可移植性。由于它的语法相对简洁且标准统一，用C语言编写的程序可以在不同型号...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值