二、线性结构

---

一、线性表

---

1.1 顺序表 ArrayList

#define MAXSIZE 100
typedef int ElementType;
typedef struct LNode *List;
struct LNode {
    ElementType Data[MAXSIZE];
    int Last; //最后一个数组下标
};

struct LNode L;
List PtrL;

// 1.初始化
List MakeEmpty() {
    List PtrL;
    PtrL = (list)malloc(sizeof(struct LNode));
    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;
    return i;
}

// 3.插入（在第i个位置，1<=i<=n+1，插入下标为i-1）
void Insert(ElementType X, int i, List PtrL) {
    if(PtrL->Last==MAXSIZE-1) {
        printf("表满\n");
        return;
    }
    if(i<1||i>PtrL->Last+2) {
        printf("插入位置不合法\n");
        return;
    }
    for(int j=PtrL->Last; j>i-2; j--) {
        PtrL->Data[j+1]=PtrL->Data[j]; //往后挪
    }
    PtrL->Data[i-1]=X;
    PtrL->Last++;
    return;
}

// 4.删除（第i个位置，1<=i<=n+1，删除下标为i-1）
void Delete(int i, List PtrL) {
    if(i<1||i>PtrL->Last+1) {
        printf("删除位置不合法\n");
        return;
    }
    for(int j=i-1; j<PtrL->Last; j++) {
        PtrL->Data[j]=PtrL->Data[j+1]; //往前挪
    }
    PtrL->Last--;
    return;
}

---

1.2 链表 LinkList

typedef int ElementType;
typedef struct LNode *list;
struct LNode {
    ElementType Data;
    List Next; //下一个结点的位置
};

struct LNode L;
List PtrL;

// 1.求表长
int Length(List PtrL) {
    List p=PtrL;
    int j=0;
    while(p) { //循环至最后一个结点时，p=NULL
        p=p->Next;
        j++;
    }
    return j;
}

// 2.查找
//   按序号查找（第K个元素）
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;
    return NULL;
//    if (p==NULL) return NULL;
//    else return p;
//    或者说直接简化为：return p;
//    都是错的，因为K<1时，不能返回NULL
}
//   按值查找
List Find(ElementType X, List PtrL) {
    List p=PrtL;
    while(p!=NULL&&p->Data!=X)
        p=p->NEXT;
    return p;
}

// 3.插入（在第i个位置，即第i-1个结点的后面，1<=i<=n+1）
List Insert(ElementType X, int i, List PrtL) {
    List p,s;
    if(i==1) { //在表头插入
        s=(List)malloc(sizeof(struct LNode));
        s->Data=X;
        s->Next=PtrL;
        return s;
    }
    p=FindKth(i-1,PtrL); //查找第i-1个结点
    if(p=NULL) { //第i-1个结点不存在，不能插入
        printf("参数i错\n");
        return NULL;
    } else {
        s=(List)malloc(sizeof(struct LNode));
        s->Data=X;
        s->Next=p->Next;
        p->Next=s;
        return PtrL;
    }
}

// 4.删除（第i个位置，1<=i<=n）
List Delete(int i, List PtrL) {
    List p,s;
    if(i==1) {
        s=PtrL;
        if(PtrL!=NULL)
            PtrL=PtrL->Next;
        else
            return NULL;
        free(s);
        return PtrL;
    }
    p=FindKth(i-1,PtrL);
    if(p==NULL) {    //i超出表长
        printf("第%d个结点不存在\n",i-1);
        return NULL;
    } else if(p->Next==NULL) {
        printf("第%d个结点不存在\n",i);
        return NULL;
    } else {
        s=p->Next;
        p->Next=s->Next;
        free(s);
        return PtrL;
    }
}

---

1.3 广义表

• 多重链表：
  • 指针域可能有多个
  • 包含两个指针域的链表不一定是多重链表，如双向链表不是多重链表
• 多重链表应用：
  • 十字链表存储稀疏矩阵，
  • 行坐标、列坐标、数值、行指针、列指针

typedef struct GNode *GList;
struct GNode {
    int Tag;   //标志，0表示单元素，1表示广义表
    union {  //子表指针域与单元素数据域复用
        ElementType Data;
        GList SubList;
    } URegion;
    GList Next;  //指向后继结点
};

---

二、堆栈

---

2.1 顺序栈

#define MAXSIZE 1000
typedef struct SNode *Stack;
struct SNode {
    ElementType Data[MAXSIZE]; /* 存储元素的数组 */
    int Top;      /* 栈顶指针 */
};

bool Push( Stack S, ElementType X ) {
    if ( S->Top == S->MAXSIZE-1 ) {
        printf("堆栈满");
        return false;
    } else {
        S->Data[++(S->Top)] = X;
        return true;
    }
}

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

---

2.2 共享栈

#define MAXSIZE
struct DStack {
    ElementType Data[MAXSIZE];
    int Top1;
    int Top2;
} S;

void Push(struct DStack *PtrS, ElementType item, int Tag) {
    if(PtrS->Top2-PtrS->Top1==1) {
        printf("栈满\n");
        return;
    }
    if(Tag==1) //对第一个堆栈操作
        PtrS->Data[++(PtrS->Top1)]=item;
    else
        PtrS->Data[--(PtrS->Top2)]=item;
}

ElementType Pop(struct DStack *PtrS, int Tag) {
    if(Tag==1) {
        if(PtrS->Top1==-1) {
            printf("堆1空\n");
            return NULL;
        } else {
            return PtrS->Data[(PtrS->Top1)--];
        }
    } else {
        if(PtrS->Top2==MAXSIZE) {
            printf("堆2空\n");
            return NULL;
        } else {
            return PtrS->Data[(PtrS->Top2)++];
        }
    }
}

---

2.3 链栈

typedef struct SNode *Stack;
struct SNode {
    ElementType Data;
    struct SNode *Next;
};

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

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

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

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

---

三、队列

---

3.1 循环队列

typedef int Position;
struct QNode {
    ElementType *Data;     /* 存储元素的数组 */
    Position Front, Rear;  /* 队列的头、尾指针 */
    int MaxSize;           /* 队列最大容量-1 */
};
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 IsFull( Queue Q ) {
    return ((Q->Rear+1)%Q->MaxSize == Q->Front);
}

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;
    }
}

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

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

---

3.2 链队

typedef struct Node *PtrToNode;
struct Node { /* 队列中的结点 */
    ElementType Data;
    PtrToNode Next;
};
typedef PtrToNode Position;

struct QNode {
    Position Front, Rear;  /* 队列的头、尾指针 */
    int MaxSize;           /* 队列最大容量 */
};
typedef struct QNode *Queue;

Queue PtrQ;

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

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;
    }
}

---

四、Practice

02-线性结构1 两个有序链表序列的合并
02-线性结构2 一元多项式的乘法与加法运算
02-线性结构3 Reversing Linked List
02-线性结构4 Pop Sequence