怎么说呢，这些练习写的不是很全面，写的可能也不是很好，结构也不够严谨，就是我平时看书时为了了解一下算法，而自己做的练习，做的时候就把主要的东西做出来了，比如说栈，我只写了入栈和出栈的函数，其他的都没写。程序也因此都不太长，不过我想正是因为他不全面，因为他们短，才可以为初学者带来一些帮助，那些全面的，初学者可能很难看懂，由于我是c语言和数据结构同时学的，所以开始写的水平可能差些，越往后就写的越好些，和和，不好意思，为了方便大伙能够复制下来就直接运行，里面的函数我和主程序也没有分开写，也简单的在里面加了些注释，现在写到了霍夫曼编码，后面的还正在写，礼拜五我就回学校了，也不知道能不能把整本书的主要内容都写完，所有程序在Dev C++下运行通过！最好真能够给大伙带来些帮助，我也算没白发，还有大家不要笑话我

顺序表的

#include <malloc.h>
#include <stdio.h>
#define List_Max_Size 100
#define Add_Size 10

struct Human_Data {
char Name [20];
int Age;
};//定义顺序表数据结构体
typedef Human_Data Thread_Save_Struct;

struct Thread_1 {
int Length;
int List_Size;
Thread_Save_Struct *Point;
};//定义顺序表指针结构体
typedef Thread_1 Thread;

int Create_List( Thread &List )
{
List.Point = (Thread_Save_Struct * )malloc ( sizeof(Thread_Save_Struct) * List_Max_Size);
if ( !List.Point ) return (0);
List.List_Size = List_Max_Size;
List.Length = 0;
return (1);
}//建立一个顺序表

int main()
{
int Create_List( Thread &List );
int OnOff = 1;
int Add = 0;
Thread_Save_Struct *Point_1;
Thread User;

if (Create_List(User)==1)
{
printf("\n","存储空间开辟成功");

for (Point_1 = User.Point;OnOff==1 && User.Length<User.List_Size;Point_1++)
{ printf("当前指针域:%d\n",Point_1);
printf("在此输入名字:");
scanf("%s", Point_1->Name);
printf("在此输入年龄:");
scanf("%d", &(Point_1->Age));
printf("是否继续输入？是(1),否(0):");
scanf("%d",&OnOff);
User.Length++;
}//for
printf("当前指针域:%d\n",Point_1);
for (Point_1 = User.Point;Add != User.Length ;Point_1++)
{
printf("当前指针域%d\n",Point_1);
printf("姓名:%s\n",Point_1->Name);
printf("年龄:%d",Point_1->Age);
scanf("%d", &OnOff);
Add++;
}//for
}//if
else printf("%s\n","存储空间开辟失败");
return 0;}//main

开辟了段空间，然后在里面存数，然后打印

双向链式表的
#include <malloc.h>
#include <stdio.h>
#include <string.h>
#define List_Max_Size 100
#define Add_Size 10
#define Null 0

struct Member_Data {
char Name [20];
int Age,Length;
Member_Data *Next;
Member_Data *Pre;
};//定义链式表数据结构体
typedef Member_Data Chain_Save_Struct;
typedef Member_Data Head_Chain;

int Create_Chain( Chain_Save_Struct &List )
{
List.Length = 0;
List.Next = Null;
List.Pre = Null;
return (1);
}//建立一个链式表

int Add_Chain ( Head_Chain &List,Chain_Save_Struct **Position)
{
Chain_Save_Struct *Position_1,*PreP;
if (List.Next==NULL)
{
List.Next = (Chain_Save_Struct * )malloc ( sizeof(Chain_Save_Struct));
if (!List.Next) return(0);
List.Length=1;
(List.Next -> Next) = Null;
(List.Next ->Pre) = &List;
*Position = List.Next;
printf("List.Next=%d\n",List.Next);
return(1);
}
else
{
Position_1 = *Position;
for (*Position = (List.Next);
*Position !=NULL; *Position=(*Position)->Next)PreP = *Position;
PreP->Next = (Chain_Save_Struct * )malloc ( sizeof(Chain_Save_Struct));
if (!List.Next) return(0);
List.Length++;
(PreP->Next->Next) = Null;
(PreP->Next->Pre)= PreP;
*Position = Position_1;
return(1);
}
}//为链表添加一个元素；

int Del_Chain (Chain_Save_Struct &List,Chain_Save_Struct **Position)
{ int a,b,c;
Chain_Save_Struct *PreP,*NPosition;
PreP = Null;
if (List.Next==Null||(*Position)->Pre==Null)
{
return 0;
}//if 链表为空表时
for (NPosition=&List;
NPosition != *Position; NPosition = NPosition->Next)PreP = NPosition;//找到当前删除节点的前驱
NPosition = (*Position)->Next;//当前节点的后继
free(*Position);
--List.Length;
//分为当前节点无后继，当前节点有后继两种情况
if (NPosition == Null)
{ *Position =PreP;
printf("无后继");

scanf("%d",&a);
(*Position)->Next = Null ;
return 1;// 当前节点无后继节点
}
else if (NPosition != Null)
{ printf("有后继");

scanf("%d",&a);
*Position = PreP;
PreP->Next = NPosition;
NPosition->Pre = PreP;
return 1;

}//当前节点有后继节点

}

int Chain_Next (Chain_Save_Struct **Position)
{ if (*Position==Null)return 0;
if ((*Position)->Next == Null) return 0;
*Position=((*Position)->Next);
return 1;
}//下移一个位置

int Chain_Pre (Chain_Save_Struct **Position)
{
if (*Position==Null)return 0;
if ((*Position)->Pre == Null) return 0 ;
*Position=((*Position)->Pre);
return 1;
}//上移一个位置

int main()
{
int Create_Chain( Chain_Save_Struct &List );
int Add_Chain ( Chain_Save_Struct &List,Chain_Save_Struct *Position);
int Del_Chain (Chain_Save_Struct &List,Chain_Save_Struct *Position);
int Chain_Next (Chain_Save_Struct *Position) ;
int Chain_Pre (Chain_Save_Struct *Position);
int OnOff = 1;
int Long = 0,Now =0,First=1;
Chain_Save_Struct *Point_1,*Point_2;
Chain_Save_Struct User,User_1;
char Comm[20];

if (Create_Chain(User)==1)
{
printf("\n","存储空间开辟成功");
Point_1 = User.Next;
while (OnOff==1)

{
printf(">:");
scanf("%s", Comm);
if (strcmp("add",strlwr(Comm))== 0)Add_Chain(User,&Point_1);
if (strcmp("del",strlwr(Comm))== 0) if (Del_Chain(User,&Point_1)==0)printf("表已空或当前节点为头节点\n");
if (strcmp("next",strlwr(Comm))== 0)if (Chain_Next(&Point_1)==0)printf ("已到表尾\n");
if (strcmp("back",strlwr(Comm))== 0) if (Chain_Pre(&Point_1)==0)printf ("已到表头\n");
if (strcmp("exit",strlwr(Comm))==0) OnOff =0;

for (Point_2 = User.Next;Point_2!=Null;Point_2 = Point_2->Next)
{
Long++;
if (Point_2==Point_1) Now = Long;
}//for
printf("表长=%d\n",Long);
printf("当前位置=%d\n",Now);
printf("@");
while(Long>=First)
{
printf("#");
First++;
}//while
printf(">\n");
First = 1;
while(Now>=(First))
{
printf(" ");
First++;
}//while
printf("|\n");
printf("Point_1=%d\n",Point_1);
if (Point_1!=Null)printf("Point_1->Pre=%d\n",Point_1->Pre);
if (Point_1!=Null)printf("Point_1->Next=%d\n",Point_1->Next);
printf("当前位置%d\n",Point_1);
printf("User.Length=%d\n",User.Length);
Long=0,Now=0,First=1;
}//while
}//if


else printf("%s\n","存储空间开辟失败");

return 0;
}//main
就在里面做了4个函数，运行后输入add可以添加，del可以删除，next指针下移，back，上移

顺序栈的
#include <malloc.h>
#include <stdio.h>
#include <string.h>
#define List_Max_Size 100
#define Add_Size 10

struct Human_Data {
char Name[20] ;
int Age;
};//定义顺序栈数据结构体
typedef Human_Data Stack_Save_Struct;

struct Stack {
int Length;
int List_Size;
Stack_Save_Struct *Base,*Top;
};//定义顺序栈指针结构体

int Create_Stack( Stack &Stack_List )
{
Stack_List.Base = (Stack_Save_Struct * )malloc ( sizeof(Stack_Save_Struct) * List_Max_Size);
if ( !Stack_List.Base ) return (0);
Stack_List.List_Size = List_Max_Size;
Stack_List.Top = Stack_List.Base;
Stack_List.Length = 0;
return (1);
}//建立一个栈表

int Push_Stack ( Stack &List,Stack_Save_Struct &Data)
{ if (List.Length == List.List_Size)return 0;
*List.Top = Data;
// *Top++ = &Data;
List.Top++;
List.Length++;
return 1;
}//入栈

int Get_Stack ( Stack &List,Stack_Save_Struct &Data)

{ int a;
if ( List.Length == 0)return 0;
Data = *(--List.Top);
List.Length--;
return 1;
}//出栈

int main()
{ char Comm[20];
int a,b,c;
int OnOff = 1;
struct Stack User,User_1;
Stack_Save_Struct Save,Save_1;
int Create_Stack( Stack &Stack_List );
int Push_Stack ( Stack &List,Stack_Save_Struct &Data);
int Get_Stack ( Stack &List,Stack_Save_Struct &Data);

Create_Stack(User);
printf("存储空间开辟成功");
while (OnOff==1)

{ printf(">:");
scanf("%s", Comm);
if (strcmp("push",strlwr(Comm))== 0)
{

printf("在此输入姓名:");
scanf("%s", Save.Name);
printf("在此输入年龄:");
scanf("%d", &Save.Age);
if (Push_Stack(User,Save)== 0)printf("栈满");
}
else if (strcmp("get",strlwr(Comm))== 0)
{
if (Get_Stack(User,Save)== 0)printf("栈空");
else {
printf("%s\n", Save.Name);
printf("%d\n", Save.Age);}
}
}//while


// }//if
return 1 ;
}

运行后输入push和get可以分别入栈和出栈

#include <malloc.h>
#include <stdio.h>
#include <string.h>
#define List_Max_Size 4
#define Add_Size 10

struct Human_Data {
char Name[20] ;
int Age;
};//定义顺序栈数据结构体
typedef Human_Data Stack_Save_Struct;

struct Queue {
int Tail_Position,Head_Position;
int Length;
int List_Size;
Stack_Save_Struct *Base;
};//定义顺序栈指针结构体

int Create_Stack( Queue &Queue_List )
{
Queue_List.Base = (Stack_Save_Struct * )malloc ( sizeof(Stack_Save_Struct) * List_Max_Size);
if ( !Queue_List.Base ) return (0);
Queue_List.List_Size = List_Max_Size;
Queue_List.Head_Position=0;
Queue_List.Tail_Position=0;
Queue_List.Length = 0;
return (1);
}//建立一个队列

int In_Stack ( Queue &List,Stack_Save_Struct &Data)

{ //printf(" tail=%d,Head_Position=%d,base=%d\n", List.Base+((List.Tail_Position%List_Max_Size)+1),List.Head_Position,List.Base);

if (List.Base+((List.Tail_Position+1)%List_Max_Size) == (List.Base+(List.Head_Position%List_Max_Size)))return 0;
List.Tail_Position = List.Tail_Position%List_Max_Size;
*(List.Base+List.Tail_Position) = Data;
List.Tail_Position++;
List.Length++;
return 1;
}//入队

int Out_Stack ( Queue &List,Stack_Save_Struct &Data)

{ if ( List.Base+(List.Head_Position%List_Max_Size) == List.Base+(List.Tail_Position%List_Max_Size))return 0;
Data = *(List.Base+(List.Head_Position%List_Max_Size));
List.Head_Position++;
List.Length--;
return 1;
}//出队

int main()
{ char Comm[20];
int a,b,c;
int OnOff = 1;
struct Queue User,User_1;
Stack_Save_Struct Save,Save_1;
int Create_Stack( Queue &Queue_List );
int In_Stack ( Queue &List,Stack_Save_Struct &Data);
int Out_Stack ( Queue &List,Stack_Save_Struct &Data);

if (Create_Stack(User)==1)
{
printf("存储空间开辟成功\n");
while (OnOff==1)

{ printf(">:");
scanf("%s", Comm);
if (strcmp("in",strlwr(Comm))== 0)
{

printf("在此输入姓名:");
scanf("%s", Save.Name);
printf("在此输入年龄:");
scanf("%d", &Save.Age);
if (In_Stack(User,Save)== 0)printf("队列满,数据没有添加\n");
}
else if (strcmp("out",strlwr(Comm))== 0)
{
if (Out_Stack(User,Save)== 0)printf("队列空\n");
else {
printf("%s\n", Save.Name);
printf("%d\n", Save.Age);
}
}
/* printf("Position=%d,",User.Tail_Position);
printf("Base=%d,",User.Base);
printf("Base+P=%d,",User.Tail_Position%List_Max_Size);
printf("NowAdd=%d,",User.Base+(User.Tail_Position%List_Max_Size));
printf("Head_Position==%d,",User.Head_Position);
printf("Size=%d\n",sizeof(Stack_Save_Struct));*/
}//while


}//if
return 1 ;
}
顺序队列的，输入in和out可以入队和出队，

暂时先发这几个，也不知道大伙用得上用不上，如果用的话，就说一声，我就再把剩下的发上来，没人用我就不占用空间了，还有对称矩阵，稀疏矩阵，Huffman编码的，对了，还有，这些程序在我的c里面是有缩进的，但是发到这里，可能是格式不一样吧，缩进有些乱，大家想看的话就自己下来调一下，就这样，我睡觉去了

不好意思，各位，上次发完后来就一直没上网，就回学校了，这新年了才回来，我把剩下的发给大家伙

霍夫曼编码的
#include <malloc.h>
#include <stdio.h>
#include <string.h>
#define List_Max_Size 100
#define Add_Size 10
#define Null 0

struct Huffman_Data {
char Word[2];
int Weight,LChild,RChild,Parent;
};//定义顺序表数据结构体
typedef Huffman_Data Thread_Save_Struct;

struct Thread_1 {
int Length;
int List_Size;
Thread_Save_Struct *Point;
};//定义顺序表指针结构体
typedef Thread_1 Thread;

typedef struct {
int Min_Weight,Addres;
}Min;

int Create_List( Thread &List )
{
List.Point = (Thread_Save_Struct * )malloc ( sizeof(Thread_Save_Struct) * List_Max_Size);
if ( !List.Point ) return (0);
List.List_Size = List_Max_Size;
List.Length = 0;
return (1);
}//建立一个顺序表

int main ()
{ int Code_Amount,Weight,Value,OnOff=1;
int Create_List( Thread &List );
int Add = 0,Add_1,e=0;
Min j,i;
char Code[100],Code_Swap[100];
Thread_Save_Struct *Point_1;
Thread User;

if (Create_List(User)==1)
{
printf("\n","存储空间开辟成功");

for (Point_1 = (User.Point)+1;OnOff==1 && User.Length<User.List_Size;Point_1++)
{ printf("在此输入字符:");
scanf("%s", Point_1->Word);
printf("在此输入权值:");
scanf("%d", &(Point_1->Weight));
Point_1->Parent = Null;
Point_1->LChild = Null;
Point_1->RChild = Null;
printf("是否继续输入？是(1),否(0):");
scanf("%d",&OnOff);
User.Length++;
}//for

}//if
else printf("%s\n","存储空间开辟失败");
i.Min_Weight=0;
j.Min_Weight=0;
while (i.Min_Weight!=-1 && j.Min_Weight!=-1)
{ i.Min_Weight =-1,j.Min_Weight =-1;
Point_1 = User.Point;
for(Add=1;Add<=User.Length;Add++)
{
if ((Point_1+Add)->Parent == 0)
{
if (i.Min_Weight ==-1||j.Min_Weight ==-1)
{
if (i.Min_Weight ==-1)
{
i.Min_Weight =(Point_1+Add)->Weight;
i.Addres = Add;
}
else if (j.Min_Weight ==-1)
{
j.Min_Weight =(Point_1+Add)->Weight;
j.Addres = Add;
}
}else if((Point_1+Add)->Weight<=i.Min_Weight||(Point_1+Add)->Weight<=j.Min_Weight)
{
if (i.Min_Weight >=j.Min_Weight )
{
i.Min_Weight =(Point_1+Add)->Weight;
i.Addres = Add;
}
if (j.Min_Weight >i.Min_Weight )
{
j.Min_Weight =(Point_1+Add)->Weight;
j.Addres = Add;
}
}//else if
}//if

}//for
if (i.Min_Weight!=-1 && j.Min_Weight!=-1)
{
(Point_1+Add)->Weight = (i.Min_Weight)+(j.Min_Weight);
if ((i.Min_Weight)<=(j.Min_Weight))
{
(Point_1+Add)->LChild =i.Addres;
(Point_1+Add)->RChild =j.Addres;
}
if ((i.Min_Weight)> (j.Min_Weight))
{
(Point_1+Add)->RChild =i.Addres;
(Point_1+Add)->LChild =j.Addres;
}
(Point_1+i.Addres)->Parent = Add;
(Point_1+j.Addres)->Parent = Add;
User.Length++;
}//if

}//while
Add=1;
for (Point_1 = (User.Point+1);Add != User.Length+1 ;Point_1++)
{
printf("parent%d,",Point_1->Parent);
printf("LChild:%d,",Point_1->LChild);
printf("RChild:%d,",Point_1->RChild);
printf("字符:%s,",Point_1->Word);
printf("权值:%d\n",Point_1->Weight);
Add++;
}//for

Point_1 = User.Point;e=0;
for (Add=1;Add<=(User.Length+1+1)/2;Add++)
{
Code[e++]=(Point_1+Add)->Word[0];
for (Add_1=Add;(Point_1+Add_1)->Parent!=0;)
{
if ((Point_1+((Point_1+Add_1)->Parent))->LChild==Add_1) Code[e++]='0';
if ((Point_1+((Point_1+Add_1)->Parent))->RChild==Add_1) Code[e++]='1';
Add_1=(Point_1+Add_1)->Parent;
}
}
printf("%s,",Code);
scanf("%d", &OnOff);
return 1;
}
这个编码还缺最后一个反转编码的小函数，也就是说，正常找码需要从叶子往根找然后再把码调过来，我懒了点，后面的反转函数没写，不好意思，呵呵

这个是稀疏矩阵的三元表存储，和转置


#define ROW 4
#define COL 4
#define Max_Size 9 //非零元最大个数
#include <stdio.h>
typedef int Data;

typedef struct
{
int Row,Col;
Data e;
}Sparse;

typedef struct
{
Sparse Grid[Max_Size+1];
int Count_Row,Count_Col,None_O;
}Tg_Array;

int main()
{

Sparse Sp_Grid;
Tg_Array Grid_1,Grid_T;
int Reg[ROW][COL] = {{1,0,3,0},{2,1,5,0},{0,8,1,0},{9,0,0,1}},Out_Reg[ROW][COL],Out_Reg_T[ROW][COL];
int Count_Col,Count_Row,Count=1,Count_1=1,Count_2=1;
Grid_1.Count_Row = ROW,Grid_1.Count_Col = COL;



//打印此距阵
for (Count_Row=0;Count_Row<ROW;Count_Row++)
{ for (Count_Col=0;Count_Col<COL;Count_Col++)
{
printf("%d,",Reg[Count_Row][Count_Col]);
}
printf("\n");
}

//将稀疏距阵存入三元组中(以行为主序存)
for (Count_Row=0;Count_Row<ROW;Count_Row++)
{
for (Count_Col=0;Count_Col<COL;Count_Col++)
{

if (Reg[Count_Row][Count_Col]!=0)
{
if (Count > Max_Size )
{ printf("非零元个数超出限定最大值\n");
break;
}
Grid_1.Grid[Count].Row=Count_Row;
Grid_1.Grid[Count].Col=Count_Col;
Grid_1.Grid[Count].e=Reg[Count_Row][Count_Col];
Grid_1.None_O++;
Count++;
}
}

}

//矩阵的转置（行主序)
Count_Row = 0;
Count_Col=0;
for(Count = 1;Count<=Max_Size;Count++)
{
for(Count_1=1;Count_1<=Max_Size;Count_1++)
{
if (Grid_1.Grid[Count_1].Col==Count-1)
{
Grid_T.Grid[Count_2].Row = Grid_1.Grid[Count_1].Col;
Grid_T.Grid[Count_2].Col = Grid_1.Grid[Count_1].Row;
Grid_T.Grid[Count_2].e = Grid_1.Grid[Count_1].e;
Count_2++;
}
}
}

//根据三元组输出距阵 (行主序)
Count_Row = 0;
Count_Col=0;
Count = 1;

for (Count_Row=0;Count_Row<ROW;Count_Row++)
{
for (Count_Col=0;Count_Col<COL;Count_Col++)
{ if (Count_Row == Grid_1.Grid[Count].Row && Count_Col == Grid_1.Grid[Count].Col)
Out_Reg[Count_Row][Count_Col]= Grid_1.Grid[Count++].e;
else Out_Reg[Count_Row][Count_Col]= 0;
}
}

//根据转置三元组输出距阵 (行主序)
Count_Row = 0;
Count_Col=0;
Count = 1;

for (Count_Row=0;Count_Row<ROW;Count_Row++)
{
for (Count_Col=0;Count_Col<COL;Count_Col++)
{ if (Count_Row == Grid_T.Grid[Count].Row && Count_Col == Grid_T.Grid[Count].Col)
Out_Reg_T[Count_Row][Count_Col]= Grid_T.Grid[Count++].e;
else Out_Reg_T[Count_Row][Count_Col]= 0;
}
}

//打印输出数组
printf("输出稀疏矩阵为:\n");
for (Count_Row=0;Count_Row<ROW;Count_Row++)
{ for (Count_Col=0;Count_Col<COL;Count_Col++)
{
printf("%d,",Out_Reg[Count_Row][Count_Col]);
}
printf("\n");
}

//打印输出转置数组
printf("输出转置稀疏矩阵为:\n");
for (Count_Row=0;Count_Row<ROW;Count_Row++)
{ for (Count_Col=0;Count_Col<COL;Count_Col++)
{
printf("%d,",Out_Reg_T[Count_Row][Count_Col]);
}
printf("\n");
}

scanf("%d",&Count_Col);
return 1;
}

这个试图的邻接表存储和遍历

#include <malloc.h>
#include <string.h>
#define List_Max_Size 100
#define Add_Size 10
#define Null 0
#define Row 4
#define True 1
#define False 0
#include <stdio.h>

struct Element{
int Data,Addr,Length;
struct Element *Next,*Pre;
};//定义链式表数据结构体
typedef Element Chain_Save_Struct;
typedef Element Head_Chain;

int Create_Chain( Chain_Save_Struct &List )
{
List.Length = 0;
List.Next = Null;
List.Pre = Null;
return (1);
}//建立一个链式表

int Add_Chain ( Head_Chain &List,Chain_Save_Struct **Position)
{
Chain_Save_Struct *Position_1,*PreP;
if (List.Next==Null)
{
List.Next = (Chain_Save_Struct * )malloc ( sizeof(Chain_Save_Struct));
if (!List.Next) return(0);
List.Length=1;
(List.Next -> Next) = Null;
(List.Next ->Pre) = &List;
*Position = List.Next;
return(1);
}
else
{
Position_1 = *Position;
for (*Position = (List.Next);
*Position !=NULL; *Position=(*Position)->Next)PreP = *Position;
PreP->Next = (Chain_Save_Struct * )malloc ( sizeof(Chain_Save_Struct));
if (!List.Next) return(0);
List.Length++;
(PreP->Next->Next) = Null;
(PreP->Next->Pre)= PreP;
*Position = Position_1;
return(1);
}
}//为链表添加一个元素；

int Del_Chain (Chain_Save_Struct &List,Chain_Save_Struct **Position)
{ int a,b,c;
Chain_Save_Struct *PreP,*NPosition;
PreP = Null;
if (List.Next==Null||(*Position)->Pre==Null)
{
return 0;
}//if 链表为空表时
for (NPosition=&List;
NPosition != *Position; NPosition = NPosition->Next)PreP = NPosition;//找到当前删除节点的前驱
NPosition = (*Position)->Next;//当前节点的后继
free(*Position);
--List.Length;
//分为当前节点无后继，当前节点有后继两种情况
if (NPosition == Null)
{ *Position =PreP;
printf("无后继");

scanf("%d",&a);
(*Position)->Next = Null ;
return 1;// 当前节点无后继节点
}
else if (NPosition != Null)
{ printf("有后继");

scanf("%d",&a);
*Position = PreP;
PreP->Next = NPosition;
NPosition->Pre = PreP;
return 1;

}//当前节点有后继节点
}

int Chain_Next (Chain_Save_Struct **Position)
{ if (*Position==Null)return 0;
if ((*Position)->Next == Null) return 0;
*Position=((*Position)->Next);
return 1;
}//下移一个位置

int Chain_Pre (Chain_Save_Struct **Position)
{
if (*Position==Null)return 0;
if ((*Position)->Pre == Null) return 0 ;
*Position=((*Position)->Pre);
return 1;
}//上移一个位置

int Opera(Chain_Save_Struct Adj[Row],int Addr)
{
Adj[Addr].Data = False;
printf("Add=%d,",Addr);

return 1;
}//操作节点

int Deep_Order(Chain_Save_Struct Adj[Row],int Addr)
{
// Opera(Chain_Save_Struct Adj[Row],int Addr);
Element *Point;
Opera(Adj,Addr);
printf(",%d",Adj[Addr].Next);

for(Point = Adj[Addr].Next;Point.Next!=Null && Adj[Point->Addr].Data==False;Point=Point->Next);
Point =Point->Next
if (Point==Null)
{

for(Addr = 0;Addr<=Row-1;Addr++)
{
if (Adj[Addr].Data==True)break;
else if (Addr == Row-1)return 1;
}
}
Deep_Order(Adj,Point->Addr);

return 1;
}//图的邻接表的深度遍历



int main()
{ int Tragle[Row][Row] = {{0,0,0,0},{1,0,1,1},{0,0,0,1},{1,0,0,0}};
Chain_Save_Struct Adj_List[Row],*Point;
int Deep_Order(Chain_Save_Struct Adj[Row],int Addr);
int Addr;
int i,j,Col;
for (i=0;i<=(Row-1);i++)
{
Create_Chain(Adj_List[i]);
Adj_List[i].Data = True;
Point=&(Adj_List[i]);
for (j=0;j<=(Row-1);j++)
{
if (Tragle[i][j]==1)
{
Add_Chain(Adj_List[i],&Point);
if (Point->Next!=Null)Point=Point->Next;
Point->Addr =j;
}
}
}//根据给定的矩阵求图的逆邻接表

for (i=0;i<=(Row-1);i++)
{
printf("是否被访问过:%d,",Adj_List[i].Data);
printf("节点名=%d",i);
for (Point=Adj_List[i].Next;Point!=Null;Point=Point->Next)
{
printf("->%d",Point->Addr);
}
printf("\n");
}

//逆邻接表在此位置
//图的深度优先遍历
Addr =0;
Deep_Order(Adj_List, Addr);
//图的广度优先遍历

scanf("%d",Col);
return 1;
}