久久99热这里只频精品6,久久精品国产亚洲av麻豆图片,性高湖久久久久久久久

�q�宫的求�?数据�l�构的栈�q�用)

Wed, 19 Oct 2005 12:47:00 GMT

//base.h
#include
#include
#include
#define OVERFLOW -2
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int Status;

//stack.h
#define STACK_INIT_SIZE 100 //存储�I�间初始�?BR>#define STACK_INCREMENT 10//存储�I�间初始增量
typedef struct
{
int r;
int c;
}PostType;//坐标位置 �q�宫的r行c�?BR>typedef struct
{
int ord;//通道块在路径上的序号
PostType seat;//通道块的当前坐标位置
int di;//通道块指向下一通道块的方向
}SElemType;//栈元素的�c�d��
typedef struct
{
SElemType *base;//栈底指针
SElemType *top;//栈顶指针
int stacksize;//栈的最大容�?BR>}Stack;//栈的�c�d��

Status InitStack(Stack &S)//初始化栈
{
S.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!S.base)
exit(OVERFLOW);//存储分配��p�|;
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return OK;
}//InitStack

Status StackEmpty(Stack S)
//判断栈是否�ؓ�I?如果为空�q�回TRUE,否则�q�回FALSE
{
if(S.top==S.base)
return TRUE;
return FALSE;
}//StackEmpty

Status Push(Stack &S,SElemType e)
//插入元素为e的栈��元�?BR>{
if(S.top-S.base>=S.stacksize)
{
  S.base=(SElemType*)realloc(S.base,(S.stacksize+STACK_INCREMENT)*sizeof(SElemType));
       if(!S.base)
       exit(OVERFLOW);
    S.top=S.base+S.stacksize;
    S.stacksize+=STACK_INCREMENT;
}
*S.top++=e;
return OK;
}//Push

Status Pop(Stack &S,SElemType &e)
//删除栈顶元素存入e
{
if(S.top==S.base)
return ERROR;
e=*--S.top;
return OK;
}//Pop

Status DestroyStack(Stack &S)
//销毁栈
{
free(S.base);
S.top=S.base;
return OK;
}//DestroyStack

//maze.cpp
#define MAXLEN 20//�q�宫包括外墙最大行列数�?BR>typedef struct{
         int r;
         int c;
         char adr[MAXLEN][MAXLEN];//可取' ''*' '@' '#'
}MazeType;   //�q�宫�c�d��

Status InitMaze(MazeType &maze){
//初始化迷宫若成功�q�回TRUE,否则�q�回FALSE
         int m,n,i,j,k=1;
         printf("输入�q�口的行数和列数: ");
         scanf("%d%d",&maze.r,&maze.c); //�q�宫行和列数
         for(i=0;i<=maze.c+1;i++){//�q�宫行外�?BR>                   maze.adr[0][i]='#';
                   maze.adr[maze.r+1][i]='#';
         }//for
         for(i=0;i<=maze.r+1;i++){//�q�宫列外�?BR>                  maze.adr[i][0]='#';
                   maze.adr[i][maze.c+1]='#';
         }
         for(i=1;i<=maze.r;i++)
                   for(j=1;j<=maze.c;j++)
                            maze.adr[i][j]=' ';//初始化迷�?BR>         printf("输入障碍�?d的坐�?以坐�?0,0)�l�束输入): ",k);
         scanf("%d%d",&m,&n);//接收障碍的坐�?BR>   k++;
       while(m!=0)
    {
                   if(m>maze.r || n>maze.c)//��界
                        exit(ERROR);
                   maze.adr[m][n]='#';//�q�宫障碍�?#'标记
                   printf("输入障碍�?d的坐�?以坐�?0,0)�l�束输入): ",k);
                   scanf("%d%d",&m,&n);
       k++;
        }
         return OK;
}//InitMaze

Status Pass(MazeType maze,PostType curpos){
//当前位置可通则�q�回TURE,否则�q�回FALSE
         if(maze.adr[curpos.r][curpos.c]==' ')//可�?BR>                   return TRUE;
         else
                   return FALSE;
}//Pass

Status FootPrint(MazeType &maze,PostType curpos){
//若走�q��ƈ且可通返回TRUE,否则�q�回FALSE
//在返回之前销毁栈S
maze.adr[curpos.r][curpos.c]='*';//"*"表示可�?BR> return OK;
}//FootPrint

PostType NextPos(PostType &curpos,int i){
//指示�q�返回下一位置的坐�?BR>         PostType cpos;
         cpos=curpos;
         switch(i){        //1.2.3.4分别表示�?�?�?北方�?BR>                   case 1 : cpos.c+=1; break;
                   case 2 : cpos.r+=1; break;
                   case 3 : cpos.c-=1; break;
                   case 4 : cpos.r-=1; break;
                   default: exit(ERROR);
         }
         return cpos;
}//Nextpos

Status MarkPrint(MazeType &maze,PostType curpos){
//曾走�q�但不是通�\标记�q�返回OK
maze.adr[curpos.r][curpos.c]='@';//"@"表示曾走�q�但不�?BR> return OK;
}//MarkPrint

void PrintMaze(MazeType &maze)
//��最后标记好的迷宫输�?BR>{
int i,j;
printf("\n输出�q�宫的�\�?\n");
for(i=0;i<=maze.c+1;i++)
  printf("%4d",i);//输出列数
printf("\n");
for(i=0;i<=maze.r+1;i++)
{
  printf("%d",i);//输出行数
  for(j=0;j<=maze.c+1;j++)
   printf("%4c",maze.adr[i][j]);//输出�q�宫
  printf("\n");
}
}//PrintMaze

Status MazePath(MazeType &maze,PostType start,PostType end)
//若迷宫从入口start到end的通道则求得一条存攑֜�栈中
{
Stack S;//初始化栈
PostType curpos;
int curstep;
SElemType e;
InitStack(S);
curpos=start;
curstep=1;
do
{
  if(Pass(maze,curpos))//当前位置可通过而未曾走�q�留下��q?BR>  {
   FootPrint(maze,curpos);
   e.ord=curstep;e.seat=curpos;e.di=1;
   Push(S,e);//加入栈�\径中
     if(curpos.r==end.r && curpos.c==end.c)//到达出口�q�回TRUE
    {
    if(!DestroyStack(S))
    exit(OVERFLOW);
       else return TRUE;
    }
     else
      {
    curpos=NextPos(curpos,1);//下一位置是当前位�|?BR>    curstep++;//探烦下一�?BR>     }
  }//if
  else//当前位置不能通过
  {
   if(!StackEmpty(S))
   {
    Pop(S,e);//提取前一位置
    while (e.di==4 && !StackEmpty(S))//4个方向都不能通过则留下记号@ 提取前一个位�|�进行判断是否是能通过
    {
     MarkPrint(maze,e.seat);
     Pop(S,e);
    }
    if(e.di<4)//换下一个方向探�?nbsp; 讑֮�当前位置��新方向上的邻�?nbsp;
    {
     e.di++;
     Push(S,e);
     curpos=NextPos(e.seat,e.di);
    }
   }//if
  }
}while(!StackEmpty(S));
if(!DestroyStack(S))
  exit(ERROR);
else return FALSE;
}//MazePath

void main()
{
MazeType maze;
PostType start,end;
char c;
do
{
  printf("----------找一条迷宫的路径-------------\n");
  if(!InitMaze(maze))
  {
   printf("\n 初始化迷宫失�?!!");
   exit(ERROR);
  }
  do
  {
   printf("\n误��入入口的坐标:");
    scanf("%d%d",&start.r,&start.c);//输入入口坐标
   if(start.r>maze.r || start.c>maze.c)
    printf("\n输入错误,请重新输入入口的坐标!!\n");
   continue;
  }
  while (start.r>maze.r || start.c>maze.c);
  do
  {
   printf("\n误��入出口的坐标:");//输入出口的坐�?BR>   scanf("%d%d",&end.r,&end.c);
   if(end.r>maze.r || end.c>maze.c)
    printf("\n输入错误,请重新输入出口坐�?!\n");
   continue;
  }
  while (end.r>maze.r || end.c>maze.c);
  if(!MazePath(maze,start,end))
   printf("\n不能扑ֈ�一条�\�?!!\n");
  else PrintMaze(maze);//输出�q�宫
  printf("是否要��l?(y/n):");
  scanf("%s",&c);
}
while (c=='y' || c=='Y');
}//main

无情�?/a> 2005-10-19 20:47 发表评论

Tue, 18 Oct 2005 15:23:00 GMT

//数据�l�构�Q�C语言版）中栈的习�?/P>

#include
#include
#include
#include
#define ERROR 0
#define OK 1
typedef struct{
int OccurTime;
int NType;
}Event;
typedef struct{
int ArrivalTime;
int Duration;
}QElemType;
struct LNODE
{
Event data;
struct LNODE *next;
};
typedef struct LNODE LNode;
typedef struct LNODE *LinkList;
typedef struct LNODE *EvenList;
typedef struct QNode{
QElemType elem;
struct QNode *next;
}QNode,*QueuePtr;
typedef struct
{ QueuePtr front;
QueuePtr rear;
}LinkQueue;
EvenList ev;
Event en;
LinkQueue q[5];
QElemType customer;
int TotalTime,CustomerNum,CloseTime;

int InitList(EvenList *L)
{
*L=(LNode *)malloc(sizeof(LNode));
if(!(*L))   exit(ERROR);
(*L)->next=NULL;
return OK;
}
int DelFirst(EvenList *L,Event *e)
{ LNode *pc,*q;
pc=*L;q=pc->next;
pc->next=q->next;*e=q->data;return OK;}
int ListEmpty(LNode L)
{LNode *p;
int j=0;
p=L.next;
while(p)
   {j++;break;}
if(j==0) return 1;
else return 0;
}
int compare(Event a,Event b)
{ if(a.OccurTime>b.OccurTime) return 1;
else if(a.OccurTime==b.OccurTime) return 0;
else return -1;
}
int OrderInsert(EvenList *L,Event e,int (* cmp)(Event ,Event ))
{ LNode *p,*pc;/*把事件插入链�?/
p=(LNode *)malloc(sizeof(LNode));/*分配�I�间*/
if(!p) { printf("not"); return(0);}
if(ListEmpty(**L))
{ p->data=e;p->next=(*L)->next;(*L)->next=p;}
else {
   switch(cmp(((*L)->next)->data,e))
{case -1:pc=(*L)->next;
   while(pc->next!=NULL)
   {
    if((pc->next)->data.OccurTime<=e.OccurTime)
        pc=pc->next;
    else break;
   }
       p->data=e;p->next=pc->next;/*把它接在比它大的�?/
       pc->next=p;break;
     case 0:pc=(*L)->next;/*相等�Ӟ��接在相等的后�?/
     p->data=e;p->next=pc->next;
     pc->next=p;break;
     case 1:p->data=e;p->next=(*L)->next;
        (*L)->next=p;break;/*��于�Ӟ��接在最前面*/
}}
return 1;
}
void DestroyList(EvenList *L)/*销毁表*/
{LNode *p;
while(*L)
   {p=(*L)->next;free(*L);*L=p;}
}
int InitQueue(LinkQueue *Q)/*初始化队�?/
{ Q->front=Q->rear=(QueuePtr)malloc(sizeof(QNode));
if(!Q->front) exit(0);
(Q->front)->next=NULL;
return OK;
}
int DestroyQueue(LinkQueue *Q)/*销毁队�?/
{ while(Q->front)
    { Q->rear=Q->front->next;
     free(Q->front);
     Q->front=Q->rear;
    }
return OK;
}
int EnQueue(LinkQueue *Q,QElemType e)/*插在队最�?/
{QueuePtr p;
p=(QueuePtr)malloc(sizeof(QNode));
if(!p) exit(0);
p->elem=e;p->next=NULL;
(Q->rear)->next=p;
Q->rear=p;/*重新讄��队尾*/
return OK;
}
int QueueEmpty(LinkQueue Q)
{ if(Q.front==Q.rear) return OK;
else return 0;}
int DelQueue(LinkQueue *Q,QElemType *e)/*删除队的�W�一个元�?/
{QueuePtr p;
if(QueueEmpty(*Q)) return ERROR;
p=(Q->front)->next;
*e=p->elem;
(Q->front)->next=p->next;
if(Q->rear==p) Q->rear=Q->front;
free(p);
return OK;
}
void GetHead(LinkQueue Q,QElemType *a)
{QNode *p;
if(Q.front==Q.rear) exit(0);
p=(Q.front)->next;
*a=p->elem;
}
int QueueLength(LinkQueue Q)/*队的长度*/
{ int i=0;
QNode *pc;
if(Q.front==Q.rear) return 0;
pc=Q.front;
while(pc->next)
{i++;pc=pc->next;}
return i;
}
int Mininum(LinkQueue *Q)/*求长度最短的�?/
{ int a[4],e,j,i;
for(i=1;i<=4;i++)
      a[i-1]=QueueLength(Q[i]);
e=a[0];j=1;
for(i=1;i<=3;i++)
      if(e>a[i]) {e=a[i];j=i+1;}
return j;
}
void OpenForDay()/*初始化操�?/
{ int i;
TotalTime=0;CustomerNum=0;/*初始化篏计时间和客户�?/
InitList(&ev);
en.OccurTime=0;en.NType=0;/*讑֮��W�一个客户到达事�?/
OrderInsert(&ev,en,compare);/*把它插入事�g�?/
for(i=1;i<=4;i++) InitQueue(&q[i]);/*�|�空队列*/
}
void Random(int *a,int *b)/*生成随机敎ͼ�a为每个客户办理时间在30分钟内，
                           b ��Z��盔R��客户到达的间隔时间不��过5分钟*/
{ *a=0+rand()%30;*b=0+rand()%5;}
void CustomerArrived()/*处理客户到达事�g*/
{int durtime,intertime,t,i,b;
++CustomerNum;/*记录客户�?/
Random(&durtime,&intertime);
b=en.OccurTime;
t=en.OccurTime+intertime;/*下一客户到达时刻*/
if(t    {en.OccurTime=t;en.NType=0;
     OrderInsert(&ev,en,compare);
    }
i=Mininum(q);/*求队列最�?/
customer.ArrivalTime=b;customer.Duration=durtime;/*��插入队的客户讄��到达旉��和办理所需旉��*/
EnQueue(&q[i],customer);
if(QueueLength(q[i])==1)
     {en.OccurTime=b+durtime;en.NType=i;
      OrderInsert(&ev,en,compare);/*讑֮��W�i 个离开事�g�q�插入事件表*/
      }
}
void CustomerDeparture()/*处理客户��d��事�g*/
{int i;
i=en.NType;DelQueue(&q[i],&customer);/*删除�W�i队列的排头客�?/
TotalTime+=en.OccurTime-customer.ArrivalTime;/*累计客户逗留旉��*/
if(!QueueEmpty(q[i]))/*讑֮��W�i队列的一个将要离开事�g�q�插入事件表*/
    { GetHead(q[i],&customer);/*得到它的资料*/
     en.OccurTime+=customer.Duration;en.NType=i;
     OrderInsert(&ev,en,compare);
     }
}
void Bank_Simulation()
{
OpenForDay();/*初始�?/
while(!ListEmpty(*ev))/*非空�Ӟ��删掉表里的第一�?/
   { DelFirst(&ev,&en);
     if(en.NType==0)
CustomerArrived();/*是客戯��没办理的�Q�就处理到达事�g*/
     else CustomerDeparture();/*否则处理��d��事�g*/
   }
printf("The Average Time is %.2f\n",(float)TotalTime/CustomerNum);
}
void main()
{scanf("%d",&CloseTime);/*输入关门旉��*/
Bank_Simulation();
getch();
}

无情�?/a> 2005-10-18 23:23 发表评论

栈的实现与表�C�，以及数制转换�Q�符号配对的问题

Thu, 13 Oct 2005 16:05:00 GMT

以下是栈的一些基本操作：

#define STACK_INIT_SIZE 10

#define STACKINCREMENT 2

typedef struct

{

SElemType *base;

SElemType *top;

int stacksize;

} Sqstack;

int InitStack(Sqstack &S)

{

if(!(S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType))))

exit(OVERFLOW);

S.top=S.base;

S.stacksize=STACK_INIT_SIZE;

return OK;

}

int DestroyStack(Sqstack &S)

{

free(S.base);

S.base=NULL;

S.top=NULL;

S.stacksize=0;

return OK;

}

int ClearStack(Sqstack &S)

{

S.top=S.base;

return OK;

}

int StackEmpty(Sqstack S)

{

if(S.top==S.base)

return TRUE;

else

return FALSE;

}

int StackLength(Sqstack S)

{

return S.top-S.base;

}

int GetTop(Sqstack S,SElemType &e)

{

if(S.top>S.base)

{

e=*(S.top-1);

return OK;

}

else

return ERROR;

}

int Push(Sqstack &S,SElemType e)

{

if(S.top-S.base>=S.stacksize)

{

S.base=(SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));

if(!S.base)

exit(OVERFLOW);

S.top=S.base+S.stacksize;

S.stacksize+=STACKINCREMENT;

}

*(S.top)++=e;

return OK;

}

int Pop(Sqstack &S,SElemType &e)

{

if(S.top==S.base)

return FALSE;

e=*--S.top;

return OK;

}

int StackTraverse(Sqstack &S,SElemType (*visit)(SElemType))

{

while(S.top>S.base)

visit(*S.base++);

return OK;

}

1�Q�数制�{�?/SPAN>:

��一个十�q�制转换成八�Q�十六进制数�?/SPAN>

typedef int SElemType; // 定义栈元素类型�ؓ整型

#include"c1.h"

//#include"c3-1.h" // 采用��序�?/SPAN>

#include"c2.cpp" // 利用��序栈的基本操作

/*void conversion()

{ // 对于输入的�Q意一个非�?/SPAN>10�q�制整数�Q�打印输��Z��其等值的16�q�制�?/SPAN>

SqStack s;

unsigned n; // 非负整数

SElemType e;

InitStack(s); // 初始化栈

printf("n(>=0)=");

scanf("%u",&n); // 输入非负十进制整�?/SPAN>n

while(n) // �?/SPAN>n不等�?/SPAN>0

{

Push(s,n%16); // 入栈n除以16的余�?/SPAN>(16�q�制的低�?/SPAN>)

n=n/16;

}

while(!StackEmpty(s)) // 当栈不空

{

Pop(s,e); // 弹出栈顶元素且赋值给e

if(e<=9)

printf("%d",e);

else

printf("%c",e+55);

}

printf("\n");

}*/

void conversion()

{

Sqstack S;

unsigned N;

SElemType e;

InitStack(S);

scanf("%u",&N);

while(N)

{

Push(S,N%8);

N=N/8;

}

while(!StackEmpty(S))

{

Pop(S,e);

printf("%d",e);

}

void main()

{

conversion();

}

2.括号配对的检�?/SPAN>:

typedef char SElemType;

#include"c1.h"

#include"c2.cpp"

void matching()

{

Sqstack S;

InitStack(S);

char *p,a[100],e;

int state;

printf("误��入一�l�符�?/SPAN>(仅只能含有三�U?/SPAN>{},(),[]):");

gets(a);

p=a;

state=1;

while(*p && state)

{

if(!(*p=='{' || *p=='}' || *p=='[' || *p==']' || *p=='(' || *p==')'))

{

printf("输入不正��?/SPAN>!");

exit(ERROR);

}

switch (*p)

{

case '(':

case '{':

case '[':{

Push(S,*p++);

break;

}

case ')':{

GetTop(S,e);

if(!StackEmpty(S) && e=='(')

{

Pop(S,e);

p++;

}

else

state=0;

break;

}

case ']':{

GetTop(S,e);

if(!StackEmpty(S) && e=='[')

{

Pop(S,e);

p++;

}

else

state=0;

break;

}

case '}':{

GetTop(S,e);

if(!StackEmpty(S) && e=='{')

{

Pop(S,e);

p++;

}

else

state=0;

break;

}

if(StackEmpty(S) && state)

printf("输入的括��L��W�合!");

else

printf("输入的括号不�W�合!");

}

/*void check()

{ // 对于输入的�Q意一个字�W�串�Q�检验括��h��否配�?/SPAN>

Sqstack s;

SElemType ch[80],*p,e;

if(InitStack(s)) // 初始化栈成功

{

printf("误��入表辑ּ�\n");

gets(ch);

p=ch;

while(*p) // 没到串尾

switch(*p)

{

case '(':

case '[':Push(s,*p++);

break; // 左括号入栈，�?/SPAN>p++

case ')':

case ']':if(!StackEmpty(s)) // 栈不�I?/SPAN>

{

Pop(s,e); // 弹出栈顶元素

if(*p==')'&&e!='('||*p==']'&&e!='[') // 弹出的栈��元素与*p不配�?/SPAN>

{

printf("左右括号不配�?/SPAN>\n");

exit(ERROR);

}

else

{

p++;

break; // 跛_��switch语句

}

else // 栈空

{

printf("�~�Z��左括�?/SPAN>\n");

exit(ERROR);

}

default: p++; // 其它字符不处理，指针向后�U?/SPAN>

}

if(StackEmpty(s)) // 字符串结束时栈空

printf("括号匚w��\n");

else

printf("�~�Z��x��?/SPAN>\n");

}

}*/

void main()

{

//char a[]={[(]])]};

matching();

//check();

}

无情�?/a> 2005-10-14 00:05 发表评论

双向循环链表的实�?�Q�语�a�)

Tue, 11 Oct 2005 15:10:00 GMT

// �U�性表的双向链表存储结�?BR> typedef struct DuLNode
{
   ElemType data;
   DuLNode *prior,*next;
}DuLNode,*DuLinkList;

双链循环�U�性表(存储�l�构由c2-4.h定义)的基本操�?14�?
Status InitList(DuLinkList &L)
{ // 产生�I�的双向循环链表L
   L=(DuLinkList)malloc(sizeof(DuLNode));
   if(L)
   {
     L->next=L->prior=L;
     return OK;
   }
   else
     return OVERFLOW;
}

Status DestroyList(DuLinkList &L)
{ // 操作�l�果�Q�销毁双向��@环链表L
   DuLinkList q,p=L->next; // p指向�W�一个结�?BR>   while(p!=L) // p没到表头
   {
     q=p->next;
     free(p);
     p=q;
   }
   free(L);
   L=NULL;
   return OK;
}

Status ClearList(DuLinkList L) // 不改变L
{ // 初始条�g�Q�L已存在。操作结果：��L重置为空�?BR>   DuLinkList q,p=L->next; // p指向�W�一个结�?BR>   while(p!=L) // p没到表头
   {
     q=p->next;
     free(p);
     p=q;
   }
   L->next=L->prior=L; // 头结点的两个指针域均指向自��n
   return OK;
}

Status ListEmpty(DuLinkList L)
{ // 初始条�g�Q�线性表L已存在。操作结果：若L为空表，则返回TRUE�Q�否则返回FALSE
   if(L->next==L&&L->prior==L)
     return TRUE;
   else
     return FALSE;
}

int ListLength(DuLinkList L)
{ // 初始条�g�Q�L已存在。操作结果：�q�回L中数据元素个�?BR>   int i=0;
   DuLinkList p=L->next; // p指向�W�一个结�?BR>   while(p!=L) // p没到表头
   {
     i++;
     p=p->next;
   }
   return i;
}

Status GetElem(DuLinkList L,int i,ElemType &e)
{ // 当第i个元素存在时,其��D��l�e�q�返回OK,否则�q�回ERROR
   int j=1; // j��数器
   DuLinkList p=L->next; // p指向�W�一个结�?BR>   while(p!=L&&j   {
     p=p->next;
     j++;
   }
   if(p==L||j>i) // �W�i个元素不存在
     return ERROR;
   e=p->data; // 取第i个元�?BR>   return OK;
}

int LocateElem(DuLinkList L,ElemType e,Status(*compare)(ElemType,ElemType))
{ // 初始条�g�Q�L已存在，compare()是数据元素判定函�?BR>   // 操作�l�果�Q�返回L中第1个与e满��关系compare()的数据元素的位序�?BR>   //           若这��L��数据元素不存在，则返回��gؓ0
   int i=0;
   DuLinkList p=L->next; // p指向�W?个元�?BR>   while(p!=L)
   {
     i++;
     if(compare(p->data,e)) // 扑ֈ��q�样的数据元�?BR>       return i;
     p=p->next;
   }
   return 0;
}

Status PriorElem(DuLinkList L,ElemType cur_e,ElemType &pre_e)
{ // 操作�l�果�Q�若cur_e是L的数据元素，且不是第一个，则用pre_e�q�回它的前驱�Q?BR>   //           前驱�Q�否则操作失败，pre_e无定�?BR>   DuLinkList p=L->next->next; // p指向�W?个元�?BR>   while(p!=L) // p没到表头
   {
     if(p->data==cur_e)
     {
       pre_e=p->prior->data;
       return TRUE;
     }
     p=p->next;
   }
   return FALSE;
}

Status NextElem(DuLinkList L,ElemType cur_e,ElemType &next_e)
{ // 操作�l�果�Q�若cur_e是L的数据元素，且不是最后一个，则用next_e�q�回它的后��Q?BR>   //           否则操作��p�|�Q�next_e无定�?BR>   DuLinkList p=L->next->next; // p指向�W?个元�?BR>   while(p!=L) // p没到表头
   {
     if(p->prior->data==cur_e)
     {
       next_e=p->data;
       return TRUE;
     }
     p=p->next;
   }
   return FALSE;
}

DuLinkList GetElemP(DuLinkList L,int i) // 另加
{ // 在双向链表L中返回第i个元素的位置指针(��法2.18�?.19要调用的函数)
   int j;
   DuLinkList p=L;
   for(j=1;j<=i;j++)
     p=p->next;
   return p;
}

Status ListInsert(DuLinkList L,int i,ElemType e) // 改进��法2.18
{ // 在带头结点的双链循环�U�性表L中第i个位�|�之前插入元素e�Q�i的合法��gؓ1≤i≤表�?1
   DuLinkList p,s;
   if(i<1||i>ListLength(L)+1) // i��g��合法
     return ERROR;
   p=GetElemP(L,i-1); // 在L中确定第i-1个元素的位置指针p
   if(!p) // p=NULL,即第i-1个元素不存在
     return ERROR;
   s=(DuLinkList)malloc(sizeof(DuLNode));
   if(!s)
     return OVERFLOW;
   s->data=e; // 在第i-1个元素之后插�?BR>   s->prior=p;
   s->next=p->next;
   p->next->prior=s;
   p->next=s;
   return OK;
}

Status ListDelete(DuLinkList L,int i,ElemType &e) // ��法2.19
{ // 删除带头�l�点的双铑��@环线性表L的第i个元�?i的合法��gؓ1≤i≤表�?1
   DuLinkList p;
   if(i<1||i>ListLength(L)) // i��g��合法
     return ERROR;
   p=GetElemP(L,i); // 在L中确定第i个元素的位置指针p
   if(!p) // p=NULL,即第i个元素不存在
     return ERROR;
   e=p->data;
   p->prior->next=p->next;
   p->next->prior=p->prior;
   free(p);
   return OK;
}

void ListTraverse(DuLinkList L,void(*visit)(ElemType))
{ // 由双铑��@环线性表L的头�l�点出发,正序�Ҏ��个数据元素调用函数visit()
   DuLinkList p=L->next; // p指向头结�?BR>   while(p!=L)
   {
     visit(p->data);
     p=p->next;
   }
   printf("\n");
}

void ListTraverseBack(DuLinkList L,void(*visit)(ElemType))
{ // 由双铑��@环线性表L的头�l�点出发,逆序�Ҏ��个数据元素调用函数visit()。另�?BR>   DuLinkList p=L->prior; // p指向��?BR>   while(p!=L)
   {
     visit(p->data);
     p=p->prior;
   }
   printf("\n");
}

无情�?/a> 2005-10-11 23:10 发表评论

Tue, 11 Oct 2005 14:48:00 GMT

struct Lnode // 定义链表�c�d��
{
ElemType data;
struct Lnode *next;
};
typedef struct Lnode *LinkList;

int InitList(LinkList &L) //初始化一个链�?BR> {
    L=(LinkList)malloc(sizeof(Lnode));
    if(!L)
     exit(OVERFLOW);
     L->next=NULL;
     return OK;
}

int DestroyList(LinkList &L) //销毁链�?BR> {
    LinkList q;
    while(L)
    {
      q=L->next;
      free(L);
      L=q;
    }
    return OK;
}

int ClearList(LinkList L) //清零操作
{
    LinkList p,q;
    q=L->next;
    while(q)
    {
      p=q->next;
      free(q);
      q=p;
    }
    L->next=NULL;
    return OK;
}

int ListEmpty(LinkList L) //判空操作
{
    if(L->next==NULL)
    return TRUE;
    else
    return FALSE;
}

int ListLength(LinkList L) //计算链表的长�?BR> {
    LinkList p;
    int i=0;
    p=L->next;
    while(p)
    {
      ++i;
      p=p->next;
    }
    return i;
}

int GetElem(LinkList L,int i,ElemType e) //得到�W�i个元素的数据�?BR> {
    LinkList p;
    int j=0;
    p=L->next;
    while(p && j    {
      p=p->next;
      ++j;
    }
    if(j>i || !p)
    return ERROR;
    else
    e=p->data;
    return OK;
}

int LocateElem(LinkList L,ElemType e,int (*compare)(ElemType,ElemType))
{                       //扑ֈ��W�一个对于E满��函数的数据元素的位置
    LinkList p;
    int i=0;
    p=L->next;
    while(p)
    {
      ++i;
      if(compare(p->data,e))
      return i;
      p=p->next;
    }
    return 0;
}

int InsertList(LinkList L,int i,ElemType e) //在第i个数据元素上插入一个元�?BR> {
    LinkList p,s;
    int j=0;
    p=L;
    while(p && j    {
      p=p->next;
      ++j;
    }
    if(!p || j>i)
    return ERROR;
    s=(LinkList)malloc(sizeof(Lnode));
    s->data=e;
    s->next=p->next;
    p->next=s;
    return OK;
}

int DeleteList(LinkList &L,int i,ElemType e) //删除�W�i个元�?BR> {
    LinkList p,q;
    int j;
    j=0;
    p=L;
    while(p->next && j    {
     p=p->next;
     ++j;
    }
    if(!p->next || j>i)
    return ERROR;
    q=p->next;
    p->next=q->next;
    e=q->data;
    free(q);
    return OK;
}

int ListTraverse(LinkList L,int (*vi)(ElemType))
//�Ҏ��有链表中的元素进行函数vi操作
{
    LinkList p;
    p=L->next;
    while(p)
    {
      vi(p->data);
      p=p->next;
    }
    return OK;
}

void MergeList(LinkList La,LinkList Lb,LinkList &Lc)
{                              //合�ƈ二个非递减的La和Lb得到一个非递减的Lc
    LinkList pa,pb,pc;
    pa=La->next;
    pb=Lb->next;
    Lc=pc=La;
    while(pa && pb)
    {
      if(pa->data <= pb->data)
      {
        pc->next=pa;
pc=pa;
pa=pa->next;
      }
      else{
        pc->next=pb;
pc=pb;
pb=pb->next;
      }
    }
    pc->next=pa?pa:pb;
    free(Lb);
Lb=NULL;
}

无情�?/a> 2005-10-11 22:48 发表评论

�U�性表的顺序表�C?C语言)

Mon, 10 Oct 2005 16:59:00 GMT

�U�性表的顺序表�C�：

#define LIST_INIT_SIZE 100 定义一个线性表�c�d��

#define LISTINCREMENT 10

typedef struct

{

ElemType *elem; 基址

int length; 元素的长�?/SPAN>

int listsize;当前的存储容�?/SPAN>

}Sqlist;

void InitList_Sq(Sqlist &L) 初始化操�?/SPAN>

{

L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));

if(!L.elem)

return overflow;

L.length=0;

L.listsize=LIST_INIT_SIZE;

return ok;

}

void DestroyList_Sq(Sqlist &L) 销毁线性表

{

free(L.elem);

L.elem=NULL;

L.length=0;

L.listsize=0;

return ok;

}

void ClearList(Sqlist L) 清零操作

{

L.length=0;

return ok;

}

void ListEmpty(Sqlist L) 判空操作

{

if(L.length=0)

return True;

else

return False;

}

int ListLength(Sqlist L) 输出表的长度�Q�数据元素个�?/SPAN>

{

return L.length;

}

void GetElem(Sqlist &L,int i,ElemType &e) 得到�W?/SPAN>I 个元素的数据元素的�?/SPAN>

{

if(i<1 || i>L.length)

return error;

e=*(L.elem+i-1);

return ok;

}

int LocateElem(Sqlist &L,ElemType e,void (*compare)(ElemType,ElemType)) 查找�?/SPAN>E相等的元素的位置

{

ElemType *p;

i=1;

while(i<=L.length && !compare(*p++,e))

++i;

if(i<=L.length)

return i;

else

return 0;

}

void PriorElem(Sqlist L,ElemType cur_e,ElemType pre_e) 得到�l�出的数的前一个元素�?/SPAN>

{

int i=2;

ElemType *p;

p=L.elem+1;

while(i<=L.length && !(*p++==cur_e))

++i;

if(i>L.length)

return INFEASIBLE;

else

{

pre_e=*--p;

return OK;

}

void NextElem(Sqlist L,ElemType pre_e,ElemType cur_e) 得到后一个元素的�?/SPAN>

{

int i=1;

ElemType *p

p=L.elem;

while(i

++i;

if(i>=L.length)

return INFEASIBLE;

else

{

cur_e=*++p;

return OK;

}

void InsertElem(Sqlist &L,int i,ElemType e) 在第I个元素中插入一个��gؓE的元�?/SPAN>

{

if(i<1 || i>=length+1)

return ERROR;

if(L.length>=L.listsize)

{

if(!newbase=(ElemType *)realloc(L.elem,(L.listsize+LISTINCREMENT)

*sizeof(ElemType))))

return OVERFLOW;

L.elem=newbase;

L.listsize+=LISTINCREMENT;

}

p=L.elem+L.length-1;

q=L.elem+i-1;

for(p;p>=q;--p)

*(p+1)=*p;

*q=e;

++L.length;

return ok;

}

void DeleteElem(Sqlist &L,int i,ElemType e) 删除�W?/SPAN>I个元�?/SPAN>

{

if(i<1 || i>=L.length)

return FALSE;

p=L.elem+i-1;

q=L.elem+L.length-1;

e=*p;

for(p;p<=q;++p)

*p=*(p+1);

--L.length;

return OK;

}

void ListTraverse(Sqlist &L,void (*vi)(ElemType)) 对线性表�q�行VI的操�?/SPAN>

{

int i;

ElemType *p;

p=L.elem;

for(i=1;i<=L.length;++i)

vi(*p++);

return OK;

}

以上是线性表的一些常用的原操�?

例：

1�Q�求一个新的集�?/SPAN>A=A U B�?/SPAN>

void union(Sqlist &LA,Sqlist LB)

{

la_len=LA.length;

lb_len=LB.length;

for(i=1;i<=lb_len;++i)

{

GetElem(LB,i,e);

if(!Locate(LA,e,compare()))

InsertList(LA,++la_len,e);

}

return OK;

}

2.��二个非递减�?/SPAN>LA表和LB表归�q��ؓ一个新的非递减�?/SPAN>LC�?/SPAN>

void MergeList(Sqlist LA,Sqlist LB,Sqlist &LC)

{

i=j=1;k=0;

InitList(LC);

while(i<=LA.length && j<=LB.length)

{

GetElem(LA,i,ai);

GetElem(LB,j,bj);

if(ai<=bj)

{

InsertList(LC,++k,ai);

++i;

}

else

{

InsertList(LC,++k,bj);

++j;

}

while(i<=LA.length)

{

GetElem(LA,i,ai);

InsertList(LC,++k,ai);

++i;

}

while(j<=LB.length)

{

GetElem(LB,i,bj);

InsertList(LC,++k,bj);

++j;

}

return OK;

}

无情�?/a> 2005-10-11 00:59 发表评论