数据结构课程设计公交系统

最新推荐文章于 2024-06-04 14:02:05 发布

土豆侠_

最新推荐文章于 2024-06-04 14:02:05 发布

阅读量6.6k

点赞数 30

文章标签：数据结构课设作业源代码公交线路查询

本文链接：https://blog.csdn.net/weixin_44728725/article/details/107140930

版权

大家好！这是我的第一篇文章，是将这学期的数据结构课设报告整理出来的。可能还有些小错误，还请多多指正。

一、引言

（一）课题描述

本程序是一个控制台程序，模拟城市公交系统，程序中保存了城市的公交线路和公交站点信息。公交线路和站点满足以下条件；

若两站点之间有一条或多条公交线路直接到达则连通；
每条公交线路经过若干站点；
相同的路线有上行和下行两条公交线路，公交线路都是单向行驶（有向图）。

（二）设计要求

实现站点信息查询，即输出经过该站点的全部车辆；
实现公交信息查询，即输出该车的所有站点；
实现线路信息查询，即输出从起始站点到终点站的线路；
从文件中读出站点消息，公交线路信息等数据；
添加公交、站点、线路信息；
删除公交、站点、线路信息。

二、总体设计

（一）数据格式

用多个文件存储数据

文件名station.txt，保存站点信息格式为：
文件名buses.txt，保存站点信息格式为：
文件名routes.txt，保存站点信息格式为：

（二）数据结构

1.图的存储

当保存图结构时，既要保存顶点信息，也要保存边。图用数组来存储。用一维数组来保存顶点的集合，使用二维数组来保存边的集合。

2.公交路线图

公交路线图可以看作是一个带权的有向图，使用邻接表来保存，所有站点即为图的顶点；当两个站点之间设有公交时，表示两个顶点相连，为一条边；两个站点之间的距离，即为边的权值。
公交线路

（三）结构体定义

公交线路Bus，保存char类型公交名称与int起点和终点；
站点Station，保存char类型站点名与指向下条路线的指针；
线路Route，保存这条路的起始站点、公交号、边的权值等；
路径Path，保存路径中站点数，路径中各站点数组站点与站点之间的路径数组，换乘次数等；
公交地图BusMap，保存公交线路数组、站点数组、站点数和公交线路数。

//代表一个公交车的线路
typedef struct Bus
{
    char* name; //公交名
    int start;  //起点
    int end;    //终点
}Bus;
//代表一个站点
typedef struct Station
{
    char* station; //站点名
    struct Route* routes; //从该站点出发的所有下行路线的链域
}Station;
//代表公交车中的一个路段（邻接表结点）
typedef struct Route
{
    int station; //指向的站点索引号
    int bus; //公交索引号
    bool visited;//
    int distance; //两站之间的距离
    struct Route* next; //起始站点相同的，下一条下行路线
}Route;
typedef struct Path
{
    int station_num;//路径中站点数
    char** stations;//路径中各站点数组
    char** buses; //站点与站点之间的路径数组
    int transfer;//换乘次数
    int need_time;//所需时间
    struct Path* next;//指向下一个路径结点
}Path;
//存储整个公交地图信息
typedef struct BusMap
{
    Bus* buses; //公交线路数组
    Station* stations; //站点数组
    int station_num; //站点数
    int bus_num; //公交线路数
}BusMap;

（四）全局定义

#define  Bus_num 10
#define Station_num 20
#define Route_num 50
#define None -1
#define Status int
#define ST_FAIL -1
#define ST_OK 1
#define Vexnum 200
char* BUS[Bus_num][3];//公交信息数组
char* STATION[Station_num];//站点信息数组
int ROUTE[Route_num][4];//路线信息数组
int Bus_Num=0;
int Station_Num=0;
int Route_Num=0;

三、详细设计

（一）函数调用关系

main函数作为程序的入口函数，根据提示输入相关信息来实现各种功能。
main

（二）创建公交线路

定义全局变量g_sMap,用于保存公交地图信息，定义并实现函数LoadMapDate,用于实现创建图。函数实现加载公交线路信息和站点信息。

加载公交线路信息，将公交线路数组信息加载到g_sMap中的公交线路数组中；
加载站点信息，将站点数组中的信息加载到g_sMap中的站点数组中；
添加公交车信息，创建AddBus（char* bus,char* pStaet,char* pEnd）函数；
添加每个路段的信息，创建AddRoute（char* pBus,char* pStart,char* pEnd,int distance）函数

void LoadMapDate();//函数中实现加载公交线路信息和站点信息
int FindBus( char* bus);
int GetBus( char* bus);
int FindStation( char* station);
int GetStation( char* station);
void AddBus( char* bus,  char* pStart,  char* pEnd);
Status AddRoute( char* pBus,  char* pStart, char* pEnd, int distance);

void LoadMapDate()
{
    g_sMap.bus_num = Bus_Num;
    g_sMap.buses = (Bus*)malloc(sizeof(Bus) * Bus_Num);
    for (int i = 0; i < Bus_Num; i++)
    {
        g_sMap.buses[i].name = (char*)malloc(sizeof(char*) *strlen(BUS[i][0]));
        strcpy(g_sMap.buses[i].name,BUS[i][0]);
        g_sMap.buses[i].start = g_sMap.buses[i].end = None;
        //cout<<g_sMap.buses[i].name<<endl;
    }
    //加载站点信息，将站点数组中的信息加载到g_sMap中的站点数组中
    g_sMap.station_num = Station_Num;
    g_sMap.stations = (Station*)malloc(sizeof(Station) * Station_Num);
    for (int i = 0; i < Station_Num; i++)
    {
        g_sMap.stations[i].station = (char*)malloc(sizeof(char*) * strlen(STATION[i]));
        strcpy(g_sMap.stations[i].station, STATION[i]); //初始化站点名
        g_sMap.stations[i].routes = NULL;//下行线路暂时设置为空
    }
    //添加公交线路信息
    for (int i = 0; i < Bus_Num; i++)
    {
        AddBus(BUS[i][0], BUS[i][1], BUS[i][2]);
    }
    //添加路段信息
    for (int i = 0; i < Route_Num; i++)
    {
        AddRoute(BUS[ROUTE[i][0]][0], STATION[ROUTE[i][1]], STATION[ROUTE[i][2]], ROUTE[i][3]);
    }
}
//用于查找Bus对象返回索引号
int FindBus(char* bus)
{
    for (int i = 0; i < g_sMap.bus_num; i++)
    {
        if (strcmp(g_sMap.buses[i].name, bus) == 0)
        {
            return i;
        }
    }
    return None;
}
//用于查找公交线路，返回索引号
int GetBus( char* bus)
{
    int nBus = FindBus(bus);
    return nBus;
}
//用于查找Station对象返回索引号
int FindStation(char* station)
{
    for (int i = 0; i < g_sMap.station_num; i++)
    {
        if (strcmp(g_sMap.stations[i].station, station)==0)
            return i;
    }
    return None;
}
//用于插入一个站点返回编号
int GetStation( char* station)
{
    int nStation = FindStation(station);
    return nStation;
}
//添加公交车信息
void AddBus(char* bus, char* pStart, char* pEnd)
{
    int nBus = GetBus(bus);
    int nStart = GetStation(pStart);
    int nEnd = GetStation(pEnd);
    Bus* pBus = g_sMap.buses + nBus;
    pBus->start = nStart;
    pBus->end = nEnd;
}
//用于添加每个路段的信息形成邻接表
Status AddRoute( char* pBus, char* pStart,char* pEnd,int distance)
{
    int nBus = GetBus(pBus);
    int nStart = GetStation(pStart);
    int nEnd = GetStation(pEnd);
    //插入起点的出边链域
    Station* pStStation =&g_sMap.stations[nStart];
    Route* pStRoute =pStStation->routes;
    //判断该边是否已存在，如果已经不存在，则不插入
    while (pStRoute != NULL && pStRoute->next != NULL)
    {
        if (pStRoute->bus == nBus && pStRoute->station == nEnd)
            return ST_FAIL;
        pStRoute = pStRoute->next;
    }
    //新建新的路线
    Route* pNewRoute = (Route*)malloc(sizeof(Route));
    pNewRoute->bus = nBus;
    pNewRoute->station = nEnd;
    pNewRoute->distance = distance;
    pNewRoute->next = NULL;
    //若是其实顶点的第一条边
    if (pStStation->routes == NULL)
    {
        pStStation->routes = pNewRoute;
    }
    else
    {
        pStRoute->next = pNewRoute;

    }
    return ST_OK;
}

（三）查询信息

int QueryStation(int s);
int QueryBus(int pBus);
bool HasPath(char* pStart, char* pEnd);
void ClearVisited();
bool HasPath(int nStart, int nEnd, bool* visited);
int QueryRoutes(char* pStart, char* pEnd,  int transfer, Path* paths);

1.查询公交线路

编写QueryBus（int pBus）函数返回站点数和路线

//查询线路信息，返回线路中站点数和路线
int QueryBus(int pBus)
{
    int nBus=pBus;
    if(nBus!=None){
        int route[30];
        int t=0;
        for(int i=0; i<Route_Num; i++){
            if(ROUTE[i][0]==nBus){
                if(t==0){
                    route[t]=ROUTE[i][1];
                    route[++t]=ROUTE[i][2];
                }
                else
                    route[t]=ROUTE[i][2];
                t++;
            }
            else if(t)
                break;
        }
        cout<<BUS[nBus][0];
        cout<<"从["<<STATION[route[0]]<<"]开往["<<STATION[route[t-1]]<<"]:";
        cout<<"共经过"<<t<<"个站点"<<endl;
        for(int i=0; i<t; i++)
        {
            if(!i)
                cout<<STATION[route[i]];
            else
                cout<<"->"<<STATION[route[i]];
        }
        cout<<endl;
    }
    return true;
}

2.查询站点信息

编写QueryStation(int s)函数，输出该站点所经过线路信息

//查询站点信息，输出该站点所经线路信息
int QueryStation(int s)
{
    int nStart=s;
    int bus[Bus_Num];
    int i=0,j;
    //遍历该站点领接表找到所有从该站点驶出的车
    Route* temp = g_sMap.stations[nStart].routes;
    while (temp != NULL)
    {
        j=temp->bus;
        bus[i]=j;
        i++;
        temp = temp->next;
    }
    //遍历所有邻接表找到所有驶入该站点的车
    for(int k=0; k<g_sMap.station_num; k++)
    {
        temp=g_sMap.stations[k].routes;
        while (temp != NULL)
        {
            if(temp->station==nStart)
            {
                j=temp->bus;
                int a=0;
                for(int b=0; b<i; b++)
                    if(bus[b]==j)
                        a++;
                if(!a)
                    bus[i++]=j;
            }
            temp = temp->next;
        }
    }
    printf("%s   共有%d辆车经过˝:\n\n",STATION[s],i);
    for(j=0; j<i; j++)
        cout<<g_sMap.buses[bus[j]].name<<endl;
    return true;
}

3.查询两个站点之间的路线信息

编写QueryRoutes(char* pStart, char* pEnd, const int transfer, Path* paths)函数，
编写HasPath（char* pStart,char* pEnd)
编写递归函数HasPath（int nStart，int nEnd,bool* visited)

bool HasPath(char* pStart, char* pEnd)
{
    if(FindStation(pStart)==None||FindStation(pEnd)==None)
        return None;
    bool *visited=(bool*)malloc(sizeof(bool)*g_sMap.station_num);
    for(int i=0; i<g_sMap.station_num; i++)
        visited[i]=false;
    ClearVisited();
    int nStart=FindStation(pStart);
    int nEnd=FindStation(pEnd);
    bool bHas=HasPath(nStart,nEnd,visited);
    free(visited);
    return bHas;
}

bool HasPath(int nStart, int nEnd, bool* visited)
{
    //判断站点是否存在
    if(nStart==nEnd)
        return true;
    bool bHas = false;
    visited[nStart] = true;
    //遍历当前结点全部的边
    Station *psStation=&g_sMap.stations[nStart];
    Route *psRoute=psStation->routes;
    while (psRoute != NULL)
    {
        //当前边指向的结点
        int nNode = psRoute->station;
        //若访边未被访问，且对应的结点不在栈中，则递归调用函数判断nNode和nEnd之间是否连通，若连通则标志为true
        if (psRoute->visited == false && visited[nNode] == false)
        {
            psRoute->visited = true;
            if (HasPath(psRoute->station, nEnd, visited) == true)
            {
                bHas = true;
                break;
            }
        }
        psRoute = psRoute->next;
    }
    //若当前nStart结点没有一条边可以与nEnd结点连通，则弹出该结点，并将该结点所有边都标记为未访问
    if (bHas == false)
    {
        psRoute = psStation->routes;
        while (psRoute != NULL)
        {
            psRoute->visited = false;
            psRoute = psRoute->next;
        }
        visited[nStart] = false;
    }
    return bHas;
}

//遍历所有站点中所有的边，将边中的visited值设为false
void ClearVisited()
{
    Route* temp;
    for (int i = 0; i < g_sMap.station_num; i++)
    {
        temp = g_sMap.stations[i].routes;
        while (temp != NULL)
        {
            temp->visited = false;
            temp = temp->next;
        }
    }
}
int QueryRoutes(char* pStart, char* pEnd,  const int transfer, Path* paths)
{
    if(FindStation(pStart)==None||FindStation(pEnd)==None)//判断pStart与pEnd的站点是否存在，不存在返回None
        return None;
    //定义两个数组
    int* path=(int *)malloc(Vexnum*sizeof(int));//当前压栈的站点编号
    bool *visited=(bool *)malloc(Vexnum*sizeof(bool));//结点是否已经在栈中的标志数组
    Path *endpath=paths;
    ClearVisited();
    int nStart=FindStation(pStart);
    int nEnd=FindStation(pEnd);
    int nTop=0;
    int nBus[50]= {0};
    int nBus_num=0;
    int RouteNum=0;
    for (int i = 0; i < g_sMap.station_num; ++i)
        visited[i] = false;
    path[nTop++]=nStart;//将始点设置为已访问，入栈
    visited[nStart]=true;
    while(nTop>0)//循环取出栈顶结点，直至栈中没有结点结束
    {
        int vTopNode=path[nTop-1];
        if(vTopNode==nEnd)//当栈顶元素为终点时，设置终点没有被访问过，打印栈中元素，弹出栈顶结点。
        {
            RouteNum++;
            visited[nEnd]=false;
            Path* pathnode = (Path*)malloc(sizeof(Path*));
            pathnode->stations = (char**)malloc(sizeof(char*) * (30));
            pathnode->buses = (char**)malloc(sizeof(char*) * (20));
            for (int i = 0; i < nTop; ++i)
            {
                pathnode->stations[i] = (char*)malloc(sizeof(char)*30);
                pathnode->buses[i] = (char*)malloc(sizeof(char)*20);
                pathnode->station_num = nTop ;
                strcpy(pathnode->stations[i], STATION[path[i]]);
                strcpy(pathnode->buses[i], BUS[nBus[i+1]][0]);
            }
            if (paths ->next== NULL){
                paths->next = pathnode;
                endpath = paths->next;
                endpath->next=NULL;
            }
            else{
                endpath->next = pathnode;
                endpath = endpath->next;
                endpath->next = NULL;
            }
            nTop--;
            if(nTop==1||nBus[nTop]!=nBus[nTop-1])
                nBus_num--;
        }
        vTopNode=path[nTop-1];
        bool bHas=false;
        Route *pRoute=g_sMap.stations[vTopNode].routes;
        while(pRoute!=NULL)//遍历当前结点全部的边
        {
            int nNode=pRoute->station;
            if(pRoute->visited==false&&visited[nNode]==false)
                //没有从这个结点V出发访问过的结点且没有入栈
            {
                visited[nNode]=true;
                pRoute->visited=true;
                if(nBus_num==0||(nBus_num<transfer+1&&pRoute->bus!=nBus[nTop-1]))
                    nBus_num++;
                else if(nBus_num==transfer+1&&pRoute->bus!=nBus[nTop-1])
                {
                    pRoute=pRoute->next;
                    continue;
                }
                bHas=true;
                break;
            }
            pRoute=pRoute->next;
        }
        if(bHas==true)//如果有一个顶点满足条件
        {
            path[nTop++]=pRoute->station;//将该顶点入栈
            nBus[nTop-1]=pRoute->bus;
        }
        else//如果没有，则将结点V访问到下一个结点的集合中每个边标为false，V出栈
        {
            visited[nStart]=true;
            Route* temp = g_sMap.stations[vTopNode].routes;
            while (temp != NULL)
            {
                temp->visited = false;
                temp = temp->next;
            }
            nTop--;
            visited[path[nTop]] = false;
            if (nTop == 1 || nBus[nTop] != nBus[nTop - 1])
                nBus_num--;
        }
    }
    free(path);
    free(visited);
    return RouteNum;

}
void QueryRoutes()
{
    char start[30];
    char end[30];
    cout<<"=====查询两个站点公交线路（最多换乘1次）====="<<endl;
    cout<<"请输入要查询的起点";
    cin>>start;
    cout<<"请输入要查询的终点";
    cin>>end;
    cout<<"-----------------------------------------"<<endl;
    if(HasPath(start,end)==true)
    {
        Path *paths=(Path*)malloc(sizeof(Path*));
        paths->next =NULL;
        int RouteNum = QueryRoutes(start, end, 1, paths);
        if (RouteNum > 0)
        {
            if (paths != NULL)
            {
                cout<<"从｜"<<start<<"｜到｜"<<end<<"｜共找到"<<RouteNum<<"条路线"<<endl;
                Path* psPath = paths->next;
                Path* psCurPath = NULL;
                for (int i = 0; i < RouteNum; i++)
                {
                    cout<<"路线"<<(i+1)<<":"<<endl;
                    for (int j = 0; j < psPath->station_num - 1; j++)
                    {
                        printf("%s--[%s]-->", psPath->stations[j], psPath->buses[j]);
                    }
                    printf("%s\n\n", psPath->stations[psPath->station_num - 1]);
                    psCurPath = psPath;
                    psPath = psPath->next;
                    free(psCurPath->buses);
                    free(psCurPath->stations);
                    free(psCurPath);
                }
            }
            free(paths);
            paths = NULL;
        }
        else
        {
            cout<<"没有满足条件的路线"<<endl;
        }
    }
    else
    {
        printf("没有满足条件的路线\n");
    }
}

（四）删除信息

编写deleteBus(char* pBus)函数，先找到对应公交再找到对应路线，总线路数减一，挪动路线数组，最后是公交的删除，调用changStrbufBus()、changeStrbufRoute()、LoadMapDate函数修改和加载信息;编写deleteStation(char* pStation)函数。

nnn

void Delete();
void deleteBus(char *pBus);
void deleteStation(char *pStation);
void deleteRoute();
//
void changeStrbufBus();
void changeStrbufStation();
void changeStrbufRoute();

void  Delete()
{
    cout<<"1.删除站点信息"<<endl;
    cout<<"2.删除公交信息"<<endl;
    cout<<"您的输入:"<<endl;
    int cas;
    cin>>cas;
    switch(cas)
    {
    case 1:
        cout<<"请输入您想删除的站点名称:"<<endl;
        char s[30];
        cin>>s;
        cout<<endl;
        deleteStation(s);
        break;
    case 2:
        cout<<"请输入您想删除的公交名称:"<<endl;
        char s1[30];
        cin>>s1;
        cout<<endl;
        deleteBus(s1);
        break;
    default:
        printf(" 输入有误\n");
        break;
    }

}

void deleteBus(char *pBus)
{
    bool bHas=false;
    int i;
    for(i=0; i<Bus_Num; i++)
        if(strcmp(BUS[i][0],pBus)==0)
        {
            bHas=true;
            break;
        }
    if(bHas==true)
    {
        int k=0,j,len,a=0;
        for(j=0; j<Route_Num; j++)
        {
            if(ROUTE[j][0]==i)
            {
                if(!k)
                    a=j;
                k++;
            }

        }
        for(j=a; j<Route_Num-k; j++)
            for(len=0; len<4; len++)
                ROUTE[j][len]=ROUTE[j+k][len];
        Route_Num=Route_Num-k;
        k=a;
        for(j=a; j<Route_Num;)
        {
            ROUTE[j][0]--;
            for(k=j+1; k<Route_num; k++)
            {
                if(ROUTE[k][0]==(ROUTE[j][0]+1))
                    ROUTE[k][0]--;
                else
                    break;
            }
            j=k;
        }
        for(j=i; j<Bus_Num-1; j++)
            for(k=0; k<3; k++)
                strcpy(BUS[j][k],BUS[j+1][k]);
        Bus_Num--;
        changeStrbufBus();
        changeStrbufRoute();
        LoadMapDate();
       
    }
    else
        cout<<"删除公交成功！"<<endl;
}
void deleteStation(char *pStation)
{
    int i,j,k,len;
    bool bHas=false;
    for(i=0; i<Station_Num; i++)
        if(strcmp(STATION[i],pStation)==0)
        {
            bHas=true;
            break;
        }

    if(bHas==true)
    {
        for(k=0; k<Route_Num; k++)
        {
            if(ROUTE[k][2]==i)
            {
                if(k<Route_Num-1&&ROUTE[k][0]==ROUTE[k+1][0])
                {

                    ROUTE[k][2]=ROUTE[k+1][2];
                    ROUTE[k][3]=ROUTE[k][3]+ROUTE[k+1][3];
                    if(k<Route_num-2)
                        for(j=k+1; j<Route_Num-1; j++)
                            for(len=0; len<4; len++)
                                ROUTE[j][len]=ROUTE[j+1][len];
                    Route_Num--;
                }
                else if(k<Route_Num-1)
                    for(j=k; j<Route_Num-1; j++)
                        for(len=0; len<4; len++)
                            ROUTE[j][len]=ROUTE[j+1][len];

            }
            else if(ROUTE[k][1]==i)
            {
                for(j=k; j<Route_Num-1; j++)
                    for(len=0; len<4; len++)
                        ROUTE[j][len]=ROUTE[j+1][len];
                Route_Num--;
            }
        }
        for(j=0; j<Bus_Num; j++)
        {
            len=0;
            for(k=0; k<Route_Num; k++)
            {
                if(j==ROUTE[k][0]&&len==0)
                {
                    strcpy(BUS[j][1],STATION[ROUTE[k][1]]);
                    len++;
                }
                else if((k==Route_Num-1||j!=ROUTE[k+1][0])&&len!=0)
                {
                    strcpy(BUS[j][2],STATION[ROUTE[k][2]]);
                    break;
                }
            }
        }
         for(j=0;j<Route_Num;j++)
        {
          if(ROUTE[j][1]>i)
            ROUTE[j][1]--;
          if(ROUTE[j][2]>i)
            ROUTE[j][2]--;
        }
        for(j=0; j<Station_Num; j++)
            if(strcmp(STATION[i],pStation)==0)
            {
                for(j=i; j<Station_Num-1; j++)
                    strcpy(STATION[j],STATION[j+1]);
                break;
            }
        Station_Num--;
        changeStrbufBus();
        changeStrbufStation();
        changeStrbufRoute();
        LoadMapDate();
        for(int j=0; j<Bus_Num; j++)
        {
            cout<<j<<"∫≈œﬂ¬∑£∫";
            for(int k=0; k<3; k++)
            {
                cout<<BUS[j][k];
                cout<<endl;
            }
        }
        for(int j=0; j<Station_Num; j++)
            cout<<j<<'-'<<STATION[j]<<endl;
    }
}

void changeStrbufBus()
{
    int len=0;
    for(int j=0; j<Bus_Num; j++)
        for(int k=0; k<3; k++)
            len=(int)(len+strlen(BUS[j][k]));
    len=len+3*Bus_Num+1;
    strbuf[0][0]='\0';
    char *s=new char[len];
    int a=0;
    for(int j=0; j<Bus_Num; j++)
    {
        for(int k=0; k<3; k++)
        {
            for(int i=0; BUS[j][k][i]; i++)
                s[a++]=BUS[j][k][i];
            //strcat(s,BUS[j][k]);
            if(k<2)
                s[a++]=' ';
        }
        s[a++]='\n';
    }
    s[a++]='\0';
    strcpy(strbuf[0],s);
    writeBus(s);
    free(s);
}

void changeStrbufStation()
{
    int len=0;
    for(int j=0; j<Station_Num; j++)
        len=(int)(len+strlen(STATION[j]));
    len=len+Station_Num+1;
    strbuf[0][0]='\0';
    char *s=new char[len];
    int a=0;
    for(int j=0; j<Station_Num; j++)
    {

        for(int i=0; STATION[j][i]; i++)
            s[a++]=STATION[j][i];
        s[a++]='\n';
    }
    s[a++]='\0';
    strcpy(strbuf[1],s);
    writeStation(s);
    free(s);
}
void changeStrbufRoute()
{
    char *s=new char[20*Route_Num];
    int  a=0;
    for(int j=0; j<Route_Num; j++)
    {
        for(int k=0; k<4; k++)
        {
            int t=ROUTE[j][k];
            if(t>9)
            {
                char r1[10];
                int len=0;
                while(t)
                {
                    r1[len++]=t%10+'0';
                    t=t/10;
                }
                for(--len; len>=0; len--)
                    s[a++]=r1[len];
            }
            else
                s[a++]=t+'0';
            s[a++]=' ';
        }
        s[a++]='\n';
    }
    s[a++]='\0';
    strcpy(strbuf[2],s);
    writeRoute(s);
    free(s);
}

（五）添加信息

编写addBus(char *pBus,char *pStart,char *pEnd)函数，先输入公交的各个站点和之间的距离，再输出修改后公交的相关信息，向站点数组添加新的站点，添加线路的路径。
mmm

void Add();
void addBus(char *pBus,char *pStart,char *pEnd);
void addStation(char *pStation);
int getaddStation(char *pStation);
void addRoute(int bus,char *pStart,char *pEnd,int distance);

void Add()
{
    char s1[30],s2[30],s3[30];
    cout<<"请输入所添加的公交线路名称:"<<endl;
    cin>>s1;
    cout<<"起点站:"<<endl;
    cin>>s2;
    cout<<"终点站:"<<endl;
    cin>>s3;
    cout<<endl;
    addBus(s1,s2,s3);
    changeStrbufBus();
    changeStrbufStation();
    changeStrbufRoute();
}
void addBus(char *pBus,char *pStart,char *pEnd)
{

    BUS[Bus_Num][0]=new char[strlen(pBus)];
    strcpy(BUS[Bus_Num][0],pBus);
    BUS[Bus_Num][1]=new char[strlen(pStart)];
    strcpy(BUS[Bus_Num][1],pStart);
    BUS[Bus_Num][2]=new char[strlen(pEnd)];
    strcpy(BUS[Bus_Num][2],pEnd);
    //int count=0;
    cout<<"	请从起点到终点输入信息"<<endl;
    char s1[30];
    char s2[30];
    do
    {
        s1[0]='\0';
        s2[0]='\0';
        int d;
        cout<<"起点站:";
        cin>>s1;
        cout<<"终点站:";
        cin>>s2;
        cout<<"距离:";
        cin>>d;
        addRoute(Bus_Num,s1,s2,d);
    }
    while(strcmp(pEnd,s2)!=0);
    Bus_Num++;
    LoadMapDate();
    for(int j=0; j<Bus_Num; j++)
    {
        cout<<j<<"号线路为：";
        for(int k=0; k<3; k++)
        {
            cout<<BUS[j][k];
            cout<<endl;
        }
    }
    for(int j=0; j<Station_Num; j++)
        cout<<j<<'-'<<STATION[j]<<endl;
    for(int j=0; j<Route_Num; j++)
    {
        for(int k=0; k<4; k++)
            cout<<ROUTE[j][k]<<' ';
        cout<<endl;
    }
}
void addStation(char *pStation)
{
    int i;
    for(i=0; i<Station_Num; i++)
        if(strcmp(STATION[i],pStation)==0)
            break;
    if(i==Station_Num)
    {
        //int nStation=Station_Num;
        STATION[Station_Num]=new char[strlen(pStation)];
        strcpy(STATION[Station_Num],pStation);
        Station_Num++;
    }
}
int  getaddStation(char *pStation)
{
    for(int i=0; i<Station_Num; i++)
        if(strcmp(STATION[i],pStation)==0)
            return i;
    return 0;
}

void addRoute(int bus,char *pStart,char *pEnd,int distance)
{
    addStation(pStart);
    addStation(pEnd);
    ROUTE[Route_Num][0]=bus;
    ROUTE[Route_Num][1]=getaddStation(pStart);
    ROUTE[Route_Num][2]=getaddStation(pEnd);
    ROUTE[Route_Num][3]=distance;
    Route_Num++;
}

（六）读函数与写函数

void writeBus(char *pBus);
void writeStation(char *pStation);
void writeRoute(char *pRoute);
//
void getStrbufBus();
void getStrbufStation();
void getStrbufRoute();
//
void getBus();
void getStation();
void getRoute();
//
char* readroute();
char* readstation();
char* readbus();

void writeBus(char *pBus)
{
   /* for(int i=0; i<strlen(pBus); i++)
        if(pBus[i]!='\n')
        fputc(pBus[i],fp);
    fclose(fp);*/

    FILE *fp = fopen("buses.txt","wb+");
    fputs(pBus,fp);
     fclose(fp);
    system("pause");
}
void writeStation(char *pStation)
{

    FILE *fp = fopen("station.txt","wb+");
    fputs(pStation, fp);
    /*for(int i=0; i<strlen(pStation); i++)
        if(pStation[i]!='\n')
        fputc(pStation[i],fp);
    fclose(fp);*/
     fclose(fp);
    system("pause");
}
void writeRoute(char *pRoute)
{
    FILE *fp = fopen("routes.txt","wb+");
    fputs(pRoute,fp);
     fclose(fp);
    /*for(int i=0; i<strlen(pRoute); i++)
        fputc(pRoute[i],fp);
    fclose(fp);*/
    system("pause");
}

void getStrbufBus()
{
    strbuf[0]=new char[strlen(readbus())];
    strcpy(strbuf[0],readbus());
}
void getStrbufStation()
{
    strbuf[1]=new char[strlen(readstation())];
    strcpy(strbuf[1],readstation());

}
void getStrbufRoute()
{
      strbuf[2]=new char[strlen(readroute())];
    strcpy(strbuf[2],readroute());

}
void getBus()
{
    getStrbufBus();
    int k=0,i=0,len=0;
    for(int j=0; j<strlen(strbuf[0]); j++)
    {

        if(strbuf[0][j]!=' '&&strbuf[0][j]!='\n')
            len++;
        else
        {
            BUS[i][k]=new char[len+1];
            strncpy(BUS[i][k],const_cast<char*>(strbuf[0])+(j-len),len);
            for(int a=j-len,b=0; a<j; a++)
                {
                    BUS[i][k][b]=strbuf[0][a];
                    b++;
                }
            BUS[i][k][len]='\0';
            len=0;
            k++;
            if(strbuf[0][j]=='\n')
            {
                Bus_Num++;
                k=0;
                i++;
            }
        }
    }

}
void getStation()
{
    getStrbufStation();
    int len=0,k=0,i;
    for(i=0; i<strlen(strbuf[1]); i++)
    {
        if(strbuf[1][i]!='\n'&&strbuf[1][i]!=' ')
            len++;
        else
        {
            STATION[k]=new char[len+1];
            strncpy(STATION[k],const_cast<char*>(strbuf[1])+(i-len),len);
              for(int j=i-len,b=0; j<i; j++)
              {
                  STATION[k][b]=strbuf[1][j];
                  b++;
              }
            STATION[k][len]='\0';
            Station_Num++;
            k++;
            len=0;

        }

    }
}
void getRoute()
{
    getStrbufRoute();
    int s=0,i=0,k=0;
    for(int j=0; j<strlen(strbuf[2]); j++)
    {
        if('0'<=strbuf[2][j]&&strbuf[2][j]<='9')
            s=(strbuf[2][j]-'0')+s*10;
        else
        {
            ROUTE[i][k]=s;
            s=0;
            if(strbuf[2][j]=='\n')
            {
                Route_Num++;
                k=0;
                i++;
            }
            else
                k++;
        }
    }
}

这个读函数根据实验环境的不同是不一样的，仅供参考。

char* readbus()
{
    filebuf *pbuf;
    ifstream filestr;
    long size;
    char * buffer;
    filestr.open ("buses.txt", ios::binary);
    pbuf=filestr.rdbuf();
    size=pbuf->pubseekoff (0,ios::end,ios::in);
    pbuf->pubseekpos (0,ios::in);
    buffer=new char[size];
    pbuf->sgetn (buffer,size);
    filestr.close();
    return buffer;
    delete []buffer;

}
char* readstation()
{
    filebuf *pbuf;
    ifstream filestr;
    long size;
    char * buffer;
    filestr.open ("station.txt", ios::binary);
    pbuf=filestr.rdbuf();
    size=pbuf->pubseekoff (0,ios::end,ios::in);
    pbuf->pubseekpos (0,ios::in);
    buffer=new char[size];
    pbuf->sgetn (buffer,size);
    filestr.close();
    return buffer;
    delete []buffer;
}
char* readroute()
{
    filebuf *pbuf;
    ifstream filestr;
    long size;
    char * buffer;
    filestr.open ("routes.txt", ios::binary);
    pbuf=filestr.rdbuf();
    size=pbuf->pubseekoff (0,ios::end,ios::in);
    pbuf->pubseekpos (0,ios::in);
    buffer=new char[size];
    pbuf->sgetn (buffer,size);
    filestr.close();
    return buffer;
    delete []buffer;
}

（七）主函数

int main()
{
    getBus();
    getStation();
    getRoute();
    LoadMapDate();
    while (1)
    {
        // ‰≥ˆΩÁ√Ê
        cout << "====公交管理系统=====" << endl;
        int cas1;
        cout <<"1.查询公交线路，站点等信息"<<endl;
        cout <<"2.删除公交线路，站点等信息"<<endl;
        cout <<"3.添加公交线路信息"<<endl;
        cout <<"0.退出" << endl;
        cout <<"您的输入:";
        cin>>cas1;
        switch(cas1)
        {
        case 1:
            cout << "1.查询公交路线" << endl;
            cout << "2.查询站点信息" << endl;
            cout << "3.查询两个站点公交路线" << endl;
            cout << "您的输入:";
            int cas;
            cin >> cas;
            switch (cas)
            {
            case 1:
                int b;
                for(int j=0; j<Bus_Num; j++)
                    cout<<j<<'-'<<BUS[j][0]<<endl;
                cout<<endl;
                cout << "请输入要查询的路线编号:范围("<<'0'<<'-'<<Bus_Num-1<<")"<<endl;
                cin>>b;
                while(b<0||b>Bus_Num-1)
                {
                    cout<<" 输入错误！请重新输入："<<endl;
                    cin>>b;
                }
                QueryBus(b);
                break;
            case 2:
                int s1;
                for(int j=0; j<Station_Num; j++)
                    cout<<j<<'-'<<STATION[j]<<endl;
                cout<<endl;
                cout << "请输入要查询的站点编号:范围("<<'0'<<'-'<<Station_Num-1<<")"<<endl;
                cin>>s1;
                while(s1>Station_Num-1||s1<0)
                {
                    cout<<" 输入错误！请重新输入："<<endl;
                    cin>>s1;
                }
                QueryStation(s1);
                break;
            case 3:
                QueryRoutes();
                break;
            default:
                cout<<"输入有误\n"<<endl;
                break;
            }
            break;
        case 2:
            Delete();
            break;
        case 3:
            Add();
            break;
        case 0:
            return 0;
        default:
            cout<<"输入有误\n"<<endl;
            break;
        }
        pause();
    }
    return 0;
}

篇幅有点过长，可以参考参考这里的结构还有一些函数，测试阶段还需要大家自己动手尝试。so和我一起加油吧！

土豆侠_

关注

30
点赞
踩
182

收藏

觉得还不错? 一键收藏
10
评论
数据结构课程设计公交系统

大家好！这是我的第一篇文章，是将这学期的数据结构课设报告整理出来的。可能还有些小错误，还请多多指正。数据结构课程设计《公交系统》引言课题描述设计要求总体设计数据格式数据结构图的存储公交路线图结构体定义全局定义详细设计函数调用关系创建公交线路查询信息删除信息添加信息引言课题描述本程序是一个控制台程序，模拟城市公交系统，程序中保存了城市的公交线路和公交站点信息。公交线路和站点满足以下条件；若两站点之间有一条或多条公交线路直接到达则连通；每条公交线路经过若干站点；相同的路线有上行和下行两条公交线
复制链接

扫一扫