求有向無環圖的所有拓撲序列

一 用到二個工具：

    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("\n");
}