算法只是具体的实现步骤的指令集合！但是算法也是数据结构最重要的一部份！设计一个好的算法可以提高自己程序的运行效率！（算法不一定要求能够在计算机上直接运行，但程序必须要求能在计算机中运行）
C语言只是对算法或者数据结构的描述！描述数据结构和算法不局限于C语言，也可以是C++语言和其他的计算机语言甚至也可以用人的自然语言！
所以只是说学习好C语言能够使自己学习的数据结构理论更好的在计算机中描述和表达！
这是链式队列的代码：#include "stdio.h"
#include "stdlib.h"
#include "io.h"
#include "math.h"
#include "time.h"
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */
typedef int Status
typedef int QElemType/* QElemType类型根据实际情况而定，这里假设为int */
typedef struct QNode/* 结点结构 */
{
QElemType data
struct QNode *next
}QNode,*QueuePtr
typedef struct/* 队列的链表结构 */
{
QueuePtr front,rear/* 队头、队尾指针 */
}LinkQueue
Status visit(QElemType c)
{
printf("%d ",c)
return OK
}
/* 构造一个空队列Q */
Status InitQueue(LinkQueue *Q)
{
Q->front=Q->rear=(QueuePtr)malloc(sizeof(QNode))
if(!Q->front)
exit(OVERFLOW)
Q->front->next=NULL
return OK
}
/* 销毁队列Q */
Status DestroyQueue(LinkQueue *Q)
{
while(Q->front)
{
Q->rear=Q->front->next
free(Q->front)
Q->front=Q->rear
}
return OK
}
/* 将Q清为空队列 */
Status ClearQueue(LinkQueue *Q)
{
QueuePtr p,q
Q->rear=Q->front
p=Q->front->next
Q->front->next=NULL
while(p)
{
q=p
p=p->next
free(q)
}
return OK
}
/* 若Q为空队列,则返回TRUE,否则返回FALSE */
Status QueueEmpty(LinkQueue Q)
{
if(Q.front==Q.rear)
return TRUE
else
return FALSE
}
/* 求队列的长度 */
int QueueLength(LinkQueue Q)
{
int i=0
QueuePtr p
p=Q.front
while(Q.rear!=p)
{
i++
p=p->next
}
return i
}
/* 若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR */
Status GetHead(LinkQueue Q,QElemType *e)
{
QueuePtr p
if(Q.front==Q.rear)
return ERROR
p=Q.front->next
*e=p->data
return OK
}
/* 插入元素e为Q的新的队尾元素 */
Status EnQueue(LinkQueue *Q,QElemType e)
{
QueuePtr s=(QueuePtr)malloc(sizeof(QNode))
if(!s) /* 存储分配失败 */
exit(OVERFLOW)
s->data=e
s->next=NULL
Q->rear->next=s /* 把拥有元素e的新结点s赋值给原队尾结点的后继，见图中① */
Q->rear=s /* 把当前的s设置为队尾结点，rear指向s，见图中② */
return OK
}
/* 若队列不空,删除Q的队头元素,用e返回其值,并返回OK,否则返回ERROR */
Status DeQueue(LinkQueue *Q,QElemType *e)
{
QueuePtr p
if(Q->front==Q->rear)
return ERROR
p=Q->front->next /* 将欲删除的队头结点暂存给p，见图中① */
*e=p->data /* 将欲删除的队头结点的值赋值给e */
Q->front->next=p->next/* 将原队头结点的后继p->next赋值给头结点后继，见图中② */
if(Q->rear==p)/* 若队头就是队尾，则删除后将rear指向头结点，见图中③ */
Q->rear=Q->front
free(p)
return OK
}
/* 从队头到队尾依次对队列Q中每个元素输出 */
Status QueueTraverse(LinkQueue Q)
{
QueuePtr p
p=Q.front->next
while(p)
{
visit(p->data)
p=p->next
}
printf("\n")
return OK
}
int main()
{
int i
QElemType d
LinkQueue q
i=InitQueue(&q)
if(i)
printf("成功地构造了一个空队列!\n")
EnQueue(&q,-5)
EnQueue(&q,5)
EnQueue(&q,10)
printf("插入3个元素(-5,5,10)后,队列的长度为%d\n",QueueLength(q))
printf("队列的元素依次为：")
QueueTraverse(q)
i=GetHead(q,&d)
if(i==OK)
printf("队头元素是：%d\n",d)
DeQueue(&q,&d)
printf("删除了队头元素%d\n",d)
i=GetHead(q,&d)
if(i==OK)
printf("新的队头元素是：%d\n",d)
ClearQueue(&q)
printf("清空队列后,q.front=%u q.rear=%u q.front->next=%u\n",q.front,q.rear,q.front->next)
DestroyQueue(&q)
printf("销毁队列后,q.front=%u q.rear=%u\n",q.front, q.rear)
return 0
}
这是二叉树后序遍历的代码：
void PostOrder(BiTree root)
{
if(root==NULL)
return
PostOrder(root->lchild) //递归调用，后序遍历左子树
PostOrder(root->rchild) //递归调用，后序遍历右子树
printf("%c ", root->data) //输出数据
}
希望能帮到你，如还有不懂，可以加我的QQ:11301655
注释非常详细，希望对你有所帮助。#include<stdio.h>
#include<stdlib.h>
#define M 15
#define N 15
struct mark //定义迷宫内点的坐标类型
{
int x
int y
}
struct Element //"恋"栈元素，嘿嘿。。
{
int x,y//x行,y列
int d//d下一步的方向
}
typedef struct LStack //链栈
{
Element elem
struct LStack *next
}*PLStack
/*************栈函数****************/
int InitStack(PLStack &S)//构造空栈
{
S=NULL
return 1
}
int StackEmpty(PLStack S)//判断栈是否为空
{
if(S==NULL)
return 1
else
return 0
}
int Push(PLStack &S, Element e)//压入新数据元素
{
PLStack p
p=(PLStack)malloc(sizeof(LStack))
p->elem=e
p->next=S
S=p
return 1
}
int Pop(PLStack &S,Element &e) //栈顶元素出栈
{
PLStack p
if(!StackEmpty(S))
{
e=S->elem
p=S
S=S->next
free(p)
return 1
}
else
return 0
}
/***************求迷宫路径函数***********************/
void MazePath(struct mark start,struct mark end,int maze[M][N],int diradd[4][2])
{
int i,j,dint a,b
Element elem,e
PLStack S1, S2
InitStack(S1)
InitStack(S2)
maze[start.x][start.y]=2//入口点作上标记
elem.x=start.x
elem.y=start.y
elem.d=-1//开始为-1
Push(S1,elem)
while(!StackEmpty(S1)) //栈不为空 有路径可走
{
Pop(S1,elem)
i=elem.x
j=elem.y
d=elem.d+1//下一个方向
while(d<4) //试探东南西北各个方向
{
a=i+diradd[d][0]
b=j+diradd[d][1]
if(a==end.x &&b==end.y &&maze[a][b]==0) //如果到了出口
{
elem.x=i
elem.y=j
elem.d=d
Push(S1,elem)
elem.x=a
elem.y=b
elem.d=886//方向输出为-1 判断是否到了出口
Push(S1,elem)
printf("\n0=东 1=南 2=西 3=北 886为则走出迷宫\n\n通路为:(行坐标,列坐标,方向)\n")
while(S1) //逆置序列 并输出迷宫路径序列
{
Pop(S1,e)
Push(S2,e)
}
while(S2)
{
Pop(S2,e)
printf("-->(%d,%d,%d)",e.x,e.y,e.d)
}
return//跳出两层循环，本来用break,但发现出错，exit又会结束程序，选用return还是不错滴
}
if(maze[a][b]==0) //找到可以前进的非出口的点
{
maze[a][b]=2//标记走过此点
elem.x=i
elem.y=j
elem.d=d
Push(S1,elem)//当前位置入栈
i=a//下一点转化为当前点
j=b
d=-1
}
d++
}
}
printf("没有找到可以走出此迷宫的路径\n")
}
/*************建立迷宫*******************/
void initmaze(int maze[M][N])
{
int i,j
int m,n//迷宫行,列 [/M]
printf("请输入迷宫的行数 m=")
scanf("%d",&m)
printf("请输入迷宫的列数 n=")
scanf("%d",&n)
printf("\n请输入迷宫的各行各列:\n用空格隔开,0代表路,1代表墙\n",m,n)
for(i=1i<=mi++)
for(j=1j<=nj++)
scanf("%d",&maze[i][j])
printf("你建立的迷宫为(最外圈为墙)...\n")
for(i=0i<=m+1i++) //加一圈围墙
{
maze[i][0]=1
maze[i][n+1]=1
}
for(j=0j<=n+1j++)
{
maze[0][j]=1
maze[m+1][j]=1
}
for(i=0i<=m+1i++) //输出迷宫
{
for(j=0j<=n+1j++)
printf("%d ",maze[i][j])
printf("\n")
}
}
void main()
{
int sto[M][N]
struct mark start,end//start,end入口和出口的坐标
int add[4][2]={{0,1},{1,0},{0,-1},{-1,0}}//行增量和列增量 方向依次为东西南北 [/M]
initmaze(sto)//建立迷宫
printf("输入入口的横坐标,纵坐标[逗号隔开]\n")
scanf("%d,%d",&start.x,&start.y)
printf("输入出口的横坐标,纵坐标[逗号隔开]\n")
scanf("%d,%d",&end.x,&end.y)
MazePath(start,end,sto,add)//find path
system("PAUSE")
}
测试数据，算法复杂度你就自己来写吧，如果你连这都不自己做，那你一定是在应付作业。劝你还是自己运行测试一下吧，免得答辩时老师问你，什么都不知道，那你就悲剧了。祝你好运！！
