第二章线性表

最新推荐文章于 2024-08-18 12:51:45 发布
最新推荐文章于 2024-08-18 12:51:45 发布
阅读量884 收藏 19
点赞数 9
分类专栏： 数据结构 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62279628/article/details/140181733
版权

线性表基本概念：

线性表是具有相同数据类型的 n（n≥0）个数据元素的有限序列。

线性表的实现：

顺序存储：

定义：它使用一组地址连续的存储单元依次存储线性表中的元素。在顺序表中，逻辑上相邻的元素其物理存储位置也相邻。

基本实现方法：

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

#define MAX_SIZE 100  // 顺序表的最大容量

typedef struct {
    int *data;  // 存储数据的数组
    int length; // 当前顺序表的长度
    int capacity; // 顺序表的容量
} SeqList;

// 初始化顺序表
void initList(SeqList *L) {
    L->data = (int *)malloc(MAX_SIZE * sizeof(int));
    if (L->data == NULL) {
        printf("内存分配失败!\n");
        return;
    }
    L->length = 0;
    L->capacity = MAX_SIZE;
}

// 插入元素到指定位置
int insertList(SeqList *L, int pos, int element) {
    if (pos < 1 || pos > L->length + 1) {
        printf("插入位置不合法!\n");
        return 0;
    }
    if (L->length == L->capacity) {
        printf("顺序表已满，无法插入!\n");
        return 0;
    }
    for (int i = L->length; i >= pos; i--) {
        L->data[i] = L->data[i - 1];
    }
    L->data[pos - 1] = element;
    L->length++;
    return 1;
}

// 删除指定位置的元素
int deleteList(SeqList *L, int pos) {
    if (pos < 1 || pos > L->length) {
        printf("删除位置不合法!\n");
        return 0;
    }
    for (int i = pos; i < L->length; i++) {
        L->data[i - 1] = L->data[i];
    }
    L->length--;
    return 1;
}

// 查找指定元素的位置
int searchList(SeqList *L, int element) {
    for (int i = 0; i < L->length; i++) {
        if (L->data[i] == element) {
            return i + 1;
        }
    }
    return -1;
}

// 打印顺序表
void printList(SeqList *L) {
    for (int i = 0; i < L->length; i++) {
        printf("%d ", L->data[i]);
    }
    printf("\n");
}

int main() {
    SeqList L;
    initList(&L);

    insertList(&L, 1, 10);
    insertList(&L, 2, 20);
    insertList(&L, 3, 30);

    printf("初始顺序表: ");
    printList(&L);

    insertList(&L, 2, 15);
    printf("插入元素后的顺序表: ");
    printList(&L);

    deleteList(&L, 2);
    printf("删除元素后的顺序表: ");
    printList(&L);

    int element = 20;
    int position = searchList(&L, element);
    if (position!= -1) {
        printf("%d 在顺序表中的位置是: %d\n", element, position);
    } else {
        printf("%d 不在顺序表中\n", element);
    }

    return 0;
}

顺序存储特点：

  1. 随机访问：可以在 O(1) 的时间复杂度内通过下标直接访问任意元素。

  2. 存储密度高：不需要额外的指针来表示元素之间的逻辑关系，因此存储密度高。

但也存在一些缺点：

  1. 插入和删除操作效率低：在进行插入和删除操作时，可能需要移动大量的元素，时间复杂度为 O(n) 。

  2. 存储空间大小固定：在初始化时需要预先分配固定大小的存储空间，如果空间不足需要重新分配更大的空间并进行数据迁移。

链式存储：

 链式存储是一种数据存储方式，其中数据元素通过指针链接在一起，形成一个链表结构。

在链式存储中，每个数据元素所在的存储单元称为节点（Node）。节点通常由两部分组成：

  1. 数据域：用于存储数据元素的具体信息。

  2. 指针域：用于存储指向下一个节点的地址或指针。

通过这种指针的连接，使得链表中的节点可以按照一定的顺序依次访问。

单链表（Singly Linked List）是链表的一种常见形式。

单链表的特点包括：

  1. 节点的链接是单向的，即每个节点只能通过指针指向下一个节点，而不能指向前一个节点。

  2. 要访问链表中的某个节点，必须从表头节点开始，沿着指针依次遍历。

  3. 插入和删除操作相对简单，只需修改相关节点的指针即可，但在特定位置插入或删除时，需要先找到目标位置。

  4. 不能像顺序表那样进行随机访问，只能顺序访问。

单链表的基本操作实现：

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

// 单链表节点结构体
typedef struct ListNode {
    int data;
    struct ListNode *next;
} ListNode;

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

// 在表头插入节点
void insertAtHead(ListNode** head, int data) {
    ListNode* newNode = createNode(data);
    newNode->next = *head;
    *head = newNode;
}

// 在指定位置插入节点
void insertAtIndex(ListNode* head, int index, int data) {
    if (index < 0) {
        printf("插入位置不合法\n");
        return;
    }

    ListNode* newNode = createNode(data);
    if (index == 0) {
        newNode->next = head;
        head = newNode;
        return;
    }

    ListNode* curr = head;
    int count = 0;

    while (curr!= NULL && count < index - 1) {
        curr = curr->next;
        count++;
    }

    if (curr == NULL) {
        printf("插入位置超出链表长度\n");
        return;
    }

    newNode->next = curr->next;
    curr->next = newNode;
}

// 删除指定节点
void deleteNode(ListNode** head, int data) {
    ListNode* curr = *head;
    ListNode* prev = NULL;

    while (curr!= NULL) {
        if (curr->data == data) {
            if (prev == NULL) {
                *head = curr->next;
            } else {
                prev->next = curr->next;
            }
            free(curr);
            return;
        }
        prev = curr;
        curr = curr->next;
    }

    printf("未找到要删除的数据\n");
}

// 打印链表
void printList(ListNode* head) {
    ListNode* curr = head;
    while (curr!= NULL) {
        printf("%d ", curr->data);
        curr = curr->next;
    }
    printf("\n");
}

// 释放链表内存
void freeList(ListNode* head) {
    ListNode* curr = head;
    ListNode* temp;

    while (curr!= NULL) {
        temp = curr;
        curr = curr->next;
        free(temp);
    }
}

int main() {
    ListNode* head = NULL;

    insertAtHead(&head, 10);
    insertAtHead(&head, 20);
    insertAtIndex(head, 1, 15);

    printf("链表: ");
    printList(head);

    deleteNode(&head, 20);

    printf("删除元素后的链表: ");
    printList(head);

    freeList(head);

    return 0;
}

双链表（Doubly Linked List）是链表的一种变体。

在双链表中，每个节点不仅有指向下一个节点的指针（称为“后继指针”），还有指向前一个节点的指针（称为“前驱指针”）。

双链表的特点包括：

  1. 可以双向遍历，既可以从表头向表尾遍历，也可以从表尾向表头遍历。

  2. 插入和删除操作在某些情况下比单链表更方便，因为不需要像单链表那样为了找到前一个节点而进行遍历。

  3. 由于每个节点需要额外存储一个指针，所以空间复杂度相对单链表略高

 以下是用 C 语言实现双链表节点的结构和一些基本操作（创建、插入、删除、遍历等）的示例代码：

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

// 双链表节点结构体
typedef struct DoublyListNode {
    int data;
    struct DoublyListNode *prev;
    struct DoublyListNode *next;
} DoublyListNode;

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

// 在表头插入节点
void insertAtHead(DoublyListNode** head, int data) {
    DoublyListNode* newNode = createDoublyNode(data);
    if (*head == NULL) {
        *head = newNode;
        return;
    }
    newNode->next = *head;
    (*head)->prev = newNode;
    *head = newNode;
}

// 在表尾插入节点
void insertAtTail(DoublyListNode** head, int data) {
    DoublyListNode* newNode = createDoublyNode(data);
    if (*head == NULL) {
        *head = newNode;
        return;
    }
    DoublyListNode* curr = *head;
    while (curr->next!= NULL) {
        curr = curr->next;
    }
    curr->next = newNode;
    newNode->prev = curr;
}

// 在指定位置插入节点
void insertAtIndex(DoublyListNode* head, int index, int data) {
    if (index < 0) {
        printf("插入位置不合法\n");
        return;
    }

    DoublyListNode* newNode = createDoublyNode(data);
    if (index == 0) {
        insertAtHead(&head, data);
        return;
    }

    DoublyListNode* curr = head;
    int count = 0;

    while (curr!= NULL && count < index) {
        curr = curr->next;
        count++;
    }

    if (curr == NULL) {
        printf("插入位置超出链表长度\n");
        return;
    }

    newNode->prev = curr->prev;
    newNode->next = curr;
    curr->prev->next = newNode;
    curr->prev = newNode;
}

// 删除指定节点
void deleteNode(DoublyListNode** head, int data) {
    DoublyListNode* curr = *head;

    while (curr!= NULL) {
        if (curr->data == data) {
            if (curr->prev == NULL) {
                *head = curr->next;
                if (*head!= NULL) {
                    (*head)->prev = NULL;
                }
            } else if (curr->next == NULL) {
                curr->prev->next = NULL;
            } else {
                curr->prev->next = curr->next;
                curr->next->prev = curr->prev;
            }
            free(curr);
            return;
        }
        curr = curr->next;
    }

    printf("未找到要删除的数据\n");
}

// 正向遍历打印链表
void printForward(DoublyListNode* head) {
    DoublyListNode* curr = head;
    while (curr!= NULL) {
        printf("%d ", curr->data);
        curr = curr->next;
    }
    printf("\n");
}

// 反向遍历打印链表
void printBackward(DoublyListNode* head) {
    DoublyListNode* curr = head;
    while (curr->next!= NULL) {
        curr = curr->next;
    }
    while (curr!= NULL) {
        printf("%d ", curr->data);
        curr = curr->prev;
    }
    printf("\n");
}

// 释放链表内存
void freeList(DoublyListNode* head) {
    DoublyListNode* curr = head;
    DoublyListNode* temp;

    while (curr!= NULL) {
        temp = curr;
        curr = curr->next;
        free(temp);
    }
}

int main() {
    DoublyListNode* head = NULL;

    insertAtHead(&head, 10);
    insertAtHead(&head, 20);
    insertAtTail(&head, 30);
    insertAtIndex(head, 1, 15);

    printf("正向遍历链表: ");
    printForward(head);

    printf("反向遍历链表: ");
    printBackward(head);

    deleteNode(&head, 20);

    printf("删除元素后的正向遍历链表: ");
    printForward(head);

    freeList(head);

    return 0;
}

循环链表（Circular Linked List）是另一种特殊的链表结构。

它分为两种类型：

  1. 单循环链表：尾节点的指针不是指向 NULL ，而是指向头节点，从而形成一个环形结构。这样就可以从任何一个节点开始，顺着指针遍历整个链表。

  2. 双循环链表：不仅尾节点指向头节点，头节点也指向尾节点，同时每个节点的前驱指针和后继指针也形成了循环。

循环链表的特点包括：

  1. 可以实现从任何节点开始的遍历，无需特殊处理表头和表尾。

  2. 在某些应用中，如环形缓冲区、约瑟夫环问题等，能更方便地进行操作。

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

// 单循环链表节点结构体
typedef struct CircularListNode {
    int data;
    struct CircularListNode *next;
} CircularListNode;

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

// 在表头插入节点
void insertAtHead(CircularListNode** head, int data) {
    CircularListNode* newNode = createCircularNode(data);
    if (*head == NULL) {
        *head = newNode;
        newNode->next = *head;
        return;
    }
    CircularListNode* curr = *head;
    while (curr->next!= *head) {
        curr = curr->next;
    }
    newNode->next = *head;
    curr->next = newNode;
    *head = newNode;
}

// 删除指定节点
void deleteNode(CircularListNode** head, int data) {
    if (*head == NULL) {
        printf("链表为空，无法删除\n");
        return;
    }

    CircularListNode* curr = *head;
    CircularListNode* prev = NULL;

    do {
        if (curr->data == data) {
            if (curr == *head) {
                *head = (*head)->next;
            }
            prev->next = curr->next;
            free(curr);
            return;
        }
        prev = curr;
        curr = curr->next;
    } while (curr!= *head);

    printf("未找到要删除的数据\n");
}

// 打印链表
void printList(CircularListNode* head) {
    if (head == NULL) {
        printf("链表为空\n");
        return;
    }

    CircularListNode* curr = head;
    do {
        printf("%d ", curr->data);
        curr = curr->next;
    } while (curr!= head);
    printf("\n");
}

// 释放链表内存
void freeList(CircularListNode* head) {
    if (head == NULL) {
        return;
    }

    CircularListNode* curr = head;
    CircularListNode* temp;

    do {
        temp = curr;
        curr = curr->next;
        free(temp);
    } while (curr!= head);
}

int main() {
    CircularListNode* head = NULL;

    insertAtHead(&head, 10);
    insertAtHead(&head, 20);
    insertAtHead(&head, 30);

    printf("循环链表: ");
    printList(head);

    deleteNode(&head, 20);

    printf("删除元素后的循环链表: ");
    printList(head);

    freeList(head);

    return 0;
}

 

静态链表（Static Linked List）是用数组来模拟链表的一种数据结构。

在静态链表中，数组的每个元素包含两个部分：数据域和游标（类似于指针）。游标用于指示下一个元素在数组中的位置。

静态链表的特点包括：

  1. 利用了数组的连续存储特性，同时模拟了链表的动态插入和删除操作。

  2. 不需要频繁地进行内存的分配和释放，适用于不支持指针操作或者内存管理较为复杂的场景。

  3. 但是，由于数组大小固定，可能存在空间浪费的情况。

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

#define MAX_SIZE 100  // 静态链表的最大长度

typedef struct {
    int data;
    int cur;  // 游标，指向下一个节点在数组中的位置
} StaticListNode;

// 初始化静态链表
void initStaticList(StaticListNode list[], int *available) {
    for (int i = 0; i < MAX_SIZE - 1; i++) {
        list[i].cur = i + 1;
    }
    list[MAX_SIZE - 1].cur = 0;  // 链表结束标志

    *available = 1;  // 空闲链表头指针
}

// 从备用空间获取一个节点
int mallocStaticList(StaticListNode list[], int *available) {
    int i = *available;
    if (*available) {
        *available = list[*available].cur;
    }
    return i;
}

// 回收节点到备用空间
void freeStaticList(StaticListNode list[], int *available, int k) {
    list[k].cur = *available;
    *available = k;
}

// 插入元素到静态链表
void insertStaticList(StaticListNode list[], int *head, int element) {
    int i = mallocStaticList(list, available);  // 获取空闲节点
    if (i) {
        list[i].data = element;
        list[i].cur = list[*head].cur;  // 新节点指向原表头节点指向的节点
        list[*head].cur = i;  // 表头节点指向新节点
    } else {
        printf("存储空间不足，无法插入!\n");
    }
}

// 打印静态链表
void printStaticList(StaticListNode list[], int head) {
    int p = list[head].cur;
    while (p) {
        printf("%d ", list[p].data);
        p = list[p].cur;
    }
    printf("\n");
}

int main() {
    StaticListNode list[MAX_SIZE];
    int available;
    int head = 0;  // 初始化表头

    initStaticList(list, &available);

    insertStaticList(list, &head, 10);
    insertStaticList(list, &head, 20);
    insertStaticList(list, &head, 30);

    printf("静态链表: ");
    printStaticList(list, head);

    return 0;
}

 

爱吃冰西瓜₍˄·͈༝·͈˄*₎◞
关注
  • 9
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
第二章 线性表
icepointLine的专栏
07-16 786
第二章   线性表 一、线性表及其逻辑特征 1.线性表定义   (1)线性表简称表，是n个具有相同类型的数据元素的有限序列,L=(a1,a2,……an)   (2)线性表中数据元素的个数称为线性表的长度   (3)长度为0的线性表称为空表   (4)线性表是一种最基本、最简单的数据结构，数据元素之间仅具有单一的前驱和后继关系，且每个元素最多只有一个前驱和一个后继 2.线性表的逻辑特征
第二章 线性表
kiki天朗晴空的博客
08-11 531
线性表三点： 顺序表 链表 表的合并
第二章 线性表（链表）
m0_49655454的博客
07-20 834
链表的基本操作（增删改查）
数据结构（C语言版） 第二章 线性表 知识梳理+作业习题详解
热门推荐
繁凡さん的博客
04-29 6万+
单链表顺序存储结构 单链表强调元素在逻辑上紧密相邻，所以首先想到用数组存储。但是普通数组有着无法克服的容量限制，在不知道输入有多少的情况下，很难确定出一个合适的容量。对此，一个较好的解决方案就是使用动态数组。首先用malloc申请一块拥有指定初始容量的内存，这块内存用作存储单链表元素，当录入的内容不断增加，以至于超出了初始容量时，就用calloc扩展内存容量，这样就做到了既不浪费内存，又可以让单链...
《数据结构》第二章线性表习题.doc
12-01
"《数据结构》第二章线性表习题" 本资源摘要信息对应的知识点主要涉及到数据结构的第二章线性表习题，包括线性表的定义、链式存储、顺序存储、单链表、双向循环链表、栈和队列等概念。 一、线性表的定义 线性表是...
《数据结构》第二章线性表习题.pdf
09-30
《数据结构》第二章线性表习题 本资源是《数据结构》第二章线性表习题，涵盖了线性表的基本概念、顺序表和链表的存储结构、线性表的操作等知识点。 一、线性表的基本概念 线性表是一种有限序列，可以为空或不为空...
第二章线性表1
08-03
在线性表中，每个元素都有其特定的位置，第一个元素被称为表头，最后一个元素被称为表尾。除了第一个元素，每个元素都有且只有一个直接前驱；同样，除了最后一个元素，每个元素都有且仅有一个直接后继。这种关系使得...
第二章 线性表.md
05-14
第二章 线性表.md
第二章 线性表.docx
11-09
线性表是数据结构中的一种重要类型，是指一组数据元素的集合，其中每个元素都有一个直接前驱和后继，除第一个元素只有直接后驱和最后一个元素只有一个前驱外。线性表的存储结构有顺序存储和链式存储两种。 一、顺序...
【数据结构-前缀哈希】力扣1124. 表现良好的最长时间段
sjsjs11的博客
08-14 390
表现良好的时间段”有两种情况，一种是当前的sum能在哈希表中匹配到sum - 1时（如果是匹配sum的话，这个子段是「劳累的天数」等于「不劳累的天数」。这一题前缀+哈希并不是空间最优，最优空间是使用贪心+栈的做法，虽然空间复杂度都是O(n)，但是实际的空间使用可能高于 O(n)，因为当哈希表需要扩展时，会预留更多的空间以减少哈希冲突。所谓「表现良好的时间段」，意味在这段时间内，「劳累的天数」是严格 大于「不劳累的天数」。输入：hours = [9,9,6,0,6,6,9]
笔记分享: 香港中文大学CSCI5610高级数据结构——最邻近查询
最新发布
qq_64091900的博客
08-18 495
香港中文大学CSCI5610高级数据结构
链表 19.删除链表的倒数第N个节点 双指针
qq_64633597的博客
08-14 203
return head 和return dummy.next 的区别，若删除的是头节点，则头节点还需要更新，题目中给的头节点就不能用了。而dummy作为虚拟头节点，永远是头节点的上一位，即使head发生变化，仍然是dummy.next。fast走n+1步，是为了和slow保持n+1个位置，此时fast移动至空节点，slow与fast位置差n+1节点，那slow再往后移动一位，就是需要删除的倒数第n个节点，即目标节点。倒数第几个，翻过来看即正数第几个。
数据结构之排序（下）
qq_74336191的博客
08-15 636
​ 嗨！小伙伴们，咱们又见面啦，在上一篇数据结构之排序（上）中，我们学习了直接插入排序、冒泡排序和希尔排序，今天我们继续学习排序这一块，准备好了吗？Ready Go ! ! ! ​
数据结构——二叉树
2301_80373479的博客
08-16 1403
轻松学会二叉树
线性表【双向循环链表基本定义与操作】（带头结点）
2401_82676816的博客
08-14 1228
双向循环链表的结构与双向链表完全一致，不同之处在于它的尾结点的next指针指向头结点，而头结点的prior指针指向尾结点，从而形成一个循环。//1.双向循环链表的结构定义（与双向链表完全一致）// 数据域//前驱和后继指针//HNode * 用来定义结点指针//HLinkList 用来定义链表指针。
uva1586分子量（Molar Mass,ACM/ICPC Danang 2007）
2301_80844586的博客
08-14 266
然后代码具体要考虑i++每次进行i++自动i++这样避免算完字母后碰到数字然后会多算一次字母。就是一位算数字后i++如果【i+2】就是匹配到两位数的话再次i++；这样可以有效避免数字越界（你可以好好思考一下）如果都没有就是1直接定义1即可。第一个是有四个字母然后把for循环中匹配到的字母进行确认到z里面后面进行。第二的大逻辑就行下面的if那个三大判断条件第一个是一位数并且是。也是改了小两天，然后说一下核心代码逻辑两大块的核心。就是没有数字的就是1的。
Codeforces Round 965 (Div. 2)
HKUST_ZJH的博客
08-14 1222
Codeforces Round 965 (Div. 2)
1223. 汉诺塔的移动次数
weixin_72786722的博客
08-13 299
汉诺塔的问题大家都已经很熟悉了，有三个柱子，每个柱子上有一些大小不一的金片，要把金片从 AA柱移动到 CC柱，可以借助 B 柱，请问 n个金片的情况下，需要最少移动多少次？输入一个整数 nn 代表金片的数量（n≤20）。一个整数，代表 n 个金片的移动次数。
数据结构第二章线性表
10-10
线性表是数据结构中最简单且常用的一种数据结构，它是由同类型的数据元素构成的有序序列。线性表具有以下特点： 1. 元素之间存在顺序关系，即元素在表中的位置是唯一确定的。 2. 线性表中的元素类型可以相同也可以不同。 3. 线性表的大小可以动态变化。 线性表的实现方式有多种，常见的包括数组和链表。 数组是一种连续存储结构，线性表中的元素在内存中占据一段连续的空间。通过下标来访问元素，具有随机访问的特性，但插入和删除操作可能需要移动大量元素。 链表是一种离散存储结构，线性表中的元素在内存中分散存储，每个元素都包含指向下一个元素的指针。插入和删除操作只需改变指针指向，但访问元素需从头节点开始遍历。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

爱吃冰西瓜₍˄·͈༝·͈˄*₎◞

感谢鼓励

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值