2012-1-31

第八章 数据结构

8.1 线性结构

8.8.1 线性表

顺序存储 n/2 (n-1)/2

链式存储 

typedef struct node{

int data;

struct node *link;

}NODE,*LinkList;

插入：

s->link = p->link

p->link = s

删除：

q = p->link

p->link = p->link->link;

free(q);

单链表的查找运算

LinkList Find_List(LinkList L, int k)

{

int i=1;

LinkList p=L->link;

while(p&&i<k){

p=p->link;i++;

}

if(p&&i==k)return p;

return NULL;

}

单链表的插入运算

int Insert_List(LinkList L,int k, int newelem)

{ LinkList p,s;

if(K==1)p=L;

else p=Find_List(L,k-1);

if(!p||!p->link)rerurn -1;

s=(NODE *)malloc(sizeof(NODE));

if(!s)return-1;

s->data = newelem;

s->link = p->link;p->link=s;

rerurn 0;

}

单链表的删除运算

int Delete_List(LinkList L, int k)

{

LinkList p,q;

if(K==1)p=L;

else p=Find_List(L,k-1);

if(!p||!p->link) return -1;

q=p->link;

p->link=q->link; free(q);

return 0;

}

双向链表

循环链表

静态链表

双向链表中插入和删除节点的操作

8.1.2 栈和队列

1.栈 LIFO

栈的基本运算

InitStack(S)

StackEmpty(S)

Push(x)

Pop(x)

Top(x)

栈的存储结构：

顺序存储

链式存储

栈的应用：表达式求值，括号匹配等

2.队列FIFO

InitQueue(Q)

Empty(Q)

EnQueue(Q,x);

DeQueue(Q);

FrontQue(Q);

#define MAXQSIZE 100

typedef struct(

int *base;

int front;

int rear;

}SqQueue;

int InitQueue(SqUueue *Q, int e)

{

Q->base=(int *)malloc(MAXQSIZE*sizeof(int));

if(!Q->base) rerurn -1;

Q->front=0;Q->rear=0;rerurn 0;

}

int EnQueue(SqQueue Q, int e)

{

if((Q->rear+1)%MAXSIZE == Q->front) rerurn -1;

Q->base[Q->rear]=e;

Q->rear=(Q->rear+1)%MAXQSIZE;

return 0;

}

int DeQueue(SqQueue *Q, int *e)

{

if(Q->rear==Q->front) return -1;

*e=Q->base[Q->front];

Q->front=(Q->front+1)%MAXQSIZE;

return 0;

}

队列的链式存储。

8.1.3 串

即字符串

串的定义：仅由字符构成的有限序列，是取值范围受限的线性表。一般记为S=‘abc....’

空串、空格串、子串、串相等、串比较。

StrAssign(s,t)

Concat(s,t)

StrLength(s)

StrCompare(s,t)

SubString(s,start,len)

2.串的存储结构

串的定长存储结构

串的链式存储

3.串的模式匹配

子串的定位操作通常称为串的模式匹配

1)朴素的模式匹配算法

布鲁特-福斯算法

以字符数组存储字符串，实现布鲁特-福斯算法

int Index(char S[], char T[], int pos)

{

int i,j,slen,jlen;

i=pos;j=0;

slen = strlen(S);tlen = strlen(T);

while(i<slen&&j<tlen)

{

if(S[i]==T[j]){i++;j++;}

else{

i=i-j+1;

j=0;

}

}

if(j>=tlen) return i-tlen;

return -1;

}

时间复杂度1/2(n+m) O(n+m)、1/2m(n-m+2) O(n*m)

2)改进的模式匹配算法

KMP算法。

void Get_next( char *p, int next[] )

{

int i;

int j;

int slen;

slen = strlen(p);

i=0;

next[0] = -1;

j = -1;

while( i < slen ){

if(j == -1 || p[i] == p[j] )

{

++i;

++j;

next[i] = j;

}

else

{

j = next[j];

}

}

}