求有向无环图的所有拓扑序列

一 用到二个工具：

    1.回溯法的算法思想

    2.顺序表（主要用到了删除操作）

二 程序设计步骤：

    1.读入图；

       这里我没有用严格的图结构。而是用邻接矩阵来表示图，邻接矩阵放在一个txt文件中。（见后文）

       读入图就是指读入这个文件。

    2.计算图中顶点的入度；

       用一个结构体数组来存放顶点名称和顶点的入度（我这里的结构体名称是ElemType）

    3.初始化顺序表

       这一步只需初始化第0号顺序表。。。

       用2中的顶点入度数组来初始化。

    4.开始计算拓扑序列

       这里我们把图的每个顶点比作一个球，每个顺序表比作一个袋子。

       假设图有十个顶点，则需要十个袋子。（100个顶点，需要100个袋子。。。）

       这个问题与常见回溯算法不同的一个特点：从前一个袋子里取出球后，才能知道下一个袋子里装的是那几个球。

       思想如下：

       （1）将所有的球装入第0号袋子；

       （2）从袋子中取出一个球。如果合法（即入度为0），进行下一步；如果非法（即入度不为0），取下一个球。

       （3）根据（2）中取出的球，计算下一个袋子中的球的情况。上一步袋子中的球，除去取出的球外，全部放入下一个袋子（假设为A号袋子）中。根据取出的球（即顶点），

          计算A号袋子中球（即顶点）的入度。

       （4）重复步骤（2），每次袋子中都会少一颗球，直到最后一个袋子。取球的顺序即该图的一个拓扑排序；

       （5）从最后一个袋子开始回溯，直到回到第0号袋子，并把第0号袋子中的球取完为止。

    5.输出

三 示例

    1.需要拓扑排序的图

    2.存放邻接矩阵的文件。。

  

    3.代码

     （1）我的一个存放顺序表操作的头文件。。 

#pragma once
#ifdef ElemType
#else
#define ElemType int
#endif
#ifdef MaxSize
#else
#define MaxSize 10
#endif

//顺序表
struct sqList
{
    ElemType data[MaxSize];
    int length;
};
typedef struct sqList SqList;

//初始化
void init(SqList* list)
{
    list->length = 0;
    return;
}

//求长度
int getLength(SqList* list)
{
    return list->length;
}

//插入
int insert(SqList* list, int n, ElemType x)
{
    if (list->length >= MaxSize || n < 0 || n > list->length)
    {
        return 0;
    }
    int i = list->length;
    while (i > n)
    {
        list->data[i] = list->data[i - 1];
        i--;
    }
    list->data[n] = x;
    list->length++;
    return 1;
}

//删除
int del(SqList* list, int n, ElemType* x)
{
    if (n < 0 || n > list->length - 1)
    {
        return 0;
    }
    int i = n;
    *x = list->data[i];
    while (i < list->length - 1)
    {
        list->data[i] = list->data[i + 1];
        i++;
    }
    list->length--;
    return 1;
}

     （2）开始求拓扑排序

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct elemType
{
    int name;    //顶点名称
    int num;     //顶点的入度数
};
#define ElemType elemType
#define MaxSize 10
#define ROW 10
#define COL 10
#include"sq-list.h"

SqList bags[COL + 1];     //袋子 

int inputGraphic(const char *path, int mGraphic[][COL], int row);
void getInDegree(int mGraphic[][COL], int row, ElemType degs[], int n);
void initList(ElemType degs[], int n);
int permulation(int mGraphic[][COL], int row, int n);
void printResult(int result[], int n);


int main()
{
    const char* path = "F:\练习\c\graphic.txt";
    int mGraphic[ROW][COL];
    ElemType degs[COL];               //存放图中的顶点信息和入度数
    int counter = 0;

    if (!inputGraphic(path, mGraphic, ROW))
    {
        return 0;
    }
    getInDegree(mGraphic, ROW, degs, COL);
    initList(degs, COL);
    counter = permulation(mGraphic, ROW, COL);
    printf("这个图共有：%d种拓扑排序", counter);
    return 0;
}

//读入图
int inputGraphic(const char* path, int mGraphic[][COL], int row)
{
    int i, j;
    FILE* fp;
    fp = fopen(path, "r");
    if (fp == NULL)
    {
        return 0;
    }
    for (i = 0; i < ROW; i++)
    {
        for (j = 0; j < COL; j++)
        {
            fscanf(fp, "%d", &mGraphic[i][j]);
        }
    }
    fclose(fp);
    return 1;
}

//计算每个顶点的入度
void getInDegree(int mGraphic[][COL], int row, ElemType degs[], int n)
{
    int i, j;
    for (j = 0; j < COL; j++)
    {
        degs[j].name = j;
        degs[j].num = 0;
        for (i = 0; i < ROW; i++)
        {
            degs[j].num += mGraphic[i][j];
        }
    }
}

//初始化顺序表
void initList(ElemType degs[], int n)
{
    init(&bags[0]);
    int i = 0, j = 0;
    for (i = 0; i < n; i++)
    {
        bags[0].data[i] = degs[i];
    }
    bags[0].length = n;
}

//计算所有拓扑排序
int permulation(int mGraphic[][COL], int row, int n)
{
    int counter = 0;     //计数器，即共多少种排序方式
    int i = 0, j = 0;
    int temp = 0;
    ElemType ball, tempBall;
    int* index = (int*)malloc(sizeof(int) * n);
    int* result = (int*)malloc(sizeof(int) * n);
    if (index == NULL || result == NULL)
    {
        return -1;
    }
    for (i = 0; i < n; i++)
    {
        index[i] = 0;
    }

    i = 0;
    while (i >= 0)
    {
        //从第i号袋子中，取第index[i]号球
        if (i < n)
        {
            if (index[i] >= bags[i].length)
            {
                //回溯
                //当第i号袋子中所有的球都被取过之后，回溯到第i-1号袋子
                //同时要把i~n-1号袋子"还原",即index[i]=0,index[i+1]=0...
                //保证再次取到这个袋子时，依然时从0号球开始取
                temp = i;
                i--;
                while (temp < n)
                {
                    index[temp++] = 0;
                }
            }
            else if (bags[i].data[index[i]].num != 0)
            {
                //如果取出的球不合法（即度不为0），则继续取下一个球
                index[i] += 1;
            }
            else
            {
                //取出一颗球
                result[i] = bags[i].data[index[i]].name;
                //生成下一个袋子里的球
                bags[i + 1] = bags[i];
                del(&bags[i + 1], index[i], &tempBall);
                for (j = 0; j < bags[i + 1].length; j++)
                {
                    ball = bags[i + 1].data[j];
                    if (mGraphic[tempBall.name][ball.name] == 1)
                    {
                        bags[i + 1].data[j].num--;
                    }
                }
                //下次在从i号袋子里取球时，球index[i]+1号球
                index[i] += 1;
                //从下一个袋子里取球
                i++;
            }
        }
        else
        {
            counter++;
            printResult(result, n);
            i--;
        }
    }
    
    return counter;
    free(index);
    free(result);
}

void printResult(int result[], int n)
{
    int i = 0;
    for (i = 0; i < n; i++)
    {
        //此次加1是因为我的图中顶点是从1开始编号的，而程序中顶点从0开始编号
        printf("%d,", result[i] + 1);    
    }
    printf("
");
}