数据结构基础（ZJU_C版）

一、线性结构

2.1 线性表

概念

线性表(Linear List)：由同类型数据元素构成有序序列的线性结构

• 表中元素个数称为线性表的长度
• 线性表没有元素时，称为空表
• 表起始位置称表头，表结束位置称表尾

线性表的顺序存储实现

• 利用数组的连续存储空间顺序存放线性表的各元素

定义

/*定义*/
typedef int Position;
typedef struct LNode *List;
struct LNode {
    ElementType Data[MAXSIZE];
    Position Last;
}；

初始化

/* 初始化 */
List MakeEmpty()
{
    List L;
 
    L = (List)malloc(sizeof(struct LNode));
    L->Last = -1;
 
    return L;
}

查找

/* 查找 */
#define ERROR -1
 
Position Find( List L, ElementType X )
{
    Position i = 0;
 
    while( i <= L->Last && L->Data[i]!= X )
        i++;
    if ( i > L->Last )  return ERROR; /* 如果没找到，返回错误信息 */
    else  return i;  /* 找到后返回的是存储位置 */
}

插入

/* 插入 */
bool Insert( List L, ElementType X, Position P ) 
{ /* 在L的指定位置P前插入一个新元素X */
    Position i;
 
    if ( L->Last == MAXSIZE-1) {
        /* 表空间已满，不能插入 */
        printf("表满"); 
        return false; 
    }  
    if ( P<0 || P>L->Last+1 ) { /* 检查插入位置的合法性 */
        printf("位置不合法");
        return false; 
    } 
    for( i=L->Last; i>=P; i-- )
        L->Data[i+1] = L->Data[i]; /* 将位置P及以后的元素顺序向后移动 */
    L->Data[P] = X;  /* 新元素插入 */
    L->Last++;       /* Last仍指向最后元素 */
    return true; 
} 

删除

/* 删除 */
bool Delete( List L, Position P )
{ /* 从L中删除指定位置P的元素 */
    Position i;
 
    if( P<0 || P>L->Last ) { /* 检查空表及删除位置的合法性 */
        printf("位置%d不存在元素", P ); 
        return false; 
    }
    for( i=P+1; i<=L->Last; i++ )
        L->Data[i-1] = L->Data[i]; /* 将位置P+1及以后的元素顺序向前移动 */
    L->Last--; /* Last仍指向最后元素 */
    return true;   
}

线性表的链式存储实现

• 不要求逻辑上相邻的两个元素物理上也相邻。
• 通过“链”建立起数据元素之间的逻辑关系。
• 插入、删除不需要移动数据元素，只需要修改“链”。

定义

typedef struct LNode *PtrToLNode;
struct LNode {
    ElementType Data;
    PtrToLNode Next;
};
typedef PtrToLNode Position;
typedef PtrToLNode List;

查找

/* 查找 */
#define ERROR NULL
 
Position Find( List L, ElementType X )
{
    Position p = L; /* p指向L的第1个结点 */
 
    while ( p && p->Data!=X )
        p = p->Next;
 
    /* 下列语句可以用 return p; 替换 */
    if ( p )
        return p;
    else
        return ERROR;
}

带头结点的插入

/* 带头结点的插入 */
bool Insert( List L, ElementType X, Position P )
{ /* 这里默认L有头结点 */
    Position tmp, pre;
 
    /* 查找P的前一个结点 */        
    for ( pre=L; pre&&pre->Next!=P; pre=pre->Next ) ;            
    if ( pre==NULL ) { /* P所指的结点不在L中 */
        printf("插入位置参数错误\n");
        return false;
    }
    else { /* 找到了P的前一个结点pre */
        /* 在P前插入新结点 */
        tmp = (Position)malloc(sizeof(struct LNode)); /* 申请、填装结点 */
        tmp->Data = X; 
        tmp->Next = P;
        pre->Next = tmp;
        return true;
    }
}

带头结点的删除

/* 带头结点的删除 */
bool Delete( List L, Position P )
{ /* 这里默认L有头结点 */
    Position tmp, pre;
 
    /* 查找P的前一个结点 */        
    for ( pre=L; pre&&pre->Next!=P; pre=pre->Next ) ;            
    if ( pre==NULL || P==NULL) { /* P所指的结点不在L中 */
        printf("删除位置参数错误\n");
        return false;
    }
    else { /* 找到了P的前一个结点pre */
        /* 将P位置的结点删除 */
        pre->Next = P->Next;
        free(P);
        return true;
    }
}

2.2堆栈

堆栈的抽象数据类型描述

堆栈（Stack）：具有一定操作约束的线性表，只在一端（栈顶，Top）做 插入、删除

• 插入数据：入栈（Push）
• 删除数据：出栈（Pop）
• 后入先出：Last In First Out（LIFO）

栈的顺序存储实现

• 栈的顺序存储结构通常由一个一维数组和一个记录栈顶元素位置的变量组成。

定义

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

入栈

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

出栈

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

堆栈的链式存储实现

• 栈的链式存储结构实际上就是一个单链表，叫做链栈。插入和删
  除操作只能在链栈的栈顶进行。

定义

typedef struct SNode *PtrToSNode;
struct SNode {
    ElementType Data;
    PtrToSNode Next;
};
typedef PtrToSNode Stack;
 
Stack CreateStack( ) 
{ /* 构建一个堆栈的头结点，返回该结点指针 */
    Stack S;
 
    S = (Stack)malloc(sizeof(struct SNode));
    S->Next = NULL;
    return S;
}

判断

bool IsEmpty ( Stack S )
{ /* 判断堆栈S是否为空，若是返回true；否则返回false */
    return ( S->Next == NULL );
}

bool IsFull( Stack S )
{ /* 判断堆栈S是否为满*/   
	return (S->Top == S->MaxSize-1);
}

入栈

bool Push( Stack S, ElementType X )
{ /* 将元素X压入堆栈S */
    PtrToSNode TmpCell;
 
    TmpCell = (PtrToSNode)malloc(sizeof(struct SNode));
    TmpCell->Data = X;
    TmpCell->Next = S->Next;
    S->Next = TmpCell;
    return true;
}

出栈

ElementType Pop( Stack S )  
{ /* 删除并返回堆栈S的栈顶元素 */
    PtrToSNode FirstCell;
    ElementType TopElem;
 
    if( IsEmpty(S) ) {
        printf("堆栈空"); 
        return ERROR;
    }
    else {
        FirstCell = S->Next; 
        TopElem = FirstCell->Data;
        S->Next = FirstCell->Next;
        free(FirstCell);
        return TopElem;
    }
}

2.3 队列

队列的抽象数据类型描述

队列(Queue)：具有一定操作约束的线性表
插入和删除操作：只能在一端插入，而在另一端删除。

• 数据插入：入队列（AddQ）
• 数据删除：出队列（DeleteQ）
• 先来先服务
• 先进先出：FIFO

队列的顺序存储实现

定义

typedef int Position;
struct QNode {
    ElementType *Data;     /* 存储元素的数组 */
    Position Front, Rear;  /* 队列的头、尾指针 */
    int MaxSize;           /* 队列最大容量 */
};
typedef struct QNode *Queue;
 
Queue CreateQueue( int MaxSize )
{
    Queue Q = (Queue)malloc(sizeof(struct QNode));
    Q->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));
    Q->Front = Q->Rear = 0;
    Q->MaxSize = MaxSize;
    return Q;
}

入列

bool AddQ( Queue Q, ElementType X )
{
    if ( IsFull(Q) ) {
        printf("队列满");
        return false;
    }
    else {
        Q->Rear = (Q->Rear+1)%Q->MaxSize;
        Q->Data[Q->Rear] = X;
        return true;
    }
}

出列

ElementType DeleteQ( Queue Q )
{
    if ( IsEmpty(Q) ) { 
        printf("队列空");
        return ERROR;
    }
    else  {
        Q->Front =(Q->Front+1)%Q->MaxSize;
        return  Q->Data[Q->Front];
    }
}

判断

bool IsFull( Queue Q )
{
    return ((Q->Rear+1)%Q->MaxSize == Q->Front);
}

bool IsEmpty( Queue Q )
{
    return (Q->Front == Q->Rear);
}

堆栈的链式存储实现

• 队列的链式存储结构也可以用一个单链表实现。
• 插入和删除操作分别在链表的两头进行

定义

typedef struct Node *PtrToNode;
struct Node { /* 队列中的结点 */
    ElementType Data;
    PtrToNode Next;
};
typedef PtrToNode Position;
 
struct QNode {
    Position Front, Rear;  /* 队列的头、尾指针 */
    int MaxSize;           /* 队列最大容量 */
};
typedef struct QNode *Queue;

出列

ElementType DeleteQ( Queue Q )
{
    Position FrontCell; 
    ElementType FrontElem;
     
    if  ( IsEmpty(Q) ) {
        printf("队列空");
        return ERROR;
    }
    else {
        FrontCell = Q->Front;
        if ( Q->Front == Q->Rear ) /* 若队列只有一个元素 */
            Q->Front = Q->Rear = NULL; /* 删除后队列置为空 */
        else                     
            Q->Front = Q->Front->Next;
        FrontElem = FrontCell->Data;
 
        free( FrontCell );  /* 释放被删除结点空间  */
        return  FrontElem;
    }
}

2.4 实例：一元多项式的加法与乘法运算

题目：

设计函数分别求两个一元多项式的乘积与和

已知两个多项式:
  (1) 3x4 - 5x2 + 6x - 2
  (2) 5x20 - 7x4 + 3x
 

多项式乘积:
  15x24-25x22+30x21-10x20-21x8+35x6-33x5+14x4-15x3+18x2-6x

多项式的表示

typedef struct PolyNode *Polynomial;
struct PolyNode {
int coef;
int expon;
Polynomial link;
};

程序框架搭建

int main()
{
  Polynomial P1, P2, PP, PS;
  P1 = ReadPoly();
  P2 = ReadPoly();
  PP = Mult( P1, P2 );
  PrintPoly( PP );
  PS = Add( P1, P2 );
  PrintPoly( PS );
  return 0;
}

如何读入多项式

Polynomial ReadPoly()
{
  Polynomial P, Rear, t;
  int c, e, N;
  scanf("%d", &N);
  P = (Polynomial)malloc(sizeof(struct PolyNode)); /* 链表头空结点 */
  P->link = NULL;
  Rear = P;
  while ( N-- ) {
scanf("%d %d", &c, &e);
Attach(c, e, &Rear); /* 将当前项插入多项式尾部 */
  }
  t = P; P = P->link; free(t); /* 删除临时生成的头结点 */
  return P;
}


void Attach( int c, int e, Polynomial *pRear )
{ Polynomial P;
P = (Polynomial)malloc(sizeof(struct PolyNode)); 
P->coef = c; /* 对新结点赋值 */
P->expon = e;
P->link = NULL;
(*pRear)->link = P; 
*pRear = P; /* 修改pRear值 */
}

Rear初值是多少？
两种处理方法：

1. Rear初值为NULL
2. Rear指向一个空结点

如何将两个多项式相加

Polynomial Add( Polynomial P1, Polynomial P2 )
{ ……
t1 = P1; t2 = P2;
P = (Polynomial)malloc(sizeof(struct PolyNode)); P->link = NULL;
Rear = P;
while (t1 && t2) {
if (t1->expon == t2->expon) {
…..
}
else if (t1->expon > t2->expon) {
……
}
else {
……
}
}
while (t1) {
……
}
while (t2) {
…..
}
……..
return P;
}

如何将两个多项式相乘

方法：
1.将乘法运算转换为加法运算
将P1当前项(ci,ei)乘P2多项式，再加到结果多项式中

2.逐项插入
将P1当前项(c1i,e1i)乘P2当前项（c2i,e2i),并插入到结果多项式
中。关键是要找到插入位置
初始结果多项式可由P1第一项乘P2获得（如上）

Polynomial Mult( Polynomial P1, Polynomial P2 )
{ 
    Polynomial P, Rear, t1, t2, t;
    int c, e;
    if (!P1 || !P2) return NULL;
    t1 = P1; t2 = P2;
    P = (Polynomial)malloc(sizeof(struct PolyNode)); P->link = NULL;
    Rear = P;
    while (t2) { 
    /* 先用P1的第1项乘以P2，得到P */
    Attach(t1->coef*t2->coef, t1->expon+t2->expon, &Rear);
    t2 = t2->link;}
    t1 = t1->link;
    while (t1) 
    {
        t2 = P2; Rear = P;
        while (t2) 
        {
            e = t1->expon + t2->expon;
            c = t1->coef * t2->coef;
            while (Rear->link && Rear->link->expon > e)
                Rear = Rear->link;
            if (Rear->link && Rear->link->expon == e) {
                if (Rear->link->coef + c)
                    Rear->link->coef += c;
                else {
                    t = Rear->link;
                    Rear->link = t->link;
                    free(t);
                }
            }
            else {
                t = (Polynomial)malloc(sizeof(struct PolyNode));
                t->coef = c; t->expon = e;
                t->link = Rear->link;
                Rear->link = t; Rear = Rear->link;
            }
            t2 = t2->link;
        }
        t1 = t1->link;
    }
    t2 = P; P = P->link; free(t2);
    return P;
}

如何将多项式输出

void PrintPoly( Polynomial P )
{ /* 输出多项式 */
int flag = 0; /* 辅助调整输出格式用 */
if (!P) {printf("0 0\n"); return;}
while ( P ) {
if (!flag)
flag = 1;
else
printf(" ");
printf("%d %d", P->coef, P->expon);
P = P->link;
}
printf("\n");
}

二、树

三、图

四、排序

五、散列查找