1-线性结构

1.线性表

“ 线性表(Linear List)”：由同类型数据元素构成有序序列的线性结构
 表中元素个数称为线性表的长度
 线性表没有元素时，称为空表
 表起始位置称表头，表结束位置称表尾

1.1.线性表的顺序存储实现

typedef struct

{
ElementType Data[MAXSIZE];
int Last;
} List;
List L, *PtrL;

1. 初始化（建立空的顺序表）

List *MakeEmpty( )
{ List *PtrL;
PtrL = (List *)malloc( sizeof(List) );
PtrL->Last = -1;
return PtrL;
}

2. 查找
int Find( ElementType X, List *PtrL )
{ int i = 0;
while( i <= PtrL->Last && PtrL->Data[i]!= X )
i++;
if (i > PtrL->Last) return -1; /* 如果没找到， 返回-1 */
else return i; /* 找到后返回的是存储位置 */
}

3.插入操作实现

void Insert( ElementType X, int i, List *PtrL )
{ int j;
if ( PtrL->Last == MAXSIZE-1 ){ /* 表空间已满，不能插入*/
printf(＂表满＂);
return;
}
if ( i < 1 || i > PtrL->Last+2) { /*检查插入位置的合法性*/
printf(＂位置不合法＂);
return;
}
for ( j = PtrL->Last; j >= i-1; j-- )
PtrL->Data[j+1] = PtrL->Data[j]; /*将 ai～ an倒序向后移动*/
PtrL->Data[i-1] = X; /*新元素插入*/
PtrL->Last++; /*Last仍指向最后元素*/
return;
}

4. 删除操作实现

void Delete( int i, List *PtrL )
{ int j;
if( i < 1 || i > PtrL->Last+1 ) { /*检查空表及删除位置的合法性*/
printf (“不存在第%d个元素”, i );
return ;
}
for ( j = i; j <= PtrL->Last; j++ )
PtrL->Data[j-1] = PtrL->Data[j]; /*将 ai+1～ an顺序向前移动*/
PtrL->Last--; /*Last仍指向最后元素*/
return;
}

1.2.线性表的链式存储实现

typedef struct Node{
ElementType Data;
struct Node *Next;
} List;
List L, *PtrL;

1.求表长

int Length ( List *PtrL )
{ List *p = PtrL; /* p指向表的第一个结点*/
int j = 0;
while ( p ) {
p = p->Next;
j++; /* 当前p指向的是第 j 个结点*/
}
return j;
}

2. 查找

（ 1）按序号查找: FindKth

List *FindKth( int K, List *PtrL )
{ List *p = PtrL;
int i = 1;
while (p !=NULL && i < K ){
p = p->Next;
i++;
}
if ( i == K ) return p;
/* 找到第K个，返回指针 */
else return NULL;
/* 否则返回空 */
}

（ 2）按值查找: Find

List *Find( ElementType X, List
*PtrL )
{
List *p = PtrL;
while ( p!=NULL && p->Data != X )
p = p->Next;
return p;
}

3. 插入操作实现

List *Insert( ElementType X, int i, List *PtrL )
{ List *p, *s;
if ( i == 1 ) { /* 新结点插入在表头 */
s = (List *)malloc(sizeof(List)); /*申请、填装结点*/
s->Data = X;
s->Next = PtrL;
return s; /*返回新表头指针*/
}
p = FindKth( i-1, PtrL ); /* 查找第i-1个结点 */
if ( p == NULL ) { /* 第i-1个不存在，不能插入 */
printf(＂参数i错＂);
return NULL;
}else {
s = (List *)malloc(sizeof(List)); /*申请、填装结点*/
s->Data = X;
s->Next = p->Next; /*新结点插入在第i-1个结点的后面*/
p->Next = s;
return PtrL;
}
}

4. 删除

List *Delete( int i, List *PtrL )
{ List *p, *s;
if ( i == 1 ) { /* 若要删除的是表的第一个结点 */
s = PtrL; /*s指向第1个结点*/
if (PtrL!=NULL) PtrL = PtrL->Next; /*从链表中删除*/
else return NULL;
free(s); /*释放被删除结点 */
return PtrL;
}
p = FindKth( i-1, PtrL ); /*查找第i-1个结点*/
if ( p == NULL ) {
printf(“第%d个结点不存在”, i-1); return NULL;
} else if ( p->Next == NULL ){
printf(“第%d个结点不存在”, i); return NULL;
} else {
s = p->Next; /*s指向第i个结点*/
p->Next = s->Next; /*从链表中删除*/
free(s); /*释放被删除结点 */
return PtrL;
}
}

 

2.堆栈

2.1.栈的顺序存储实现

#define MaxSize <储存数据元素的最大个数>
typedef struct {
ElementType Data[MaxSize];
int Top;
} Stack;

1.入栈

 void Push( Stack *PtrS, ElementType item )
{
if ( PtrS->Top == MaxSize-1 ) {
printf(“堆栈满”); return;
}else {
PtrS->Data[++(PtrS->Top)] = item;
return;
}
}

2.出栈

ElementType Pop( Stack *PtrS )
{
if ( PtrS->Top == -1 ) {
printf(“堆栈空”);
return ERROR; /* ERROR是ElementType的特殊值，标志错误
*/
} else
return ( PtrS->Data[(PtrS->Top)--] );
}

2.2.栈的链式存储实现

typedef struct Node

{
ElementType Data;
struct Node *Next;

\*不能是 struct Node Next; 不允许结构的类型作为其成员的类型，但允许结构的指针作为其成员的类型*/
} LinkStack;
LinkStack *Top;

c代码

LinkStack *CreateStack()
{ /* 构建一个堆栈的头结点，返回指针 */
LinkStack *S;
S =(LinkStack *)malloc(sizeof(struct Node));
S->Next = NULL;
return S;
}
int IsEmpty( LinkStack *S )
{ /*判断堆栈S是否为空， 若为空函数返回整数1，
否则返回0 */
return ( S->Next == NULL );
}

 

void Push( ElementType item, LinkStack *S )
{ /* 将元素item压入堆栈S */
struct Node *TmpCell;
TmpCell=(LinkStack *)malloc(sizeof(struct Node));
TmpCell->Element = item;
TmpCell->Next = S->Next;
S->Next = TmpCell;
}

 

ElementType Pop( LinkStack *S )
{ /* 删除并返回堆栈S的栈顶元素 */
struct Node *FirstCell;
ElementType TopElem;
if( IsEmpty( S ) ) {
printf(“堆栈空”); return NULL;
} else {
FirstCell = S->Next;
S->Next = FirstCell->Next;
TopElem = FirstCell ->Element;
free(FirstCell);
return TopElem;
}
}

3.队列

3.1.队列的线性存储实现

#define MaxSize <储存数据元素的最大个数>
struct QNode {
ElementType Data[ MaxSize ];
int rear;
int front;
};
typedef struct QNode *Queue;

(1)入队列

void AddQ( Queue PtrQ, ElementType item)
{
if ( (PtrQ->rear+1) % MaxSize == PtrQ->front ) {
printf(“队列满”);
return;
}
PtrQ->rear = (PtrQ->rear+1)% MaxSize;
PtrQ->Data[PtrQ->rear] = item;
}

(2)出队列

ElementType DeleteQ ( Queue PtrQ )
{
if ( PtrQ->front == PtrQ->rear ) {
printf(“队列空”);
return ERROR;
} else {
PtrQ->front = (PtrQ->front+1)% MaxSize;
return PtrQ->Data[PtrQ->front];
}
}

3.2.队列的链式存储实现

struct Node{
ElementType Data;
struct Node *Next;
};
struct QNode{ /* 链队列结构 */
struct Node *rear; /* 指向队尾结点 */
struct Node *front; /* 指向队头结点 */
};
typedef struct QNode *Queue;
Queue PtrQ;

不带头结点的链式队列出队操作的一个示例：

ElementType DeleteQ ( Queue PtrQ )
{ struct Node *FrontCell;
ElementType FrontElem;
if ( PtrQ->front == NULL) {
printf(“队列空”); return ERROR;
}
FrontCell = PtrQ->front;
if ( PtrQ->front == PtrQ->rear) /* 若队列只有一个元素 */
PtrQ->front = PtrQ->rear = NULL; /* 删除后队列置为空 */
else
PtrQ->front = PtrQ->front->Next;
FrontElem = FrontCell->Data;
free( FrontCell ); /* 释放被删除结点空间 */
return FrontElem;
}