线性表及其逻辑结构（超详细版）

原创 于 2025-03-30 14:35:56 发布 · 492 阅读 · 9 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #链表 #线性表

一、线性表

1.定义：具有相同特性的数据元素的一个有限序列

2.特性：有穷性、一致性、序列性

二、线性表的顺序存储结构----顺序表

顺序表的各种操作（含详细注释）

#include <stdio.h>
#include <stdlib.h>

#define MAXSIZE 50
typedef int ElemType; // 假设元素类型为int

typedef struct {
    ElemType data[MAXSIZE]; // 存放线性表中的元素
    int length;             // 存放线性表的长度
} SqList;                   // 顺序表类型

// 1. 初始化顺序表
void InitList(SqList *L) {
    L->length = 0;
}

// 2. 销毁顺序表（顺序表是静态分配的，不需要特殊操作）
void DestroyList(SqList *L) {
    L->length = 0; // 只需将长度置0
}

// 3. 判断顺序表是否为空
int ListEmpty(SqList L) {
    return (L.length == 0);
}

// 4. 求顺序表长度
int ListLength(SqList L) {
    return L.length;
}

// 5. 按元素值查找，返回位置（从1开始），找不到返回0
int LocateElem(SqList L, ElemType e) {
    for (int i = 0; i < L.length; i++) {
        if (L.data[i] == e) {
            return i + 1; // 返回位置（从1开始）
        }
    }
    return 0; // 未找到
}

// 6. 插入元素（在位置i插入元素e）
int ListInsert(SqList *L, int i, ElemType e) {
    if (i < 1 || i > L->length + 1) { // 检查插入位置是否合法
        return 0; // 插入失败
    }
    if (L->length >= MAXSIZE) { // 检查顺序表是否已满
        return 0; // 插入失败
    }
    
    // 将第i个位置及之后的元素后移
    for (int j = L->length; j >= i; j--) {
        L->data[j] = L->data[j - 1];
    }
    
    L->data[i - 1] = e; // 插入新元素
    L->length++;        // 表长加1
    return 1;           // 插入成功
}

// 7. 删除元素（删除位置i的元素，并用e返回其值）
int ListDelete(SqList *L, int i, ElemType *e) {
    if (i < 1 || i > L->length) { // 检查删除位置是否合法
        return 0; // 删除失败
    }
    
    *e = L->data[i - 1]; // 保存被删除元素的值
    
    // 将第i个位置之后的元素前移
    for (int j = i; j < L->length; j++) {
        L->data[j - 1] = L->data[j];
    }
    
    L->length--; // 表长减1
    return 1;    // 删除成功
}

// 8. 建立顺序表（通过数组创建）
void CreateList(SqList *L, ElemType a[], int n) {
    if (n > MAXSIZE) {
        printf("数组长度超过顺序表最大容量！\n");
        return;
    }
    for (int i = 0; i < n; i++) {
        L->data[i] = a[i];
    }
    L->length = n;
}

// 打印顺序表
void PrintList(SqList L) {
    printf("顺序表内容：");
    for (int i = 0; i < L.length; i++) {
        printf("%d ", L.data[i]);
    }
    printf("\n");
}

int main() {
    SqList L;
    ElemType e;
    
    // 测试各个操作
    InitList(&L);
    printf("初始化后，顺序表是否为空：%s\n", ListEmpty(L) ? "是" : "否");
    
    ElemType arr[] = {1, 3, 5, 7, 9};
    CreateList(&L, arr, 5);
    PrintList(L);
    printf("当前顺序表长度：%d\n", ListLength(L));
    
    printf("元素5的位置：%d\n", LocateElem(L, 5));
    
    ListInsert(&L, 3, 4);
    printf("在第3个位置插入4后：");
    PrintList(L);
    
    ListDelete(&L, 4, &e);
    printf("删除第4个位置的元素%d后：", e);
    PrintList(L);
    
    DestroyList(&L);
    printf("销毁后顺序表长度：%d\n", ListLength(L));
    
    return 0;
}

三、线性表的的链式存储结构----链表

单链表

        线性表的的每个元素用一个内存结点存储每个内存结点存储，每个内存结点包含本身的数据域和表示元素之间逻辑关系用指针实现（也就是指针域）。

node ：结点

箭头：指针

data: 每个结点存储的数据

单链表示意图

相关代码示例

#include <stdio.h>
#include <stdlib.h>

// 定义单链表节点结构
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// 创建新节点
Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (newNode == NULL) {
        printf("内存分配失败\n");
        exit(1);
    }
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// 在链表头部插入节点
Node* insertAtBeginning(Node* head, int data) {
    Node* newNode = createNode(data);
    newNode->next = head;
    return newNode;
}

// 在链表尾部插入节点
Node* insertAtEnd(Node* head, int data) {
    Node* newNode = createNode(data);
    if (head == NULL) {
        return newNode;
    }
    Node* temp = head;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    temp->next = newNode;
    return head;
}

// 删除指定值的第一个节点
Node* deleteNode(Node* head, int key) {
    Node* temp = head;
    Node* prev;
    if (temp != NULL && temp->data == key) {
        head = temp->next;
        free(temp);
        return head;
    }
    while (temp != NULL && temp->data != key) {
        prev = temp;
        temp = temp->next;
    }
    if (temp == NULL) return head;
    prev->next = temp->next;
    free(temp);
    return head;
}

// 查找指定值的节点
Node* searchNode(Node* head, int key) {
    Node* temp = head;
    while (temp != NULL) {
        if (temp->data == key) {
            return temp;
        }
        temp = temp->next;
    }
    return NULL;
}

// 遍历链表
void traverseList(Node* head) {
    Node* temp = head;
    while (temp != NULL) {
        printf("%d ", temp->data);
        temp = temp->next;
    }
    printf("\n");
}

// 释放链表内存
void freeList(Node* head) {
    Node* temp;
    while (head != NULL) {
        temp = head;
        head = head->next;
        free(temp);
    }
}

int main() {
    Node* head = NULL;
    head = insertAtBeginning(head, 1);
    head = insertAtEnd(head, 2);
    head = insertAtEnd(head, 3);
    printf("链表元素: ");
    traverseList(head);
    head = deleteNode(head, 2);
    printf("删除元素 2 后链表元素: ");
    traverseList(head);
    Node* found = searchNode(head, 3);
    if (found != NULL) {
        printf("找到元素 3\n");
    } else {
        printf("未找到元素 3\n");
    }
    freeList(head);
    return 0;
}

1. 关键操作说明

头插法：新结点始终插入头结点之后（逆序建表）。

尾插法：维护尾指针，新结点插入链表尾部（顺序建表）。

（根据题目要求选择合适的插入方法）

插入/删除：需先找到前驱结点（第i-1个结点）。

销毁链表：需要逐个释放所有结点内存。

2. 时间复杂度

按位查找/插入/删除：O(n)

头插法建表：O(n)

尾插法建表：O(n)

单链表虽然实现简单且内存利用率高，但也存在以下几个主要缺点：

(1)单向遍历，无法逆向访问

问题：单链表的指针域仅指向后继结点，无法直接访问前驱结点。

(2)查找效率低

问题：单链表只能顺序访问，不支持随机访问。

(3)删除/插入操作依赖前驱结点

问题：在位置 i 插入或删除结点时，需要先找到第 i-1 个结点（前驱结点）。

(4)内存空间额外开销

问题：每个结点需要额外存储指针域（next 指针）。

(5) 尾部操作效率低

问题：单链表需遍历到尾结点才能执行尾部插入/删除。

(6)无法直接实现某些高效算法

问题：单链表结构限制了算法的灵活性,快速排序等需随机访问的算法在单链表上难以高效实现。

解决单向链表的缺点----双线链表

单向链表每个节点只有一个next指针，增加一个pre指针用来指向前一个节点，这样就能够往前往后的双向查找了。

双向链表

插入操作

s->next=p->next;            //将s结点插入p结点之后
p->next->prev=s;
s->prev=p;
p->next=s;
#include <stdio.h>
#include <stdlib.h>

// 定义双向链表节点结构
typedef struct Node {
    int data;
    struct Node* prev;
    struct Node* next;
} Node;

// 创建新节点
Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (newNode == NULL) {
        printf("内存分配失败\n");
        exit(1);
    }
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = NULL;
    return newNode;
}

// 在链表头部插入节点
Node* insertAtBeginning(Node* head, int data) {
    Node* newNode = createNode(data);
    if (head == NULL) {
        return newNode;
    }
    newNode->next = head;
    head->prev = newNode;
    return newNode;
}

// 在链表尾部插入节点
Node* insertAtEnd(Node* head, int data) {
    Node* newNode = createNode(data);
    if (head == NULL) {
        return newNode;
    }
    Node* temp = head;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    temp->next = newNode;
    newNode->prev = temp;
    return head;
}

// 删除指定值的第一个节点
Node* deleteNode(Node* head, int key) {
    if (head == NULL) {
        return head;
    }
    Node* temp = head;
    if (temp->data == key) {
        head = temp->next;
        if (head != NULL) {
            head->prev = NULL;
        }
        free(temp);
        return head;
    }
    while (temp != NULL && temp->data != key) {
        temp = temp->next;
    }
    if (temp == NULL) {
        return head;
    }
    if (temp->prev != NULL) {
        temp->prev->next = temp->next;
    }
    if (temp->next != NULL) {
        temp->next->prev = temp->prev;
    }
    free(temp);
    return head;
}

// 查找指定值的节点
Node* searchNode(Node* head, int key) {
    Node* temp = head;
    while (temp != NULL) {
        if (temp->data == key) {
            return temp;
        }
        temp = temp->next;
    }
    return NULL;
}

// 正向遍历链表
void traverseForward(Node* head) {
    Node* temp = head;
    while (temp != NULL) {
        printf("%d ", temp->data);
        temp = temp->next;
    }
    printf("\n");
}

// 反向遍历链表
void traverseBackward(Node* head) {
    if (head == NULL) {
        return;
    }
    Node* temp = head;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    while (temp != NULL) {
        printf("%d ", temp->data);
        temp = temp->prev;
    }
    printf("\n");
}

// 释放链表内存
void freeList(Node* head) {
    Node* temp;
    while (head != NULL) {
        temp = head;
        head = head->next;
        free(temp);
    }
}

int main() {
    Node* head = NULL;
    head = insertAtBeginning(head, 1);
    head = insertAtEnd(head, 2);
    head = insertAtEnd(head, 3);
    printf("正向遍历链表元素: ");
    traverseForward(head);
    printf("反向遍历链表元素: ");
    traverseBackward(head);
    head = deleteNode(head, 2);
    printf("删除元素 2 后正向遍历链表元素: ");
    traverseForward(head);
    Node* found = searchNode(head, 3);
    if (found != NULL) {
        printf("找到元素 3\n");
    } else {
        printf("未找到元素 3\n");
    }
    freeList(head);
    return 0;
}

双向链表 vs 单链表对比

操作双向链表单链表
插入/删除可直接操作前驱和后继（O(1)）需遍历找前驱（O(n)）
逆向遍历直接通过prior指针（O(n)）无法直接实现（需栈辅助）
空间开销每个结点多一个指针域仅一个指针域
适用场景需要频繁逆向操作或双向查找简单线性操作

双向链表通过空间换时间，显著提升了插入、删除和遍历的灵活性！

双链表的优化----循环链表

#include <stdio.h>
#include <stdlib.h>

// 定义单向循环链表节点结构
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// 创建新节点
Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (newNode == NULL) {
        printf("内存分配失败\n");
        exit(1);
    }
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// 初始化单向循环链表
Node* initCircularSingleList(int data) {
    Node* head = createNode(data);
    // 让头节点的 next 指针指向自身，形成循环
    head->next = head;
    return head;
}

// 遍历单向循环链表
void traverseCircularSingleList(Node* head) {
    if (head == NULL) {
        return;
    }
    Node* temp = head;
    do {
        printf("%d ", temp->data);
        temp = temp->next;
    } while (temp != head);
    printf("\n");
}

int main() {
    // 初始化单向循环链表，初始数据为 1
    Node* head = initCircularSingleList(1);
    printf("单向循环链表元素: ");
    traverseCircularSingleList(head);
    return 0;
}

                                 

LFLY_J
关注
线性表的逻辑结构
bingXxx的博客
12-11 7858
线性表的定义:用数据元素的有限序列表示的表,我们称之为线性表 比如 a1,a2,a3,a4…an,其中a1就是线性表的起点,而a1中的下标1表示的就是元素的序号,它表示了这个元素在线性表中的位置,而相对a2来说它的直接前驱就是a1,而它的直接后继就是a3,而an中n表示的就是这个线性表的长度. 注意:同一个线性表具有相同的特性,相邻的数据元素之间是序偶关系(表示的就是有序成对的意思) 比如上面这...
1.1 线性表的逻辑结构：
L158943041的博客
06-02 820
例一：有两个集合A和B分别用两个线性表La和Lb表示，即：线性表中的数据元素即为集合中的成员；分析：上述问题演绎为：要求对线性表作如下操作：扩大线性表La,将存于线性表Lb中而不存与线性表La中的数据元素插入到La中去。线性集合A和B的合并：A：把B中的元素加入A中首先： Len_Lb = ListbLength(Lb);(Len_La = ListLength(La))取得线性表Lb的长度，为下...
【数据结构】线性表的逻辑结构
SuperSources的博客
09-17 1525
第一节、线性表的逻辑结构 1、线性表的定义 是零个或多个具有相同类型的数据元素的有限序列。 2、线性表的抽象数据类型定义 ADT List Data 线性表中的数据元素具有相同类型，相邻元素具有前驱和后继关系 Operation InitList 前置条件：线性表不存在 输入：无 功能：线性表的初始化 输出： 无 后置条件：一个空的线性表 DestroyList 前置条件：...
线性表(逻辑结构)
weixin_39280437的博客
07-12 1855
线性表定义（逻辑结构）值得注意的特性重要术语基本运算创销、增删改查判空、判长、打印输出其它值得注意的点 定义（逻辑结构） 线性表是具有相同数据类型的n个数据元素的有限序列，其中n为表长，当n=0时线性表是一个空表。若用L表示线性表，则一般表示为 几个概念： a_i表示线性表中第i个元素的位序；（程序中下标从零开始） a_0表示线性表的表头元素； a_n表示线性表的表尾元素； 除第一个元素外，每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有一个直接后继 值得注意的特性 数据元素同类型、
线性表逻辑结构
gsh1075035316的博客
08-10 490
按元素的特性分类 再按元素的不同组织关系分类 如一对一、一对多、多对多 先强调元素的相同特性 再强调元素的不同组织关系 上面这些话的意思是 不只线性表要强调相同特性 图 树等等 都要强调相同特性 ...
线性表的逻辑结构及其存储实现详解
总结来说，本部分课程详细介绍了线性表的逻辑结构和存储结构，并对顺序表和链表这两种存储结构的具体实现进行了深入讲解，同时也涵盖了基本运算的实现方法以及应用案例分析。作为数据结构课程的重要组成部分，本课程...
数据结构线性表及其基本算法.pptx
06-11
线性表是数据结构中的基础概念，它表示元素之间存在一一对应关系的有限序列，通常按照一定的...线性表及其基本算法是数据结构课程中的重要内容，其理论知识和操作技巧对后续学习更为复杂的数据结构打下了坚实的基础。
线性表的逻辑结构与实现分析
"这篇资料主要介绍了数据结构中的线性表，通过职工工资登记表和学生成绩登记表作为实例，阐述了线性表的基本概念、逻辑结构及其特性，并提到了线性表的操作如初始化、销毁和求长度等。" 线性表是数据结构中的基础...
线性表：逻辑结构与存储结构详解
数据结构课程的核心内容之一是线性表，它探讨了逻辑结构与存储结构的区别以及它们在算法设计中的重要性。线性表是一个数据结构的基本概念，它定义为数据元素的有限序列，每个元素都有唯一的序号或位置。在逻辑上，...
C语言实现线性表顺序存储结构及其基本操作
最新发布
07-08
线性表是数据结构中的基本概念，...利用C语言实现顺序表的顺序存储结构及其基本操作，不仅可以加深对线性表概念的理解，而且能够锻炼程序员的指针操作能力和内存管理能力，对数据结构和算法的学习和应用具有重要意义。
线性表——(1)线性表的逻辑结构
一个正在学习C/C++的博主
11-27 1377
线性表的逻辑结构
数据结构(03)：线性表的逻辑结构
qq_42279379的博客
08-15 295
线性表的逻辑结构：介绍了线性表的逻辑结构，并阐述了线性表的基本特征，即线性表的抽象数据类型
2.1 线性表的逻辑结构
weixin_30263277的博客
04-08 156
线性表是最简单、最基本、也是最常用的一种线性结构。它有两种存储方法：顺序存储和链式存储，它的主要基本操作是插入、删除和检索等。 2.1.1 线性表的定义 线性表是一种线性结构。线性结构的特点是数据元素之间是一种线性关系，数据元素“一个接一个的排列”。在一个线性表中数据元素的类型是相同的，或者说线性表是由同一类型的数据元素构成的线性结构。在实际问题中线性表的例子是很多的，如学生情况信息表是一...
期末复习 线性表的逻辑结构（数据结构——用C语言表示）
weixin_44488944的博客
06-20 292
一些概念性的东西。（先知道什么是线性表，线性表概念，特点，和一些看课本时出现的概念……） 首先认识一下什么是线性表 线性表，最简单，最常见的数据结构 线性表：线性表是n个类型相同数据元素的有限序列，对n>0，除第一个元素无直接前驱，最后一个元素无直接后继外其余的元素都只有一个直接前驱和一个直接后继。（第一个元素前面没东西，最后一个元素后面没东西，其余元素被夹在中间。） 线性表是由n(n&gt...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值