数据结构#课表排序及查询

专业课程安排

摘要：利用邻接表建立专业课程的有向图，明确课程先修后修的关系，可实现拓扑排序，最后使用广度遍历，可查询每学期的课程信息，还可以查询该课程所在的学期。最后利用循环，选择功能可实现专业课程安排中所给要求。

关键词：邻接表；有向图；拓扑排序；广度遍历

 

1. 功能介绍

该程序的功能是专业课程安排。输入任意一个专业的所有专业课建立有向图，可以完成拓扑排序，输出任意一个学期的课程信息：名称，课时，学分，按照课程查询任意一门课程所属的学期。

1. 概要设计

  2.1模块功能流程图

1. 详细设计

3.1采用C语言定义结构体数据类型

     3.1.1 头结点的顶点信息结构体数据类

typedef struct{

ArcNode *firstarc;

   char data;//编号

   char keming[20];//课程名称

   int xueqi;//学期

   int xueshi;//学时

   int xuefen; //学分

}VNode,Vertice[MAX];//顶点信息 

3.1.2 表结点结构体数据类型

  typedef struct ArcNode{

  struct ArcNode *nextarc;  //指向下一条弧的指针

  int adjvex;     //该弧所指的顶点位置

}ArcNode;

 

3.2各模块的类C 代码

3.2.1邻接表创建创建有向图

void CreateALGraph(ALGraph &G){

int i,j,k;

char v1,v2;//顶点编号

ArcNode *p,*s;

scanf("%d%d",&G.vexnum,&G.arcnum);//输入顶点数目和边数

 

for(i = 0; i < G.vexnum; i++){

cin>>G.vex[i].data>>G.vex[i].keming>>G.vex[i].xuefen>>G.vex[i].xueqi>>G.vex[i].xueshi; //输入课程标号，学期，课程名称，学分，学时等所有信息

G.vex[i].firstarc = NULL;//指向的第一个节点为空

}

 

for(i = 0; i < G.arcnum; i++){

cin>>v1>>v2;//输入一条边上的两个顶点编号

j = LocateVex(G,v1);//获取弧尾结点存储位置

k = LocateVex(G,v2);//获取弧头结点存储位置

s = (ArcNode *)malloc(sizeof(ArcNode));

s->adjvex = k; //将弧头位置给新分配分节点

s->nextarc = NULL;  

if(!G.vex[j].firstarc){

G.vex[j].firstarc = s;//如果弧尾指向的第一个节点为空，插入s

}

else{

p = G.vex[j].firstarc;//如果不为空，一直往后找，找到末位插入s

while(p->nextarc)

p = p->nextarc;

    p->nextarc = s;

}

}

}

3.2.2拓扑排序

void TopologicalSort(ALGraph G){

ArcNode *p; int count=0;

FindInputDgeree(G); //对各个顶点求入度

InitStack(S);

for(i = 0; i < G.vexnum; i ++)

if(!indegree[i])//把入度为零的节点入栈

Push(S,i);

while(!StackEmpty(S)){

i=Pop(S,i);  cout<<G.vex[i].data<<endl; count ++;//输出i号定点并计数

   for(p = G.vex[i].firstarc; p;p=p->nextarc){

k=p->adjvex;  //对i号顶点的每个邻接点入度减一

if(!(--indegree[k]))//入度为0则入栈

Push(S,k);

}

3.2.3 DFS遍历

void DFS(ALGraph G, int i,int term){

 //以vi为出发点对邻接表表示的图G进行深度优先搜索

       if(G.vex[i].xueqi==term){

cout<<G.vex[i].data<<""<<G.vex[i].keming<<""<<G.vex[i].xuefen<<""<<G.vex[i].xueshi<<endl;//如果学期相等，则输出该学期信息

}

    visited[i] = TRUE;              //标记vi已访问

    p = G.vex[i].firstarc;        //取vi边表的头指针

    while (p) {          //依次搜索vi的邻接点vj，这里j=p->adjvex

           if (!visited[p->adjvex])    //若vi尚未被访问

          DFS(G, p->adjvex,term);      //则以Vj为出发点向纵深搜索

           p = p->nextarc;                     //找vi的下一邻接点

    }

}

3.3.2 主函数

int main(){

ALGraph G;

CreateALGraph(G);//建立图

cout<<"功能1：拓扑排序"<<"    "<<"功能2：查询学期课程"<<"    "<<"功能3：查看课程所属学期"<<"   "<<"功能4：退出"<<endl;

while(1){

cout<<"请输入1/2/3/4完成功能"<<endl;

int i;  cin>>i; //选择功能

switch(i){

case 1:TopologicalSort(G);

cout<<endl;//进行拓扑排序

break;

case 2:{

cout<<"请输入学期（1-7）";

        cin>>term;

        DFSTraverseM(G,term);

break;

}

case 3:{

cout<<"请输入课程名称：";

          cin>>name;

        DFSTraverseM2(G,name);

break;

}

case 4:{

n=0;

break;

}

}

}

return 0;

}

  

 最后附上源码：

#include <stdio.h>
#include<string.h>
#include<iostream>
using namespace std;
#include <stdlib.h>
#define MAX 30
typedef enum{ FALSE, TRUE }Boolean;
Boolean visited[30];

int indegree[MAX];//用来存储所有节点的入度之和
//表节点 
typedef struct ArcNode{
    struct ArcNode *nextarc;  //指向下一条弧的指针 
    int adjvex;     //该弧所指的顶点位置 
}ArcNode;
//头节点中存储课程名称，编号，学期，学分，指向第一个节点的指针 
typedef struct{
    ArcNode *firstarc;
    char data;//编号
    char keming[20];//课程名称
    int xueqi;
    int xueshi;
    int xuefen;     
}VNode,Vertice[MAX];//顶点信息 

typedef struct{
    int vexnum,arcnum;
    Vertice vex;
}ALGraph;//图的信息
 
typedef struct{
    int *top;
    int *base;
    int stacksize;
}SqStack;

int LocateVex(ALGraph G, char v){
    for(int i = 0; i < G.vexnum; i ++){
        if(v == G.vex[i].data)
            return i;
    }
    
    return -1;
}

void CreateALGraph(ALGraph &G){
    int i,j,k;
    char v1,v2;//顶点编号 
    ArcNode *p,*s;
    
    printf("输入节点和边的数目:
");
    scanf("%d%d",&G.vexnum,&G.arcnum);
    

    //getchar();
    cout<<"请输入所有的专业课信息"<<endl; 
    cout<<"请输入    编号"<<"-----"<<"课程名称"<<"-----"<<"学分"<<"-----"<<"学期"<<"-----"<<"学时"<<endl; 
    for(i = 0; i < G.vexnum; i++){ 
        cin>>G.vex[i].data>>G.vex[i].keming>>G.vex[i].xuefen>>G.vex[i].xueqi>>G.vex[i].xueshi; 
        G.vex[i].firstarc = NULL;    
    }
    
    for(i = 0; i < G.arcnum; i++){
    cout<<"输入一条边上的两个顶点编号 :"<<endl; 
        
        cin>>v1>>v2;
        
        j = LocateVex(G,v1);
        k = LocateVex(G,v2);
        
        s = (ArcNode *)malloc(sizeof(ArcNode));
        s->adjvex = k;        
        s->nextarc = NULL;
        
        
        if(!G.vex[j].firstarc){
            G.vex[j].firstarc = s;
        }
        else{
            p = G.vex[j].firstarc;
            
            while(p->nextarc)
                p = p->nextarc;
            
            p->nextarc = s;
        }
    }
}

void FindInputDgeree(ALGraph G){ //计算所有节点的入度
    ArcNode *p;
    int i;
    
    for(i = 0; i < G.vexnum; i ++)
        indegree[i] = 0;
    
    for(i = 0; i < G.vexnum; i ++){
        p = G.vex[i].firstarc;
        
        while(p){
            indegree[p->adjvex] ++;
            p = p->nextarc;
        }
    }
}

void InitStack(SqStack &S){
    S.base = ( int*)malloc(sizeof(int) * MAX);
    
    if(!S.base)
        return ;
    
    S.top = S.base;
    S.stacksize = MAX;
}

void Push(SqStack &S, int i){
    
    *S.top++ = i;
}

int StackEmpty(SqStack S){
    if(S.top==S.base)
        return 1;
    
    return 0;
}

int Pop(SqStack &S, int &i){
    if(S.base!=S.top)
    i = *-- S.top;
    return i;
}

void TopologicalSort(ALGraph G){
    ArcNode *p;
    FindInputDgeree(G); 
    int i,count = 0;
    
    SqStack S;    
    InitStack(S);
    
    for(i = 0; i < G.vexnum; i ++)
        if(!indegree[i])//把入度为零的节点入栈
            Push(S,i);
    
    printf("拓扑序列如下:
");        
    while(!StackEmpty(S)){
        i=Pop(S,i);
        cout<<G.vex[i].data<<"  ";
        count ++;
        
        int k;
        for(p = G.vex[i].firstarc; p;p=p->nextarc){
            k=p->adjvex;
            if(!(--indegree[k]))
            Push(S,k);
            
        }
        
        
        
        
        /*while(p){        
            if(!(-- indegree[p->adjvex]))//判断去掉一条边后节点的入度是否为零
                Push(S,p->adjvex);
            
            p = p->nextarc;
        }    */    
    }
    
    if(count < G.vexnum)
        cout<<"该图为有向有环图"<<endl;
    
}

void DFS(ALGraph G, int i,int term)
{
    //以vi为出发点对邻接表表示的图G进行深度优先搜索
    ArcNode *p;
    if(G.vex[i].xueqi==term){
         cout<<"编号"<<"    " <<"课程名称"<<"    "<<"学分" <<"   "<<"学时"<<endl; 
    cout<<G.vex[i].data<<"    "<<G.vex[i].keming<<"   "<<G.vex[i].xuefen<<"   "<<G.vex[i].xueshi<<endl;
    }
      // 访问顶点vi
    visited[i] = TRUE;              //标记vi已访问
    p = G.vex[i].firstarc;        //取vi边表的头指针
    while (p)
    {                               //依次搜索vi的邻接点vj，这里j=p->adjvex
        if (!visited[p->adjvex])    //若vi尚未被访问
            DFS(G, p->adjvex,term);      //则以Vj为出发点向纵深搜索
        p = p->nextarc;                     //找vi的下一邻接点
    }
}
void DFSTraverseM(ALGraph G,int term)
{
    int i;
    for (i = 0; i < G.vexnum; i++)
        visited[i] = FALSE;
    for (i = 0; i < G.vexnum; i++)
        if (!visited[i])
            DFS(G, i,term);
}

void DFS2(ALGraph G, int i,char name[20])
{
    //以vi为出发点对邻接表表示的图G进行深度优先搜索
    ArcNode *p;
    if(strcmp(G.vex[i].keming,name)==0)
    {
    cout<<"所在学期" <<endl; 
    cout<<G.vex[i].xueqi<<endl;
    }
    
     else // 访问顶点vi
    {visited[i] = TRUE;              //标记vi已访问
    p = G.vex[i].firstarc;        //取vi边表的头指针
    while (p)
    {                               //依次搜索vi的邻接点vj，这里j=p->adjvex
        if (!visited[p->adjvex])    //若vi尚未被访问
            DFS2(G, p->adjvex,name);      //则以Vj为出发点向纵深搜索
        p = p->nextarc;                     //找vi的下一邻接点
    }}
}


void DFSTraverseM2(ALGraph G,char name[20])
{
    int i;
    for (i = 0; i < G.vexnum; i++)
        visited[i] = FALSE;
    for (i = 0; i < G.vexnum; i++)
        if (!visited[i])
            DFS2(G, i,name);
}


int main(){
    ALGraph G;
    int term;
    char name[20];
    
    CreateALGraph(G);//建立图    
    cout<<"功能1：拓扑排序"<<"    "<<"功能2：查询学期课程"<<"    "<<"功能3：查看课程所属学期"<<"   "<<"功能4：退出"<<endl;
    
    int n;
    n=1;
    
    while(n){
    
    cout<<"请输入1/2/3/4完成功能"<<endl; 
    int i;
    cin>>i;
    switch(i){
        case 1:TopologicalSort(G);
        cout<<endl;//进行拓扑排序
        break;
        case 2:{
            cout<<"请输入学期（1-7）"; 
            cin>>term;
            DFSTraverseM(G,term);
            break;
        }
        case 3:{
            cout<<"请输入课程名称：";
             cin>>name;
            DFSTraverseM2(G,name);
     
            break;
        }
        case 4:{
            n=0;
            break;
        } 
    } 
}
    
    
    

    return 0;
}