Thư viện Graph.h

Phˆa
`
n phu
.
lu
.
c A
Thu
.
viˆe
.
n Graph.h
Du
.
´o
.
i d¯ˆay l`a thu
.
viˆe
.
n gˆo
`
m c´ac cˆa
´
u tr´uc d˜u
.
liˆe
.
u v`a c´ac thu
˙’

tu
.
c cˆa
`
n thiˆe
´
t hˆo
˜
tro
.
.
viˆe
.
c c`ai d¯ˇa
.
t
c´ac thuˆa
.
t to´an trong gi´ao tr`ınh.
/**************************************************
Luu y: Tat ca cac file du lieu dung voi Thu vien nay
phai duoc tao bang trinh Norton Commander.
**************************************************/
#if !defined(graph_h)
#define graph_h
#include <stdio.h>
#include <conio.h>
#include <alloc.h>
#include <string.h>
/****** Phan dinh nghia cac hang *****/

#define TRUE 1
#define FALSE 0
#define INFTY 32767
#define MAXEDGES 50 // So cuc dai cac canh
#define MAXVERTICES 25 // So cuc dai cac \dd\ir nh
#define MAXSTRINGS 16 // Chieu dai cuc dai xau ky tu
197

/****** Phan dinh nghia cac kieu du lieu *****/
typedef unsigned char byte;
typedef byte Boolean;
typedef char DataType[MAXSTRINGS+1]; // Them mot ma ket thuc chuoi
/*******************************
Cau truc du lieu: don lien ket
*******************************/
typedef struct VertexNode *AdjPointer;
struct VertexNode
{
byte Vertex;
int Length;
int Flow;
AdjPointer Next;
};
typedef struct
{
DataType Data;
AdjPointer Next;
} HeadNode;
typedef HeadNode *HeadPointer;
typedef HeadPointer ArrayOfPointer[MAXVERTICES];

typedef struct QueueType *QueueNode;
struct QueueType
{
byte Vertex;
QueueNode Next;
};
typedef struct
{
QueueNode Head, Tail;
} Queue;
typedef byte Path[MAXVERTICES];
198

typedef byte SetOfVertices[(MAXVERTICES%8)?((MAXVERTICES/8)+1):(MAXVERTICES/8)];
/***********************************
Danh sach da lien ket cho cac canh
***********************************/
typedef struct EdgeNode *EdgePointer;
struct EdgeNode
{
byte Vertex[2];
EdgePointer Link[2];
};
typedef struct
{
char Data;
EdgePointer Next;
} ListEdge;
typedef ListEdge *ListEdgePointer;
typedef ListEdgePointer ArrayOfEdge[MAXVERTICES];

/***** Phan khai bao prototype ham *****/
void Create(AdjPointer *List);
Boolean Empty(AdjPointer List);
void Push(AdjPointer *List, byte Item);
void Pop(AdjPointer *List, byte *Item);
void CreatQueue(Queue *Q);
Boolean EmptyQueue(Queue Q);
void PushQueue(Queue *Q, byte Item);
void PopQueue(Queue *Q, byte *Item);
Boolean EmptySet(SetOfVertices S);
Boolean InSet(SetOfVertices S, byte Value);
void InitSet(SetOfVertices S, byte MaxValue);
void AddSet(SetOfVertices S, byte Value);
void SubSet(SetOfVertices S, byte Value);
void MakeV_out(char *FileName, ArrayOfPointer V_out, byte *NumVertices,
199

Boolean Weight);
void MakeV_in(char *FileName, ArrayOfPointer V_in, ArrayOfPointer V_out,
byte *NumVertices);
void BuildGraph(char *FileName, ArrayOfEdge E, byte *NumVertices);
void DisplayV_out(ArrayOfPointer V_out, byte NumVertices, Boolean Weight);
void DisplayV_in(ArrayOfPointer V_in, byte NumVertices);
void DFS(ArrayOfEdge E, byte Start, SetOfVertices S);
void PathTwoVertex(Path Pred, byte Start, byte Terminal);
void PopHeadPtr(byte NumVertices, ArrayOfPointer V_out);
/***** Phan cai dat cac ham *****/
void Create(AdjPointer *List)
{
(*List) = NULL;

}
Boolean Empty(AdjPointer List)
{
return((List == NULL) ? TRUE : FALSE);
}
void Push(AdjPointer *List, byte Item)
{
AdjPointer TempPtr;
TempPtr = (AdjPointer) malloc(sizeof(struct VertexNode));
TempPtr->Vertex = Item;
TempPtr->Next = (*List);
(*List) = TempPtr;
}
void Pop(AdjPointer *List, byte *Item)
{
AdjPointer TempPtr;
if (Empty(*List))
{
printf(" Thao tac con tro khong hop le ");
return;
200

}
TempPtr = (*List);
(*Item) = TempPtr->Vertex;
(*List) = TempPtr->Next;
free(TempPtr);
}
void CreatQueue(Queue *Q)
{

(*Q).Head = NULL;
}
Boolean EmptyQueue(Queue Q)
{
return((Q.Head == NULL) ? TRUE : FALSE);
}
void PushQueue(Queue *Q, byte Item)
{
QueueNode TempPtr;
TempPtr = (QueueNode) malloc(sizeof(struct QueueType));
TempPtr->Vertex = Item;
TempPtr->Next = NULL;
if ((*Q).Head == NULL) (*Q).Head = TempPtr;
else (*Q).Tail->Next = TempPtr;
(*Q).Tail = TempPtr;
}
void PopQueue(Queue *Q, byte *Item)
{
QueueNode TempPtr;
if (EmptyQueue(*Q))
{
printf(" Thao tac con tro khong hop le ");
return;
}
TempPtr = (*Q).Head;
(*Item) = TempPtr->Vertex;
(*Q).Head = TempPtr->Next;
free(TempPtr);
201

}
Boolean EmptySet(SetOfVertices S)
{
int i, k = (MAXVERTICES %8 ) ? ((MAXVERTICES / 8) + 1) : (MAXVERTICES / 8);
for (i = 0; i < k; i++)
if (S[i] != 0) return(FALSE);
return(TRUE);
}
Boolean InSet(SetOfVertices S, byte Value)
{
if ((Value < 1) || (Value > MAXVERTICES))
return(FALSE);
return((S[(Value - 1) / 8] & (0x80 >> ((Value - 1) % 8))) ? TRUE : FALSE);
}
void InitSet(SetOfVertices S, byte MaxValue)
{
int i;
if (MaxValue>MAXVERTICES)
{
printf(" Gia tri khong thuoc tap hop ");
return;
}
for (i = 0; i < MaxValue; i++) S[i/8] |= 0x80 >> (i%8);
}
void AddSet(SetOfVertices S, byte Value)
{
int i;
if ((Value < 1) || (Value > MAXVERTICES))
{
printf(" Gia tri khong thuoc tap hop ");

return;
}
202