最短路径

/********************************************************
--程序描述：	图1-1的最短路径算法
--修改日期：	2009.5.31
--修改人：		吴强
--修改原因：	从前写的程序不够规范
--输入要求：	字母A至J
********************************************************/
#include 
#include 

#define N 5
#define M 10
#define Max 255

typedef struct 
{
    char node;
    int len;
    char last;
}Node;

int tu[N][M]={ {0, 2, Max, Max, Max, 4, Max, Max, 9, Max},              /*压缩10*10的对称矩阵*/
               {2, 0, 4, Max, Max, Max, Max, Max, Max, Max},
               {Max, 1, 0, 2, Max, 8, Max, Max, Max, Max},
               {4, Max, 3, 0, 5, Max, Max, Max, Max, Max},
               {Max, 3, 6, Max, 0, 7, 3, 5, Max, Max} };

Node nodeArr[M];

main()
{
    char ch;
    int i;
    
    int put(int,int);
    void sort(char c);
    int Seek(char c);

    for (i=0; i< M; i++)      /*初始化数组*/
    {
    	nodeArr[i].node='A'+i;
    	nodeArr[i].len=Max;
    	nodeArr[i].last='#';
    }

    printf("input Node: ");  
    ch=getchar();     /*输入起点*/

    while ( ch< 'A' || ch > 'J' )
    {   
    	printf("error/ninput Node: ");
    	ch=getchar();
    }                          
    
    sort(ch);

    for ( i=0; i< M; i++)
    {
        printf("%c %d %c /n", nodeArr[i].node, nodeArr[i].len, nodeArr[i].last);  
    }
   
}

void sort(char c)         /*按到起点距离最短的全部排序*/
{
    int i;
    int j;
    int n;
    int h;
    int k=0;
    Node jh;

    for ( i=0; i< M; i++ )                /*起点到起点的距离总是0*/
    {
    	if (c==nodeArr[i].node)
    	{   
            /*查找原点附值并交换至nodeArr[0]*/
            jh=nodeArr[i];
            nodeArr[i]=nodeArr[0];

            nodeArr[0]=jh;
            nodeArr[0].len=0;
            nodeArr[0].last='*';

            break;
    	}
    }

    while(k< M)                  
    {    
        n=0;

        for (i=0; i< M; i++)
        {
            n=put(c-'A',i);  /*该点到各点的距离*/

            if (n!=0 || n!=Max)
            {  
                h=Seek('A'+i); 

                if (nodeArr[h].len> n+nodeArr[k].len)
                {
                    nodeArr[h].len=n+nodeArr[k].len;
                    nodeArr[h].last=nodeArr[k].node;
                }
            }
        }

        j=k+1;

        for ( i=j+1; i< M; i++ )	/*查找数组中最小的*/
        {
            if (nodeArr[j].len> nodeArr[i].len)
            {
                j=i;
            }
        }

        if (nodeArr[k].node!=nodeArr[j].node)
        {
            jh=nodeArr[k+1];
            nodeArr[k+1]=nodeArr[j];
            nodeArr[j]=jh;
        }

        k++;
        c=nodeArr[k].node;
    }
}
	     

int put(int i,int j)                 /*输入下标，在压缩的矩阵中查找各点间距离*/
{
    if ( i< M/2 )
    {
        if ( j< M/2 && j< i )
        {
            return tu[i][j];
        }
        else if ( j< M/2 )
        {
	    return tu[j][i];
        }
        else 
        {
	    return tu[M-j-1][M-i-1];
        }
    }
    else 
    {
        if (j< i)
    	{
            return tu[M-i-1][M-j-1];
    	}
        else  
    	{
            return tu[M-j-1][M-i-1];
    	}
    }
}

int Seek(char c)              /*在所放各点数据的nodeArr数组中查找指定字母的下标*/
{
    int i;

    for (i=0; i< M; i++)
    {
        if ( nodeArr[i].node==c )
        {
            return i;
        }
    }

    return -1;
}