[color="ffffff"]串 基本运算： StrAssign(&t,chars) 初始条件：chars是字符串常量。 操作结果：生成一个其值等于chars的串t。 StrCopy(&t,s) 初始条件：串s存在。 操作结果：由串s复制得串t。 StrEpty(s) 初始条件：串s存在。 操作结果：若s为空串，则返回TRUE，否则返回FALSE。 StrCompare(s,t) 初始条件：串s和串t存在。 操作结果：若s>t，则返回值>0；若s=t，则返回值=0；若s

[color=#DC143C]栈和队列

队列的链式存储
定义：
typedef struct node
{elemtype data;
struct node *next;}  queueqtr;
typedef struct
{queueptr *front,*rear;} linkedquetp;

初始化算法：
void inilinkedque(linkedquetp *s)
{s->front=(queueptr *)malloc(sizeof(queueptr));
s->rear=s->front;
s->front->next=Null';
}
入队列算法：
void enlinkedque(linkedquetp *s,elemtype x)
{queueptr *p;
p=(queueptr *)malloc(sizeof(queueptr));
p->data=x;
p->next=Null;
s->rear->next=p;
s->rear=p;
}
出队列算法：
elemtype dllinkedque(linkedquetp *s)
{queueptr *p;
if(s->front==s->rear)
   return(Null);
else
   {p=s->front;
    s->front=s->front->next;
    free(p);
    return(s->front->data);}
}

循环队列
入队列算法：
int encycque(sequeuetp *s,elemtype x)
{if((s->rear+1)%MAXSIZE==front)
   return(false);
else
   {s->rear=(s->rear+1)%MAXSIZE;
    s->queue[s->rear]=x;
    return(true);}  
}

出队列算法：
elemtype dlcycque(sequeuetp *s)
{if(s->front==s->rear)
   return(Null);
else
  {s->front=(s->front+1)%MAXSIZE;
  return(s->queue[s->front]);
  }
}

顺序队列
定义：
typedef struct
{elemtype queue[MAXSIZE];
int front,rear;} sequeuetp;
初始化算法：
void iniqueue(sequeue *s)
{s->front=-1;
s->rear=-1;}
入队列算法：
int enqueue(sequeuetp *s,elemtype x)
{if(s->rear==MAXSIZE-1)
return(false);
else
  {s->queue[++s->rear]=x;
   return(true);
  }
}
出队列算法：
elemtype dlqueue(sequeuetp *s)
{if(s->front==s->rear)
   return(Null);
else
   {return(s->queue[++s->front];)}
}

队列基本运算：
(1)初始化队列：iniqueue(Q)
设置一个空的队列Q。
(2)入队列：enqueue(Q,X)
Q为已知队列，在队尾加入数据元素X，使X成为新的队尾元素。
(3)出队列：dlqueue(Q)
Q为已知队列，若Q非空，则删除队头元素，并返回该队头元素，再设置其后继元素为新的队头元素；否则返回空元素值Null
(4)取队头元素：gethead(Q)
Q为已知队列，若Q非空，则返回队头元素；否则返回空元素值Null
(5)判队列空；empty(Q)
若队列Q为空，则返回true，否则返回false

单链栈
定义：
typedef struct node
{elemtype data;
struct node *next;} linkstktp;
linkstktp *top;
进栈算法：
void push(linkstktp *top,elemtype x)
{linkstktp *p;
p=(linkstktp *)malloc(sizeof(linkstktp));
p->data=x;
p->next=top->next;
top->next=p;}
出栈算法：
elemtype pop(linkstktp *top)
{linkstktp *p;
elemtype x;
p=top->next;
if(p=Null)
   {printf("栈已空");
    return(Null);}
else
   {top->next=p->next;
   x=p->data;
   free(p);
   return(x);
   }
}

顺序栈两栈共享空间： 定义： typedef struct {elemtype stack[m]; int top[2];} dustktp; 初始化算法： void inistack(dustktp *s) {s->top[0]=-1; s->top[1]=m; } 进栈算法： int push(dustktp *s,int i,elemtype x) {if(s->top[0]==s->top[1]-1) {printf("栈已满"); return(False);} if(i!=0||i!=1) {printf("栈参数出错"); return(False);} if(i==0) s->stack[++s->top[0]]=x; else s->stack[++s->top[1]]=x; return(True); } 出栈算法： elemtype pop(dustktp *s,int i) {if(i!=0||i!=1) {printf("栈参数出错"); return(false);} if(i==0) {if(s->top[0]<=-1) {printf("0号栈已空"); return(Null);} else {s->top[0]--; return(s->stack[s->top[0]+1]);} } else if(s->top[1]==m) {printf("1号栈已空"); return(Null);} else {s->top[1]++; return(s->stack[s->top[1]-1]);} }

顺序栈 定义： #define MAXNUM 100 typedef struct {elemtype stack[MAXNUM]; int top;} sqstktp; sqstktp *s; 初始化栈算法： void inistack(sqstktp *s) {s->top=1;} 进栈算法： #define ture 1 #define false 0 int push(sqstktp *s,elemtype x) {if(s->top>=MAXNUM-1) return(false); else {s->stack[++s->top]=x; return(true); } } 出栈算法： elemtype pop(sqstktp *s) {if(s->top<0) return(Null); else {s->top--; return(s->stack[s->top+1]);} } 取栈顶元素算法： elemtype gettop(sqstktp *s) {if(s->top<0) return(Null); else return(s->stack[s->top];) } 判栈空算法： int empty(sqstktp *s) /*int? boolean?*/ {if(s->top<0) return(true); else return(false); }

栈基本运算：
(1)初始化栈：inistack(s)
将栈s置成空栈，建立起栈顶指针。
(2)进栈：push(s,x)
s为已知栈，若s未满，则将x插入栈顶，并使栈顶指针指向x，函数返回true；否则出错，函数返回false值。
(3)出栈：pop(s)
s为已知栈，若s非空，则函数返回栈顶元素，且从栈中删去栈顶元素；否则函数返回空元素值Null。
(4)取栈顶元素：gettop(s)
s为已知栈，若s非空，则函数返回栈顶元素；否则函数返回空元素值Null。
(5)判栈空：empty(s)
若s为空栈，则函数true值，否则返回false值。

再起个帖子吧。。。也给个rar我下来看看。。。算是给我做个辅导

:)
我以前写过C++版发到这里

线性表，模板：

双向循环链表 定义： typedef struct dupnode {elemtp data; struct dupnode *next,*prior;} dulinklist; dulinklist *head; 插入:有头结点 void insdulist(head,i,x)/*在双向循环链表head中的第i个结点之前插入值为x的新结点*/ dulinklist *head; int i; elemtp x; {dulinklist *p,*s; int j; p=head; j=0; while((p->next!=head)&&(jnext; j++;} if((i>0)&&(j=i-1)) {s=malloc(sizeof(dulinklist)); s->data=x; s->next=p->next; s->prior=p; p->next=s; p->next->prior=s; } else printf("error\n"); } 删除： void deledulist(head,i) dulinklist *head; int i; {dulinklist *p; int j; p=head; j=0; while((p->next!=head)&&(jnext; j++;} if((i>0)&&(j==i)) {p->prior->next=p->next; p->next->prior=p->prior; free(p);} else printf("error\n"); }

循环链表：
只要将单链表算法中出现的Null改为head