期末了，赶紧复习一波，手打一份书上的代码以便随时查阅

第二章：

//顺序表存储结构

#define MAXSIZE 100

typedef struct

{

Elemtype *elemt;

int length;

}Sqlist;

Status InitList(Sqlist &L)

{

L.elemt=new Elemtype[MAXSIZE];

if(!L.elemt) exit(OVERFLOW);

// L.length=MAXQSIZE;

L.length=0;

return OK;

}

Status GetElemt(Sqlist &L,int i,Elemtype &e)

{

if(i<1||i>L.length) return ERROR;

// [错了]e=L->elemt[i];

e=L->elemt[i-1];

return OK;

}

Status LocateElem(Sqlist &L,Elemtype e)

{

for(i=0;i

{

if(L.elemt[i]==e) return i+1;

}

return 0;

}

//Status SearchElemt(Sqlist &L,int &j,Elemtype e)

//{

// if(j<1||j>L.length) return ERROR;

// for(int i=0;i

// if(L.elemt[i]==e)

// {

// j=i+1;

// return OK;

// }

// return ERROR;

//}

Status ListInsert(Sqlist &L ,int i,Elemtype e)

{

if(i<1||i>L.length) return ERROR;//忘记了

if(L.length==MAXSIZE)return ERROR;//又忘记了

for(j=L.length-1;j>=i-1;--j)

{

L.elemt[j+1]=L.elemt[j];

}

L.elemt[i-1]=e;

L.length++;

return OK;

}

Status ListDelete(Sqlist &L,int i)

{

if(i<1||i>L.length) return ERROR;//忘了

// for(j=i-1;j

// {

// L.elemt[j]=L.elemt[j+1];

// }

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

L.elemt[j-1]=L.elemt[j];

L.length--;

return OK;

}

//单链表的存储

typedef struct LNode

{

ElemType data;

struct LNode * next;

}LNode,*Linklist;

Status InitLink(Linklist &L)

{

L=new LNode;

// if(!L) exit(OVERFLOW);

L->next=NULL;

return OK;

}

//单链表的取值

Status GetElemt(Linklist &L,int i,Elemtype &e)

{

p=L->next;

j=1;

while(p&&j

{

p=p->next;++j;

}

if(!p||j>i) return ERROR;

e=p->data;

return OK;

}

//单链表的按值查找

LNode LocateElem(Linklist &L,Elemtype e)

{

p=L->next;j=1;

// while(p->data!=e)

// {

// p=p->next;

// }

// return p;

while(p&&p->data!=e)

p=p->next;

return p;

}

//单链表的插入

Status ListInsert(Linklist &L,int i,Elemtype e)

{

// p=L->next;j=1;

p=L;j=0;

while(p&&j

{

p=p->next;++j;

}

if(!p||j>i-1) return ERROR;

s=new LNode;

s->data=e;

s->next=p->next;

p->next=s;

return OK;

}

//删除

Status DeleteElemt(Linklist &L,int i)

{

p=L;j=0;

while(p->next&&j

{

p=p->next;++j;

}

if(!p->next||j>i-1) return ERROR;

s=p->next;

p->next=s->next;

delete s;

return OK;

}

//单链表的创建--前插

void CreateList_H(Linklist &L,int n)

{

L=new LNode;

L->next=NULL;

for(i=-0;i

{

p=new LNode;

cin>>p->data;

p->next=L->next;

L->next=p;

}

}

//单链表的创建——尾插

void CreateList_T(Linklist &L,int n)

{

L=new LNode;

L->next=NULL;

r=L;

for(i=0;i

{

p=new LNode;

cin>>p->data;

p->next=NULL;

r->next=p;

r=p;

}

}

//双向链表

typedef struct DuLNode

{

Elemtype data;

struct DuLNode *ptr;

struct DuLNode *next;

}DulNode,*DuLinkList;

//双向链表的插入

Status ListInsert_Dul(DuLinkList &L，int i,Elemtype e)

{

// p=L;j=1;

// while(p&&j

// {

// p=p->next;++j;

// }

// if(!p||j>i-1) return ERROR;

//

// s=new DulNode;

// s->data=e;

// s->next=p->next;

// s->ptr=p->ptr;

// p->next->ptr=s;

// p->next=s;

if(!(p=GetElem_Dul(L,i)))

return ERROR;

s=new LNode;

s->data=e;

s->ptr=p->ptr;

s->next=p;

p->ptr->next=s;

p->ptr=s;

return OK;

}

//双向链表的删除

Status ListDelete_Dul(Linklist &L,int i)

{

if(!(p=GetElemt_Dul(L,i)))

return ERROR;

p->next->ptr=p->ptr;

p->ptr->next=p->next;

delete p;

return OK;

}

第三章：

#define MAXSIZE

typedef struct

{

SElemtTpye *base;

SElemtTpye *top;

int stacksize;

}SqStack ;

Status InitStack(SqStack &S)

{

S.base=new SElemtTpye[MAXSIZE];

// [危阻]if(!S.basa)return ERROR;

if(!S.base) exit(OVERFLOW);

S.top=S.base;

S.stacksize=MAXSIZE;

return OK;

}

Status Push(SqStack &S,SElemtTpye e)

{

if(S.top-S.base==S.stacksize) return ERROR;

*S.top=e;

S.top++;

// S.stacksize++;

return OK;

}

Status Pop(SqStack &S,SElemtTpye &e)

{

if(S.top==S.base) return ERROR;

S.top--;

e=*S.top;

// S.stacksize--;

return Ok;

}

SElemtTpye GetTop(SqStack &S)

{

if(S.top==S.base) return ERROR;

// S.top--;

// return *S.top;

return *(S.top-1);

}

//全媚

typedef struct StackNode

{

struct StackNode *next;

ElemtTpye data;

}StackNode,*LinkStack;

Status InitStack(LinkStack &S)

{

S=NULL;

return OK;

// S=new StackNode;

// if(!S) return ERROR;

// S.next=NULL;

// return OK;

}

Status Push(LinkStack &S,ElemtTpye e)

{

p=new StackNode;

if(!p) return ERROR;

p->data=e;

p->next=S;

S=p;

return OK;

}

Status Pop(LinkStack &S,ElemtTpye &e)

{

if(!S)return ERROR;

e=S.data;

p=S;

S=S->next;

delete p;//梨芝瞥慧阻

return OK;

}

ElemtTpye GetTop(LinkStack &S)

{

if(!S) return ERROR;

return S->data;

}

#define MAXQSIZE 100

typedef struct

{

QElemtype *base;

int front;

int rear;

}SqQueue;

Status InitQueue(SqQueue &Q)

{

Q.base=new QElemtype[MAXQSIZE];

if(!Q.base) exit(OVERFLOW);

Q.front=Q.rear=0;

return OK;

}

Status EnQueue(SqQueue &Q,Elemtype e)

{

if((Q.rear+1)%MAXQSIZE==Q.front) return ERROR;

Q.base[Q.rear]=e;

Q.rear=(Q.rear+1)%MAXQSIZE;

return OK;

}

Status DeQueue(SqQueue &Q,Elemtype &e)

{

if(Q.rear==Q.front) return ERROR;

e=Q.base[Q.front];

Q.front=(Q.front+1)%MAXQSIZE;

return OK;

}

Elemtype GetTop(SqQueue &Q)

{

if(Q.front==Q.base) return ERROR;

return Q.base[Q.front];

}

//全錦

typedef struct QNode

{

Elemtype data;

struct QNode *next;

}QNode,*QueuePtr;

typedef struct

{

QueuPtr front;

QueuePtr rear;

}*LinkQueue;

Status InitQueue(LinkQueue &Q)

{

Q.front=Q.rear=new QNode;

Q.front->next=NULL;

return OK;

}

Status EnQueue(LinkQueue &Q,Elemtype e)

{

p=new QNode;

p->data=e;

p->next=NULL;

Q.rear->next=p;

Q.rear=p;

return OK;

}

Status DeQueue(LinkQueue &Q,Elemtype &e)

{

if(Q.front==Q.rear)return ERROR;

p=Q.front->next;

e=p->data;

Q.front->next=p->next;

if(p==Q.rear) Q.rear=Q.front;

delete p;

return OK;

}