数据结构与算法 —— 表

已于 2024-08-20 17:03:26 修改
阅读量486 收藏 4
点赞数 6
分类专栏： 数据结构 文章标签： 数据结构 c语言 链表
于 2024-08-20 17:01:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_71421536/article/details/141359130
版权

一. 引言

表是一种线性数据结构，其中的元素按照一定的顺序排列。每个元素在表中有一个唯一的位置，称为索引（Index）。表中的元素可以是任意类型的数据，如整数、字符、字符串或其他复杂数据结构。

二. 表的基本概念

  • 元素（Element）：在数据表中，每一个独立的数据项都被称作一个元素。
  • 序号（Index）：为了标识和定位，表中的每一个元素都被赋予一个非负整数作为其在表中的位置标识，该整数通常从0开始计数。
  • 前驱（Predecessor）：在数据表的序列中，如果元素a1位于元素a2之前，那么我们称a1为a2的前驱。
  • 后继（Successor）：相对地，如果元素a3紧随元素a2之后出现在数据表中，那么a3就被称为a2的后继。

在表中，每个元素有唯一的前驱后继（第一个元素或最后一个元素除外）

三. 线性表

1.定义

线性表，顾名思义，是由相同数据类型的n（n≥0）个数据元素构成的有限序列。这里的n代表着线性表的长度，用以衡量线性表中所包含元素的数量。当n等于0时，线性表便成为了一个空表，意味着它不包含任何元素。

在描述线性表时，我们通常用字母L来表示，其结构可以表达为L=(a1, a2, …, an)，其中每个元素ai都是线性表中的一个组成部分。这些元素属于相同的类型，因此它们在内存中所占用的空间大小一致。

线性表具有以下特性：

  • 有限性：线性表中的元素数量是有限的，不是无限延伸的。
  • 有序性：线性表中的元素按照一定的顺序排列，这种顺序是固定的，不是随机的。

在线性表中，每个元素ai都有一个明确的位序，用以标识其在表中的位置。位序是从1开始的，这意味着线性表的第一个元素a1具有位序1，而最后一个元素an则具有位序n。

具体来说，线性表的结构如下：

  • 表头元素：a1，它是线性表中的第一个元素，没有直接前驱。
  • 中间元素：除了a1之外，每个元素都有一个直接前驱，即每个元素除了第一个元素之外，都有一个在它之前的元素。
  • 表尾元素：an，它是线性表中的最后一个元素，没有直接后继。

这种有序排列的特性使得线性表成为数据处理和存储的基本结构之一，广泛应用于各种算法和数据结构的实现中。

2.特点

基于数组实现的线性表在进行以下操作时的时间复杂度为：

索引查找

O(1)

任意位置插入

O(n)

查找值

O(n)

删除

O(n)

从这个图中可以看出，对于顺序存储的线性表（如数组），访问、插入、删除等操作的时间复杂度通常较低，尤其是访问操作，时间复杂度为O(1)。这使得线性表在处理大量数据时具有较高的效率。

3.线性表的实现

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

typedef struct list
{
    //数据 - 数组
    int *data;
    //容量 - 数组容量
    int capacity;
    //大小
    int size;
}List;

void init(List *l, int n);
void add(List *l, int n);
void show(List *l);
void insert(List *l, int index, int n);
void incr(List *l);
int get(List *l, int index);//查找值
int find(List *l, int n);//查找索引
void delete(List *l, int index);
bool empty(List *l);
void clear(List *l);


int main(int argc, char const *argv[])
{
    List *li = malloc(sizeof(struct list));
    //初始化
    init(li, 3);
    //添加
    add(li, 100);
    add(li, 200);
    add(li, 300);
    add(li, 400);
    add(li, 500);

    add(li, 600);
    add(li, 700);
    show(li);
    insert(li, 3, 2000);
    show(li);
    get(li, 3);
    find(li, 300);

    delete(li, 5);
    show(li);
    empty(li);
    //显示
    show(li);
    clear(li);
    show(li);
    return 0;
}

void init(List *l, int n)
{
    l->capacity = n;
    l->size = 0;
    l->data = malloc(sizeof(int) * n);
}

void add(List *l, int n)
{
    if (l->size == l->capacity)
    {
        incr(l);
    }
    l->data[l->size] = n;
    l->size++;
}

void show(List *l)
{
    for(size_t i = 0; i < l->size; i++)
    {
        printf("[%ld] = %d,", i, l->data[i]);
    }
    printf("\n");
}

void insert(List *l, int index, int n)
{
    //边界
    if (index > l->size)
    {
        return ;
    }
    
    if (l->size == l->capacity)
    {
        incr(l);
    }
    for (size_t i = l->size - 1; i >= index; i--)
    {
        l->data[i + 1] = l->data[i];
    }
    l->data[index] = n;
    l->size++;
}

void incr(List *l)
{
    //增量
    // l->capacity *= 2;
    //l->data = realloc(l->data, sizeof(int) * l->capacity);
    int incr = l->capacity >> 1;
    //右移一位 变成一半
    l->capacity += incr;
    //扩容
    l->data = realloc(l->data, sizeof(int) * l->capacity); 
    printf("扩容至%d\n", l->capacity);
    
}

int get(List *l, int index)
{
    if (index > l->size)
    {
        return -1;
    }
    printf("%d 对应的值是%d\n",index, l->data[index]);
}

int find(List *l, int n)
{
    for (size_t i = 0; i < l->size; i++)
    {
        if (l->data[i] == n)
        {
            printf("%d对应的索引为%ld\n", n, i);
        }
    }

    
}

void delete(List *l, int index)
{
    if (index > l->size - 1)
    {
        printf("该索引不存在\n");
        return;
    }
    for (size_t i = index; i <= l->size - 1; i++)
    {
        l->data[i] = l->data[i + 1];
    }
    l->size--;
}
bool empty(List *l)
{
    if (l->size > 0)
    {
        printf("不是空的\n");
    }
    return true;
    
}
void clear(List *l)
{
    l->data = 0;
    free(l->data);
    l->size = 0;
}

这段代码实现了如何通过数组实现线性表的基本操作，包括添加、删除、查找、显示和初始化等。

功能：

  1. 初始化列表：init 函数用于初始化列表，包括分配内存、设置列表的容量和当前大小。默认容量为 n，初始大小为0。

  2. 添加元素：add 函数用于在列表末尾添加元素。如果列表已满，会调用 incr 函数进行扩容。每次添加后，列表大小增加1。

  3. 显示列表：show 函数用于打印列表中的所有元素，按索引顺序显示。

  4. 插入元素：insert 函数允许在指定索引处插入一个元素。如果列表已满，会进行扩容。插入操作会将列表中的元素向后移动以腾出空间。

  5. 扩容：incr 函数通过增加列表容量的一半来实现扩容，然后重新分配内存以扩展列表的大小。

  6. 获取元素值：get 函数用于获取指定索引处的元素值。如果索引超出范围，返回-1。

  7. 查找元素索引：find 函数遍历列表，查找指定元素的索引，并打印结果。如果元素不存在，则不打印任何内容。

  8. 删除元素：delete 函数允许删除指定索引处的元素。元素删除后，后面的元素会向前移动填充空位，列表大小减1。

  9. 检查列表是否为空：empty 函数检查列表是否为空。如果列表大小大于0，则返回 false，表示列表不是空的。

  10. 清空列表：clear 函数将列表的数据指针设置为0，释放当前分配的内存，并将列表大小设置为0，从而清空列表。

在 main 函数中，创建了一个列表实例并初始化了容量为3。然后，连续添加了6个元素，并显示了列表内容。接着，插入了一个元素，显示了更新后的列表。使用 get 函数获取了指定索引处的元素值，使用 find 函数查找了元素索引。删除了一个元素，再次显示了列表内容，并检查了列表是否为空。最后，清空了列表，并再次显示了空列表。

四.链表

1.定义

链表（Linked List）是一种线性数据结构，其中的数据元素不是直接存储在连续的内存位置，而是通过指针相互连接。每个数据元素称为节点，每个节点包含两部分：数据域（用来存储数据）和指针域（指向下一个节点的地址）。

链表的主要类型有以下几种：

  1. 单链表（Singly Linked List）：每个节点包含一个数据元素和一个指向下一个节点的指针。单链表只能从头部开始遍历，因为每个节点只知道其下一个节点的位置。

  2. 双链表（Doubly Linked List）：每个节点包含数据元素、一个指向下一个节点的指针和一个指向前一个节点的指针。双链表允许双向遍历，即能够从头部或尾部开始遍历。

  3. 循环链表（Circular Linked List）：最后一个节点的指针指向链表的第一个节点，形成一个循环。这使得从任意节点开始都可以遍历整个链表。

2.特点

链表是一种灵活的存储结构，其关键特征在于数据元素以链的形式组织，无需连续的内存空间。这种设计使得链表能够动态分配存储空间，非常适合元素频繁插入和删除的情况。链表的每个节点包含数据和指向下一个节点的指针，形成一条链。

3.实现

1.单向链表

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


typedef struct node
{
    int data;
    struct node* next;
}Node;

// typedef struct node* List;
typedef struct list
{
    Node* head;
    int size;
}List;

void init(List *l);
void add(List *l, int data);
void display(List *l);
void insert(List *l, int data, int index);
void delete(List *l, int index);
void find(List *l, int index);
void clear(List *l);
int size(List *l);


int main(int argc, char const *argv[])
{
    // Node *head = malloc(sizeof(Node));

    // Node n1;
    // Node n2;
    // Node n3;

    // n1.data = 100;
    // n2.data = 200;
    // n3.data = 300;

    // head->next = &n1;
    // n1.next = &n2;
    // n3.next = NULL;

    //创建
    List *link = malloc(sizeof(List));
    //初始化
    init(link);
    //添加
    add(link, 100);
    add(link, 200);
    add(link, 300);
    //显示
    display(link);
    delete(link,2);
    display(link);
    return 0;
}

void init(List *l)
{
    l->head = malloc(sizeof(Node));
    l->head->next = NULL;
    l->size = 0;
}

void add(List *l, int data)
{
    // Node node = {data, NULL};
    Node *node = malloc(sizeof(Node));
    node->data = data;
    node->next = NULL;

    if (l->head->next == NULL)
    {
        //链表为空链表
        l->head->next = node;
    }
    else
    {
        // //头插法
        // node->next = l->head->next;
        // l->head->next = node;
        //尾插法
        Node *n = l->head;
        while (n->next != NULL)
        {
            n = n->next;
        }
        n->next = node;
    }
    l->size++;
}

void display(List *l)
{
    Node *n = l->head->next;
    while (n != NULL)
    {
        printf("%d,", n->data);
        n = n->next; 
    }
    printf("\n");
}

void delete(List *l, int index)
{
    Node *prev = l->head;
    for (size_t i = 0; i < index; i++)
    {
        prev = prev->next;
    }
    Node *n = prev->next;
    prev->next = n->next;
    l->size--;
    free(n);
    
}

void insert(List *l, int data, int index)
{
    Node *prev = l->head;
    for (size_t i = 0; i < index; i++)
    {
        prev = prev->next;
    }

    Node *n = prev->next;
    Node *node = malloc(sizeof(Node));

    node->data = data;
    node->next = n;
    
    l->size++;
    free(n);
}
void find(List *l, int index);
void clear(List *l);
int size(List *l);

实现了如何通过链表结构在动态内存中存储数据，并实现基本的操作。链表相比于数组，更灵活地适应了元素频繁插入和删除的需求，但访问元素时需要遍历链表，时间复杂度为O(n)。

  •  初始化 (init)

初始化函数创建链表的头节点，并将其next指针设置为NULL。同时，初始化链表的大小为0。

  • 添加 (add)

添加函数接收一个整数值和链表指针作为参数。如果链表为空，直接将新节点添加到头节点的next指针处。如果链表非空，则在链表末尾添加新节点。

  • 显示 (display)

显示函数遍历链表，打印每个节点的数据。从头节点的next指针开始，直到链表末尾。

  • 删除 (delete)

删除函数接收一个索引作为参数。根据索引找到需要删除的节点的前一个节点，然后更新前一个节点的next指针，跳过被删除的节点。最后释放被删除节点的内存。

  • 插入 (insert)

插入函数接收一个整数值、链表指针和一个索引作为参数。根据索引找到插入位置的前一个节点，创建新节点，并将其插入到该位置。

  • 查找 (find)

查找函数接收一个索引作为参数。遍历链表，查找指定索引处的节点。如果找到，打印节点数据；否则，打印找不到的提示。

  •  清空 (clear)

清空函数释放链表中的所有节点内存，并将链表大小设置为0。

  • 获取链表大小 (size)

获取链表大小的函数返回链表中节点的数量。

  • 主函数 (main)

在main函数中，首先创建了一个链表实例，并初始化了头节点和链表大小。然后，连续添加了三个元素，并显示了链表内容。接着，删除了索引为2的元素，并再次显示了链表内容。

2.双向链表

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

typedef struct node
{
    int data;
    struct node *prev;//前驱
    struct node *next;//后继
}Node;

//一个指针
//typedef struct node link;

//两个指针
typedef struct list
{
    int size;//大小
    struct node *head;//头指针
    struct node *tail;//尾指针
}List;

void init(List *l);
void add(List *l, int value);
void display(List *l);
void insert(List *l, int index, int value);
void delete(List *l, int index);
int get(List *l, int index);
int find(List *l, int value);
int size(List *l);
void clear(List *l);


int main(int argc, char const *argv[])
{
    List *l = malloc(sizeof(Node));
    init(l);
    add(l,1000);
    add(l,2000);
    add(l,8888);
    add(l,3000);
    add(l,8888);
    add(l,8888);

    display(l);

    insert(l,2,1234);

    display(l);
    
    delete(l,1);
    display(l);
    get(l,3);
    find(l, 8888);
    size(l);
    clear(l);
    display(l);
    return 0;
}


void init(List *l)
{
    l->size = 0;
    l->head = malloc(sizeof(Node));
    l->tail = malloc(sizeof(Node));
    l->head->next = l->tail;
    l->tail->prev = l->head;
}

void add(List *l, int value)
{
    Node *n = malloc(sizeof(Node));
    n->data = value;

    n->prev = l->tail->prev;
    l->tail->prev->next = n;

    n->next = l->tail;
    l->tail->prev = n;
    
    l->size++;
}

void display(List *l)
{
    Node *n = malloc(sizeof(Node));
    n = l->head;
    for (size_t i = 0; i < l->size; i++)
    {
        n = n->next;
        printf("[%ld] = %d,", i, n->data);
    }
    printf("\n");
    
}
void insert(List *l, int index, int value)
{
    if (index < 0 || index > l->size)
    {
        printf("索引错误\n");
        return ;
    }
    
    Node *n = malloc(sizeof(Node));
    n->data = value;
    if (l->size == 0)
    {
        n->prev = l->head;
        l->head->next = n;

        n->next = l->tail;
        l->tail->prev = n;
    }
    else if(l->size == index)
    {
        n->prev = l->tail->prev;
        l->tail->prev->next = n;

        n->next = l->tail;
        l->tail->prev = n;
    }
    else
    {
        Node *newnode = malloc(sizeof(Node));
        newnode = l->head->next;
        for (size_t i = 0; i < index; i++)
        {
            newnode = newnode->next;
        }
        n->prev = newnode->prev;
        newnode->prev->next = n;

        n->next = newnode;
        newnode->prev = n;
        
    }
    l->size++;
}

void delete(List *l, int index)
{
    Node *newnode = malloc(sizeof(Node));
    newnode = l->head->next;
    for (size_t i = 0; i < index; i++)
    {
        newnode = newnode->next;
    }
    newnode->prev->next = newnode->next;
    newnode->next->prev = newnode->prev;
    l->size--; 
    free(newnode);
}

int get(List *l, int index)
{
    Node *newnode = malloc(sizeof(Node));
    newnode = l->head->next;
    for (size_t i = 0; i < index; i++)
    {
        newnode = newnode->next;
    }
    printf("[%d] = %d\n", index, newnode->data);
    return 0;
}

int find(List *l, int value)
{
    Node *newnode = malloc(sizeof(Node));
    newnode = l->head;
    for (size_t i = 0; i < l->size; i++)
    {
        newnode = newnode->next;
        if (newnode->data == value)
        {
            printf("%d对应的索引为%ld\n", value, i);
        }
    }
    return 0;
}
int size(List *l)
{
    printf("size = %d\n", l->size);
    return 0;
}
void clear(List *l)
{
    l->size = 0;
    free(l->head);
}

实现了如何通过双向链表结构在动态内存中存储数据，并实现基本的操作。双向链表相比于单向链表，更灵活地适应了元素频繁插入和删除的需求，但访问元素时需要遍历链表，时间复杂度为O(n)。

  • 1初始化 (init)

初始化函数创建链表的头节点和尾节点，并将它们相互连接。同时，初始化链表的大小为0。

  •  添加 (add)

添加函数接收一个整数值和链表指针作为参数。创建一个新节点，并将其插入到链表的末尾。更新相关节点的prev和next指针，以保持链表的完整性。

  •  显示 (display)

显示函数遍历链表，打印每个节点的数据。从头节点的next指针开始，直到链表末尾。

  • 插入 (insert)

插入函数接收一个整数值、链表指针和一个索引作为参数。根据索引找到插入位置的前一个节点，创建新节点，并将其插入到该位置。更新相关节点的prev和next指针，以保持链表的完整性。

  •  删除 (delete)

删除函数接收一个索引作为参数。根据索引找到需要删除的节点，更新前一个节点和后一个节点的prev和next指针，跳过被删除的节点。最后释放被删除节点的内存。

  •  获取 (get)

获取函数接收一个索引作为参数。遍历链表，查找指定索引处的节点。如果找到，打印节点数据；否则，打印找不到的提示。

  • 查找 (find)

查找函数接收一个整数值作为参数。遍历链表，查找包含该值的节点。如果找到，打印节点索引；否则，打印找不到的提示。

  • 获取链表大小 (size)

获取链表大小的函数返回链表中节点的数量。

  • 清空 (clear)

清空函数释放链表中的所有节点内存，并将链表大小设置为0。

  • 主函数 (main)

在main函数中，首先创建了一个链表实例，并初始化了头节点和尾节点。然后，连续添加了多个元素，并显示了链表内容。接着，插入了索引为2的元素，删除了索引为1的元素，并再次显示了链表内容。使用get函数获取了指定索引处的元素值，使用find函数查找了元素索引。最后，清空了链表，并再次显示了空链表。

3.循环链表

循环链表，顾名思义就是就是是一个环，比如：

在单向链表中，链表的最后一个元素的next指向表头head，这样就形成了一个环；

而在双向链表中，就是表头head 的前驱prev 是表尾tail，而表尾的tail的后继next是表头head就形成了一个环。

经典题目

在循环链表中有一个很经典的题目，如何判断一个链表中是否有环？

这个题目可以使用到快慢指针法，顾名思义，就是一个指针移动快，一个移动慢，如果链表中有环，那么最后这个快指针一定会追上慢指针，这就是快慢指针法。

代码实现：

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

typedef struct node {
    int data;
    struct node *next;
} Node;

// 判断链表是否有环
int hasCycle(Node *head) {
    if (head == NULL || head->next == NULL) {
        return 0; // 链表为空或只有一个节点，不可能有环
    }

    Node *slow = head;
    Node *fast = head->next;

    while (slow != fast) {
        if (fast == NULL || fast->next == NULL) {
            return 0; // 快指针到达链表末尾，没有环
        }
        slow = slow->next;          // 慢指针每次移动一步
        fast = fast->next->next;    // 快指针每次移动两步
    }

    return 1; // 快指针追上慢指针，说明有环
}

// 创建新节点
Node* createNode(int data) {
    Node *newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

int main() {
    // 创建一个有环的链表
    Node *head = createNode(1);
    head->next = createNode(2);
    head->next->next = createNode(3);
    head->next->next->next = createNode(4);
    head->next->next->next->next = head->next; // 创建环

    if (hasCycle(head)) {
        printf("链表中有环\\n");
    } else {
        printf("链表中没有环\\n");
    }

    return 0;
}

通过上述代码，我们可以判断一个链表中是否存在环。如果有环，快指针最终会追上慢指针；如果没有环，快指针会到达链表末尾。

五.总结

表作为一种基础的数据结构，其独特的结构特性以及相应的操作，堪称众多复杂算法的关键基石。线性表在需要实现快速随机访问的场景之中，具有十分显著的优势。相比之下，链表在频繁进行插入和删除操作的情形下，则展现出更为卓越的性能表现。通过对表进行深入透彻的理解，并切实地进行代码层面的实现，能够为后续进一步深入学习以及开发更为复杂的数据结构和算法，筑牢坚实稳固的根基。

表的结构和操作看似简单，实则蕴含着深刻的逻辑和价值。线性表以其连续存储的方式，使得随机访问变得高效快捷，能够在瞬间定位到特定位置的元素。而链表则凭借其灵活的节点连接方式，在插入和删除操作时无需进行大量的数据移动，极大地提高了操作效率。对这些特性的深入把握，不仅有助于我们在实际编程中选择合适的数据结构，更能够为我们探索更高级的数据结构和算法提供坚实的理论支持和实践经验。

本文章到这里就结束了，下篇文章会在介绍一些表的另外两个非常重要的实例，栈和队列。

本文章若有问题，欢迎大家批评指正。

醒目61
关注
  • 6
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法——从零开始学习（一）基础概念篇
csdn_aiyang的博客
12-06 25万+
前言 数据结构：是指相互之间存在一种或多种特定关系的数据元素的集合用计算机存储、组织数据的方式。数据结构分别为逻辑结构、（存储）物理结构和数据的运算三个部分。 为什么要学数据结构？ 首先，因为数据结构作为计算机专业的专业基础课程，是计算机考研的必考科目之一，如果打算报考计算机专业的研究生，你必须学好它；其次，数据结构是计算机软考、计算机等级考试等相关考试的必考内容之一，想要顺利通过这些考...
数据结构与算法 —— Java 实现（链表）
01-21
数据结构与算法 —— Java 实现（链表）一、单链表1.1 链表的定义1.2 链表添加一个新的节点1.3 判断当前节点是否为最后一个节点 （isLast）1.4 删除下一节点 （removeNext）1.5 显示节点信息（show）1.6 插入一个...
数据结构与算法——算法
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-04 1万+
算法是对特定问题求解的步骤的一种具体描述，算法是指令的有有限序列，其中每一条指令表示一个或是多个操作，用于解决某个问题。本文主要讲解了数据结构与算法——算法的基本概念，知识点详细。...
数据结构与算法——绪论
小田是个程序员的博客欢迎你的到来呀~
05-28 1871
数据结构与算法绪论一章，总结数据结构基本概念和三要素比较重要的理论部分，图文结合的方式更加有助于小伙伴们对抽象理论知识的理解，对于学习数据结构和算法的小伙伴可是纯纯干货，不要错过呀！！！
python 数据结构与算法——链表
颹蕭蕭
01-07 1409
链表 如何检测链表有环？——快慢指针 如何找出链表中倒数第k个元素？——遍历时使用额外指针记录当前位置前第k个元素 如何找出链表中间的元素？——快慢指针 栈 ...
数据结构与算法——冒泡排序
chen18221987993的博客
09-08 2760
目录 前言 一、冒泡排序算法介绍 二、冒泡排序算法原理 三、示例分析 四、实现代码 前言 冒泡排序是一种常用的排序方法。它是一种具有“交换”性质的排序方法。 一、冒泡排序算法介绍 冒泡是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。 这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端
数据结构与算法——时间复杂度
xzt12138的博客
07-18 2728
众所周知，设计算法需要提高效率。那么，如何度量一个算法的执行时间呢?我们的计算机前辈们，为了对算法的评判更加科学，研究出了一种叫做事前分析估算的方法。实际上，就是通过在程序运行前通过对代码语句执行的次数进行求和，以此来评判一个算法的效率。所谓的时间复杂度，也就跟这个代码语句的执行次数密切相关。提示以下是本篇文章正。...
Java数据结构与算法——图
★★光亭★★
03-21 6681
Java数据结构与算法——图
Java数据结构与算法——快速排序
★★光亭★★
03-16 5137
Java数据结构与算法——快速排序
Java数据结构与算法——冒泡排序
★★光亭★★
03-16 6995
Java数据结构与算法——冒泡排序
数据结构与算法————无向图
qq_26952443的博客
03-04 5051
数据结构与算法————无向图图的邻接表存储表示 图的定义及分类 图是由一组顶点和一组能够将两个顶点相连的边组成的 我们需要定义三种结构、邻接表的构建 步骤： ①输入总顶点数，总边数 ②输入各顶点的值 ③输入各边所依附的两个顶点 ④构建新的边节点（使用头插法）
数据结构与算法——C++版
08-25
Mark Allen Weiss《数据结构与算法——C++语言描述》原书第三版，中文
武汉理工大学数据结构与算法实验——欢乐连连看
06-03
武汉理工大学的“数据结构与算法实验——欢乐连连看”是一门将理论学习与实践应用相结合的课程，旨在帮助学生深入理解并掌握这些核心概念。在这个实验项目中，学生们通过实现一个基于经典游戏“欢乐连连看”的程序来...
武汉理工大学数据结构与算法实验——景区管理系统
06-03
(3)使用C++语言，定义图的数据结构，结合迭代开发思路实现“景区信息管理系统”。 2.实验内容 (1)任务背景 现有一个景区，景区里面有若干个景点，如图1所示，景点之间满足以下条件： ①某些景点之间铺设了道路（相邻...
数据结构——————KMP算法
03-12
数据结构——————KMP算法
数据结构之树的存储结构
最新发布
DKPT的博客
08-16 500
孩子链表表示法将树中所有节点存储在一个顺序表中，每个数据元素有两个域：数据域和存放该节点第一个孩子地址的指针域。同时，为树中每个节点构建一个单链表，链表中的节点也有两个域：存放该孩子节点在顺序表中的数组下标和指向下一个孩子的指针。对于完全二叉树，如果父节点的索引是i（假设从0开始计数），那么它的左子节点的索引是2i+1，右子节点的索引是2i+2。数组的第一个元素存储树的根节点。双亲表示法通过采用一维数组来存储树中的节点，其中每个节点被赋予一个结构体类型，包含数据域和父节点位置域（parent域）。
二叉树详解（1）
weixin_73077334的博客
08-15 1268
二叉树详解（1）
数据结构之排序（下）
qq_74336191的博客
08-15 665
​ 嗨！小伙伴们，咱们又见面啦，在上一篇数据结构之排序（上）中，我们学习了直接插入排序、冒泡排序和希尔排序，今天我们继续学习排序这一块，准备好了吗？Ready Go ! ! ! ​
【数据结构】二叉树篇
2303_79015671的博客
08-14 1344
深入解析数据结构二叉树
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值