第二章线性表

最新推荐文章于 2025-12-16 16:07:35 发布

原创最新推荐文章于 2025-12-16 16:07:35 发布 · 1.4k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#数据结构

数据结构专栏收录该内容

4 篇文章

订阅专栏

线性表

线性表基础
- 理论
顺序表
单链表
双链表
循环列表
静态链表
每种存储结构的比较

线性表基础

理论

在这里插入图片描述

注意点：

线性表的位序第几个和数组下表有区别
线性表位序从1开始
数组下表从0开始
当参数的修改结果需要“带回来”时，传入参数引用&

顺序表

理论

在这里插入图片描述

书本代码

静态分配

1. 定义

typedef struct {
    char data[MaxSize];
    int length;
}SqList;

2. 初始化

void InitList(SqList &L){
    for (int i = 0; i < MaxSize; i++) {
        L.data[i] = 'a';
    }
    L.length = 0;
}

3. 顺序表的插入

bool ListInsert(SqList &L, int i, char e) {
    /*i是顺序表的位序，不是数组下表，所以左边范围应该最小是1
      右边能插入的最大范围值应该是length+1           */
    if(i < 1||i > L.length+1){
        return false;
    }
    //当前存储空间已满
    if(L.length >= MaxSize){
        return false;
    }
    for (int j = L.length; j >= i; j--) {
        L.data[j] = L.data[j-1];
    }
    L.data[i-1] = e;
    L.length++;
    return true;
}

4. 顺序表的删除

bool ListDelete(SqList &L, int i, char &e){
    if(i < 1 || i > L.length){
        return false;
    }
    e = L.data[i-1];
    for (int j = i; j < L.length; j++) {
        L.data[j - 1] = L.data[j];
    }
    L.length--;
    return true;
}

5. 按位查找

int GetElem(SqList L, int i){
    return L.data[i-1];
}

6. 按值查找

int LocateElem(SqList L,int e){
    for (int i = 0; i < L.length; i++) {
        if(L.data[i] == e){
            return i+1;
        }
    }
    return 0;
}

动态分配

定义

typedef struct{
    char *data;
    int MaxSize;
    int length;
}SqList;

初始化

void InitList(SqList &L){
    L.data = (char *) malloc(InitSize * sizeof(char));
    L.length = 0;
    L.MaxSize = InitSize;
}

增加顺序表的长度

void IncreaseSize(SqList &L, int len){
    char *p = L.data;
    L.data =(char *) malloc((L.MaxSize + len) * sizeof(char));
    for (int i = 0; i < L.length; ++i) {        //是length不是MaxSize,因为只需要把已有的数据存到新的表里就行
        L.data[i] = p[i];
    }
    L.MaxSize = L.MaxSize + len;
    free(p);
}

插入、删除，查找同静态分配。

课后题

第一题

定义一个记录最小值的数组下标的变量，然后将最后一个元素传给最小值的位置，然后长度-1

bool DelElem(SqList &L, int &e){
    if(L.length < 1){
        cout<<"顺序表为空"<<endl;
        return false;
    }
    int min = L.data[0];
    int j = 0;
    for (int i = 1; i < L.length; i++) {
        if(L.data[i] < min){
            min = L.data[i];
            j = i;
        }
        e = min;
        L.data[j] = L.data[L.length - 1];
        L.data[L.length - 1] = 0;
        L.length--;
        return true;
    }
}

第二题

从头和尾分别向中间靠拢，每次两边交换元素

bool NiZhi(SqList &L){
    if(L.length == 0)
        return false;
    for(int i = 0; i < L.length/2; i++){
        int t = L.data[i];
        L.data[i] = L.data[L.length-i-1];
        L.data[L.length-i-1] = t;
    }
    return true;
}

第三题

定义一个初始为0的变量k，用来记录不等于x的元素的数量。遍历数组时，若元素等于x，k不增加；若元素不等于x，将元素放到下标为k的位置，同时k加1。遍历完后，将顺序表长度改为k。

void DelXList(SqList &L, int x){
    int k = 0;
    for(int i = 0; i < L.length; i++){
        if(L.data[i] != x){
            L.data[k] = L.data[i];
            k++;
        }
        L.length = k;
    }
    return ;
}

第四题

定义两个变量，一个记录第一个符合区间要求的元素下标，一个记录最后一个符合要求的元素下标。然后以后面变量为下标开始遍历顺序表，并将每一个放入到以前面变量为下标开始递增的顺序表中。之后修改顺序表的表长。

bool DelQvJian(SqList &L, int s, int t){
    if(s>=t || L.length == 0)
        return false;
    int begin = 0;
    int finish = 0;
    for(int i = 0; i < L.length; i++){
        if(L.data[i] > s && L.data[i] < t){
            if(begin == 0)
                begin = i;
            finish = i;
        }
    }
    for(int i = begin,j = 0 ; finish+1+j < L.length ; i++,j++){
        L.data[i] = L.data[finish+1+j];
    }
    L.length = L.length - (finish - begin + 1);
    return true;
}

第五题

同第四题

bool DelQvJian(SqList &L, int s, int t){
    if(s>=t || L.length == 0)
        return false;
    int begin = 0;
    int finish = 0;
    for(int i = 0; i < L.length; i++){
        if(L.data[i] >= s && L.data[i] <= t){
            if(begin == 0)
                begin = i;
            finish = i;
        }
    }
    for(int i = begin,j = 0 ; finish+1+j < L.length ; i++,j++){
        L.data[i] = L.data[finish+1+j];
    }
    L.length = L.length - (finish - begin + 1);
    return true;
}

第六题

定义一个记录位序的变量。当循环变量时，该变量也随之递增。当遇见和前面元素相同的元素时，该变量停止递增。直到遇见不同的元素时，先将这个元素放入到该变量为下标的位置，递增变量。最后修改表长。

void DelSamElem(SqList &L){
    int first = L.data[0];
    int begin = 1;
    for(int i = 1; i < L.length; i++){
        if(L.data[i] == first){
            continue;
        }
        L.data[begin] = L.data[i];
        first = L.data[i];
        begin++;
    }
    L.length = begin;
    return ;
}

第七题

顺序表的合并

bool HeBingList(SqList L1, SqList L2, SqList &L3){
    if(L1.length + L2.length > MaxSize)
        return false;
    int x = 0;
    int y = 0;
    int i = 0;
    for(; x < L1.length && y < L2.length; i++){
        if(L1.data[x] <= L2.data[y]){
            L3.data[i] = L1.data[x];
            x++;
        }else{
            L3.data[i] = L2.data[y];
            y++;
        }
    }
    if(x != L1.length)
        for(int j = x; j < L1.length ; j++,i++)
            L3.data[i] = L1.data[j];
    if(y != L2.length)
        for(int j = y; j < L2.length ; j++,i++)
            L3.data[i] = L2.data[j];
    L3.length = L1.length + L2.length;
    return true;
}

第八题

先将数组整个逆置，然后在以b的长度-1为下标分别将前后两个逆置。

void Swap(int x, int y, int *A){
    int n = x+y;
    for (int i = 0; i < n/2; i++) {
        int t = A[i];
        A[i] = A[n-1-i];
        A[n-1-i] = t;
    }
    for(int i = 0 ; i < y/2 ; i++){
        int t = A[i];
        A[i] = A[y-1-i];
        A[n-1-i] = t;
    }
    for(int i = 0 ; i < x/2 ; i++){
        int t = A[y+i];
        A[y+i] = A[n-1-i];
        A[n-1-i] = t;
    }
}

第九题

先二分查找该元素。找到就判断能不能和后继交换。找不到就从最后二分的右边开始一个个后移，并在该位置插入该元素。

void FindElem(SqList &L, int t){
    int left = 0, right = L.length-1, mid;
    int i;
    while (left <= right){
        mid = (left + right) / 2;
        if (L.data[mid] == t)
            break;
        else if(L.data[mid] < t)
            left = mid + 1;
        else
            right = mid - 1;
    }
    if (L.data[mid] == t && mid != L.length-1){
        int temp;
        temp = L.data[mid];
        L.data[mid] = L.data[mid+1];
        L.data[mid+1] = temp;
    }
    if(left > right){
        for (i = L.length-1; i >right; i--) {
            L.data[i+1] = L.data[i];
        }
        L.data[i+1] = t;
    }
}

单链表

理论

在这里插入图片描述

头插法的重要逆用：链表的逆置。

书本代码

1. 定义单链表

typedef struct LNode{
    char data;
    struct LNode *next;
}LNode,*LinkList;

2. 初始化不带头结点的单链表

bool InitList(LinkList &L){
    L = NULL;
    return true;
}

3. 不带头单链表判空

bool Empty(LinkList L){
    if(L == NULL)
        return true;
    else
        return false;
}

4. 按位序插入(不带头结点)

bool ListInsert(LinkList &L, int i, char e){
    if(i < 1)
        return false;
    LNode *p;
    if(i == 1){
        p = (LNode *)malloc(sizeof(LNode));
        p->data = e;
        p->next = L;
        L=p;       //头指针指向新结点
        return true;
    }
    int j = 1;
    p=L;
    while (p != NULL && j < i-1){
        p = p->next;
        j++;
    }
    if(p == NULL)
        return false;
    LNode *s = (LNode *) malloc(sizeof(LNode));
    s->next = p->next;
    p->next = s;
    s->data = e;
    return true;
}

5. 初始化带头结点的单链表

bool InitList_(LinkList &L){
    L = (LNode *) malloc(sizeof(LNode));
    if(L == NULL){      //判断分配是否成功
        return false;
    }else{
        return true;
    }
}

6. 带头结点单链表判空

bool Empty_(LinkList L){
    if(L->next == NULL)
        return true;
    else
        return false;
}

7. 按位序插入(带头结点)

bool ListInsert_(LinkList &L, int i, char e){
    if(i < 1)
        return false;
    LNode *p;       //用来扫描结点的指针p
    int j = 0;      //扫描的第几个结点
    p = L;
   while(p != NULL && j < i-1){
       p = p->next;
       j++;
   }
   if(p == NULL)
       return false;
   LNode *s = (LNode *)malloc(sizeof(LNode));
   s->data = e;
   s->next = p->next;
   p->next = s;
   return true;
}

8. 按位查找

LNode * GetElem(LinkList L, int i){
    if(i < 0)       //头结点
        return NULL;
    LNode *p;
    p = L;
    int j = 0;
    while (p != NULL && j < i){
        p = p->next;
        j++;
    }
    return p;
}

9. 按值查询

LNode * LocateElem(LinkList L,char e){
    LNode *p;
    p = L->next;
    while (p != NULL && p->data != e){
        p = p->next;
    }
    return p;
}

10. 求表长

int Length(LinkList L){
    int i = 0;
    LNode *p = L->next;
    while(p != NULL){
        p = p->next;
        i++;
    }
    return i;
}

11. 尾插法创建单链表

LinkList List_TailInsert(LinkList &L){
    L = (LNode *) malloc(sizeof(LNode));
    LNode *biaoji = L,*p;
    char x;
    scanf("%c",&x);
    while(x = '#'){
        p = (LNode *) malloc(sizeof(LNode));
        p->data = x;
        biaoji->next = p;
        biaoji = p;
        scanf("%c",&x);
    }
    biaoji->next = NULL;
    return L;
}

12. 头插法

LinkList List_HeadInsert(LinkList &L){
    char x;
    /*
     * 头插法不需要用来指向最后结点的指针
     * 因为每次插入都是插在头结点后
     */
    LNode *p = L;
    L->next = NULL;
    scanf("%c",&x);
    while (x != '#'){
        p = (LNode *) malloc(sizeof(LNode));
        p->data = x;
        p->next = L->next;
        L->next = p;
        scanf("%c",&x);
    }
    return L;
}

13. 后插操作

bool InsertNextNode(LNode *p, char e){
    if(p == NULL)
        return false;
    LNode *s = (LNode *) malloc(sizeof(LNode));
    if(s == NULL)
        return false;
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

14. 前插操作

bool InsertPriorNode(LNode *p, char e){
    if(p == NULL)
        return false;
    LNode *s = (LNode *) malloc(sizeof(LNode));
    if(s == NULL)
        return false;
    s->next = p->next;
    p->next = s;
    s->data = p->data;
    p->data = e;
    return true;
}

15. 指定结点删除

bool DeleteNode(LNode *p){
    if(p == NULL){
        return false;
    }
    /*
     * 和该结点后面的结点交换，删后面的结点
     * 类似于前插
     */
    LNode *q = p->next;
    p->data = p->next->data;
    p->next = q->next;
    free(q);
    return true;
}

双链表

理论

双链表在定义时比单链表多一个前驱指针。
双链表虽可进可退，但是存储密度要更低一些。
在插入结点和删除结点时，要注意前驱结点与后继结点的指针需要被修改。

书本代码

1. 定义双链表

typedef struct DNode{
    char e;
    struct DNode *prior,*next;
}DNode,*DLinkLIst;

2. 双链表初始化

bool InitDLinkList(DLinkLIst &L){
    L = (DNode *) malloc(sizeof(DLinkLIst));
    if(L == NULL)
        return false;
    L->prior = NULL;
    L->next = NULL;
    return true;
}

3. 判空

bool Empty(DLinkLIst L){
    if(L->next==NULL)
        return true;
    else
        return false;
}

4. 双链表的插入,在p后插入s

bool InsertNextDNode(DNode *p, DNode *s){
    if(p == NULL || s == NULL)
        return false;
    s->next = p->next;
    if(p->next != NULL)
        p->next->prior = s;
    s->prior = p;
    p->next = s;
    return true;
}

5. 删除p结点后的一个结点

bool DeleteNextDNode(DNode *p){
    if(p == NULL)
        return false;
    DNode *q;
    q = p->next;
    p->next = q->next;
    if(q->next != NULL)
        q->next->prior = p;
    free(q);
    return true;
}

6. 双链表的销毁

bool DestoryList(DLinkLIst &L){
    while (L->next != NULL)
        DeleteNextDNode(L);
    free(L);
    L=NULL;
}

循环列表

理论

区别

单链表：表尾结点的next指针指向NULL。
循环单链表：表尾结点的next指针指向头结点。

双链表：表头结点的prior指向NULL。表尾结点的next指向NULL。
循环双链表：表头结点的prior指向表尾结点。表尾结点的next指向头结点。

书本代码

1.初始化循环单链表

bool InitList(LinkList &L){
    L = (LNode *) malloc(sizeof(LNode));
    if(L == NULL)
        return false;
    L->next = L;
    return true;
}

2. 判断循环单链表是否为空

bool Empty(LinkList L){
    if(L->next == L)
        return true;
    else
        return false;
}

3. 判断结点p是否为循环单列表的表尾结点

bool isTail(LinkList L, LNode *p){
    if(p->next == L)
        return true;
    else
        return false;
}

4. 初始化双链表

bool InitDList(DLinkList &L){
    L = (DNode *) malloc(sizeof(DNode));
    if(L == NULL)
        return false;
    L->next = L;
    L->prior = L;
    return true;
}

5. 循环双链表判空

bool Empty(DLinkList L){
    if(L->next == L)
        return true;
    else
        return false;
}

6. 判断结点是否为尾结点

bool isTail(DLinkList L, DNode *p){
    if(p->next == L)
        return true;
    else
        return false;
}

7. 双链表的插入(在p后插入s)

bool InsertNextDNode(DNode *p, DNode *s){
    s->next = p->next;
    if(p->next == NULL)
        return false;
    p->next->prior = s;
    s->prior = p;
    p->next = s;
    return true;
}

8.双链表的删除(删除p的后继结点s)

bool DeleteNextDNode(DNode *p, DNode *s){
    p->next = s->next;
    if(s->next == NULL)
        return false;
    s->next->prior = p;
    free(s);
    return true;
}

静态链表

理论

0号结点充当“头结点”，游标-1表示已经到达表尾，next记录下一个结点的数组下标。

书本代码

1. 定义静态链表

typedef struct {
    char data;
    int next;
}SLinkList[MaxSize];

每种存储结构的比较

逻辑结构
都属于线性表，都是线性结构。
存储结构
顺序表：
优点：支持随即存取，存储密度高。
缺点：大片连续空间分配不方便，改变内存不方便。
链表：
优点：离散的小空间分配方便，改变容量方便。
缺点：不可随机存取，存储密度低。
特殊的(静态链表)：
优点：增删操作不需要大量移动元素。
缺点：不能随机存取，只能从头结点开始依次往后查找；容量固定不可变。
表长难以预估、经常要增加/删除元素 ——链表
表长可预估、查询（搜索）操作较多 ——顺序表