重温数据结构之链表二——C语言实现

最新推荐文章于 2024-11-12 18:03:10 发布
最新推荐文章于 2024-11-12 18:03:10 发布
阅读量330 收藏
点赞数
分类专栏： 算法 文章标签： 数据结构 线性表 单链表 数据 内存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/itheimach/article/details/59708030
版权

链表

链表属于线性表的一种，不同于顺序表数据的内存地址是连续的，我们就在该数据结构上加一个属性，指向前后数据的内存地址，这样就将数据一串一串的连起来了，这就是链表！

链表分类

链表是有一系列的内存地址不连续的节点组成的，每个节点有两部分组成：数据域，指针域。数据域表示存储的数据，指针域指向另外一个节点，连接成串！
链表有几种：

单链表：头尾不相连，节点有下一个节点的指针（除去尾节点）
双链表：头尾不相连，节点指向上一个以及下一个节点的指针（头节点只有后继，尾节点只有前驱）
单向循环链表：头尾相连的链表，尾节点指向头节点，形成环
双向循环链表：头尾相连的链表，所有节点都有前驱以及后继，形成双向环，可以前后遍历！

简单实现

单链表实现

#include <stdio.h>
#include <malloc.h>

//单链表实现
typedef struct queue_node {

    void *data;
    struct queue_node* next;
} node;

static int count;
static node *phead = NULL;
static node* create_node(void *data) {

    node* node = malloc(sizeof(node));
    if (!node) {

        return NULL;
    }
    node->data = data;
    return node;
}

//创建链表,成功返回0,失败返回-1
int create_queue() {

    node* node = create_node(null);
    if (!node) {

        return -1;
    }
    phead = node;
    phead->next = NULL;
    count = 0;
    return 0;
}

// 链表是否为空
int queue_is_empty() {

    return count == 0;
}

// 获取链表的长度
int queue_size() {

    return count;
}

static node* get_node(int index) {

    if (index < 0 || index >= count) {

        return NULL;
    }

    int i = 0;
    node* node = phead->next;
    while (i < index) {

        node = node->next;
        i++;
    }

    return node;
}

static node* get_first_node() {

    return get_node(0);
}

static node* get_last_node() {

    return get_node(count - 1);
}

//获取index位置的元素值
void* queue_get(int index) {

    if (index < 0 || index >= count) {

        return NULL;
    }

    node* node = get_node(index);
    if (!node) {
        return NULL;
    }
    return node->data;
}

// 获取链表中第1个元素的值
void* queue_get_first() {

    node* node = get_node(0);
    if (!node) {

        return NULL;
    }
    return node->data;
}

void* queue_get_last() {

    node* node = get_node(count - 1);
    if (!node) {

        return NULL;
    }
    return node->data;
}

//向链表中插入元素,成功返回0,失败返回-1
int queue_insert(int index, void* data) {

    if (index < 0 || index > count) {

        return -1;
    }

    //新的元素
    node* newnode = create_node(data);
    if (!newnode) {

        return -1;
    }

    if (index == 0) {
        // 插入头部
        node* first_node = get_first_node();
        phead->next = newnode;
        newnode->next = first_node;
    } else if (index == count) {

        // 插入末尾
        node* lastnode = get_last_node();
        lastnode->next = newnode;
        newnode->next = NULL;
    } else {

        // 中间插入
        node* nodepre = get_node(index - 1);
        nodepre->next = newnode;
        newnode->next = nodepre->next;
    }

    count++;
    return 0;
}

int queue_insert_first(void *data) {

    return queue_insert(0, data);
}

int queue_append_last(void *pval) {

    return queue_insert(count, data);
}

int queue_delete(int index) {

    if (index < 0 || index >= count) {

        return -1;
    }

    if (index == 0) {

        // 删除首个元素
        node* nodeindex = get_node(index);
        phead->next = nodeindex->next;
        free(nodeindex);
    } else {

        node* prenode = get_node(index - 1);
        node* current = nodenode->next;
        prenode->next = current->next;
        free(current);
    }

    count--;
    return 0;
}

int queue_delete_first() {

    return queue_delete(0);
}

int queue_delete_last() {

    return queue_delete(count - 1);
}

int destroy_queue() {

    if (!phead) {

        return -1;
    }
    node* node = phead->next;
    node* q = node;
    while (node) {

        q = node;
        node = node->next;
        free(q);
    }

    free(phead);
    count = 0;
}

双链表实现

#include <stdio.h>
#include <malloc.h>

//双链表实现
typedef struct queue_node {

    void *data;
    struct queue_node* next;
    struct queue_node* pre;
} node;

static int count;
static node *phead = NULL;

// 创建node
static node* create_node(void *data) {

    node* node = malloc(sizeof(node));
    if (!node) {

        return NULL;
    }
    node->data = data;
    node->pre = node->next = NULL;
    return node;
}

// 新建“双向链表”。成功，返回0；否则，返回-1
int create_queue() {

    node* node = create_node(NULL);
    if (!node) {

        return -1;
    }

    phead = node;
    count = 0;
}

// “双向链表是否为空”。为空的话返回1；否则，返回0。
int queue_is_empty() {

    return count == 0;
}
// 返回“双向链表的大小”
int queue_size() {

    return count;
}
// 获取“双向链表中第index位置的元素”。成功，返回节点指针；否则，返回NULL。
void* queue_get(int index) {

    if (index < 0 || index >= count) {

        return NULL;
    }

    int i = 0;
    node * node = phead->next;
    while (i < index) {

        node = node->next;
        i++;
    }

    return node;
}
// 获取“双向链表中第1个元素”。成功，返回节点指针；否则，返回NULL。
void* queue_get_first() {

    return queue_get(0);
}
// 获取“双向链表中最后1个元素”。成功，返回节点指针；否则，返回NULL。
void* queue_get_last() {

    return queue_get(count - 1);
}
// 将“value”插入到index位置。成功，返回0；否则，返回-1。
int queue_insert(int index, void *value) {

    if (index < 0 || index > count) {

        return -1;
    }

    // 新建节点
    node* newnode = create_node(value);
    if (!newnode) {

        return -1;
    }

    if (index == 0) {

        // 在首个位置插入
        node* firstnode = phead->next;
        phead->next = newnode;
        newnode->pre = phead;
        newnode->next = firstnode;
        firstnode->pre = newnode;
    } else if (index == count) {

        // 在末尾插入
        node* lastnode = queue_get(index - 1);
        lastnode->next = newnode;
        newnode->pre = lastnode;
        newnode->next = NULL;

    } else {

        //在中间插入
        node* currentnode = queue_get(index);
        node* prenode = currentnode->pre;

        prenode->next = newnode;
        newnode->pre = prenode;
        newnode->next = currentnode;
        currentnode->pre = newnode;
    }
    count++;
    return 1;
}
// 将“value”插入到表头位置。成功，返回0；否则，返回-1。
int queue_insert_first(void *pval) {

    return queue_insert(0, pval);
}
// 将“value”插入到末尾位置。成功，返回0；否则，返回-1。
int queue_append_last(void *pval) {

    return queue_insert(count, pval);
}
// 删除“双向链表中index位置的节点”。成功，返回0；否则，返回-1
int queue_delete(int index) {

    if (index < 0 || index >= count) {

        return -1;
    }
    node* node = queue_get(index);
    node* prenode = node->pre;
    prenode->next = node->next;
    node->next->pre = prenode;
    free(node);
    count--;
    return 0;
}

// 删除第一个节点。成功，返回0；否则，返回-1
int queue_delete_first() {

    return queue_delete(0);
}

// 删除组后一个节点。成功，返回0；否则，返回-1
int queue_delete_last() {

    return queue_delete(count - 1);
}

// 撤销“双向链表”。成功，返回0；否则，返回-1
int destroy_queue() {

    if (!phead) {

        return -1;
    }
    node* node = phead->next;
    node * p;
    while (node) {

        p = node;
        node = node->next;
        free(p);
    }

    free(phead);
    count = 0;
}

双向循环链表实现

#include <stdio.h>
#include <malloc.h>

//双向循环链表实现
typedef struct queue_node {

    void *data;
    struct queue_node* next;
    struct queue_node* pre;
} node;

static int count;
node* phead;

// 新建“双向链表”。成功，返回0；否则，返回-1
int create_queue() {

    phead = create_node(NULL);
    if (!node) {

        return NULL;
    }
    count = 0;
    return 0;
}

node * create_node(void *data) {

    node* node = malloc(sizeof(node));
    if (!node) {

        return NULL;
    }
    node->data = data;
    node->pre = node->next = NULL;
    return node;
}

// “双向链表是否为空”。为空的话返回1；否则，返回0。
int queue_is_empty() {

    return count == 0;
}
// 返回“双向链表的大小”
int queue_size() {

    return count;
}
// 获取“双向链表中第index位置的元素”。成功，返回节点指针；否则，返回NULL。
void* queue_get(int index) {

    if (index < 0 || index >= count) {

        return NULL;
    }

    // 这里可以优化
    node* firstnode = phead->next;
    int i = 0;
    while ((i++) < index) {

        firstnode = firstnode->next;
    }

    return firstnode->data;
}
// 获取“双向链表中第1个元素”。成功，返回节点指针；否则，返回NULL。
void* queue_get_first() {

    return queue_get(0);
}
// 获取“双向链表中最后1个元素”。成功，返回节点指针；否则，返回NULL。
void* queue_get_last() {

    return queue_get(count - 1);
}
// 将“value”插入到index位置。成功，返回0；否则，返回-1。
int queue_insert(int index, void *pval) {

    if (index < 0 || index > count) {

        return -1;
    }

    node* newnode = create_node(pval);
    if (!newnode) {

        return -1;
    }
    node* nodeindex = queue_get(index);
    if (!nodeindex) {
        // index=count 在末尾插入
        node* lastnode = phead->pre;
        lastnode->next = newnode;
        newnode->pre = lastnode;
        newnode->next = phead;
        phead->pre = newnode;
    } else {
        // 不为空，在其他位置插入
        node* prenode = nodeindex->pre;
        prenode->next = newnode;
        newnode->pre = prenode;
        newnode->next = nodeindex;
        nodeindex->pre = newnode;
    }
    count++;
    return 0;
}
// 将“value”插入到表头位置。成功，返回0；否则，返回-1。
int queue_insert_first(void *pval) {

    return queue_insert(0, pval);
}
// 将“value”插入到末尾位置。成功，返回0；否则，返回-1。
int queue_append_last(void *pval) {

    return queue_insert(count, pval);
}
// 删除“双向链表中index位置的节点”。成功，返回0；否则，返回-1
int queue_delete(int index) {

    if (index < 0 || index >= count) {

        return -1;
    }

    node* indexnode = queue_get(index);
    node* prenode = indexnode->pre;
    node* nextnode = indexnode->next;
    prenode->next = nextnode;
    nextnode->pre = prenode;
    free(indexnode);
    count--;
    return 0;
}
// 删除第一个节点。成功，返回0；否则，返回-1
int queue_delete_first() {

    return queue_delete(0);
}
// 删除组后一个节点。成功，返回0；否则，返回-1
int queue_delete_last() {

    return queue_delete(count - 1);
}

// 撤销“双向链表”。成功，返回0；否则，返回-1
int destroy_queue() {

    if (!phead) {

        return -1;
    }
    node* firstnode = phead->next;
    node* p;
    while (firstnode) {

        p = firstnode;
        firstnode = firstnode->next;
        free(p);
    }
    free(phead);
    phead = NULL;
    count = 0;
    return 0;
}
数据结构——链表 C语言
03-16
设单链表A和B均非递减有序，试设计算法，将A和B合并成非递增有序的单链表C，并要求利用原表A和B的结点空间构造表C。
使用C语言实现队列
cangck_x的博客
06-29 877
#include &lt;stdio.h&gt;#include &lt;malloc.h&gt;typedef struct queue_node { struct queue_node* prev; struct queue_node* next; void *p;//节点的值} node;// 表头static node *phead = NULL;static int count = 0;...
链表的c语言实现（二）
leton2008的专栏
04-30 2284
单链表的c语言实现(1)一、单链表的建立有了动态内存分配的基础，要实现链表就不难了。所谓链表，就是用一组任意的存储单元存储线性表元素的一种数据结构。链表又分为单链表、双向链表和循环链表等。我们先讲讲单链表。所谓单链表，是指数据接点是单向排列的。一个单链表结点，其结构类型分为两部分：1、数据域：用来存储本身数据2、链域或称为指针域：用来存储下一个结点地址或者说指向其直接后继的指针。例：typedef
数据结构与C语言实现（一）——链表及两个实例
Sonihr的犀牛园
10-12 356
//用数组实现线性表 /* #include #include #define MAXSIZE 11 struct LNode { char data[MAXSIZE]; int last; }L; typedef struct LNode * PList; void List_Adress()//测试结构体及内部元素地址 { PList PtrL = &L; printf(
数据结构链表详解+C语言实现 从入门到精通.pdf
08-23
数据结构链表详解+C语言实现 从入门到精通.pdf
数据结构-循环链表-C语言实现约瑟夫圈-数据结构学习
05-26
C语言实现的数据结构中的循环链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件，以及使用循环链表实现的约瑟夫圈的main.c文件 用于C语言以及数据结构的学习，熟练对循环链表边界的判定 此外循环...
数据结构-循环链表-C语言实现循环链表功能-数据结构学习
05-26
C语言实现的数据结构中的循环链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习，熟练对循环链表边界的判定 实现了以下功能： 创建无头循环链表 向循环链表中插入...
C语言 数据结构之链表实现代码
01-20
最近在复习数据结构的相关知识，感觉在初学的时候还是有很多东西没有掌握，不过现在终于算是搞得比较有头绪了，所以就在写出来和大家一起分享！ 什么是链表 简单的说，链表就是由多个结点离散分配，彼此通过指针...
C 语言冒泡排序算法详解
licy__的博客
11-09 338
冒泡排序是一种简单的排序算法，它通过重复地遍历要排序的列表，比较相邻的元素并根据需要交换它们的位置来实现排序。尽管冒泡排序的时间复杂度较高（O(n²)），但它因其简单易懂而常用于教学目的。本文将详细介绍冒泡排序的工作原理，并提供一个用 C 语言实现的示例。冒泡排序的基本思想是通过多次遍历待排序的列表，每次遍历时比较相邻的两个元素，如果前一个元素大于后一个元素，则交换它们的位置。这样，每遍历一次，最大的元素就会像气泡一样“浮”到列表的末尾。这个过程会重复进行，直到整个列表变得有序。
C++研发笔记12——C语言程序设计初阶学习笔记10
Lbs_gemini0603的博客
11-09 590
C++研发笔记12——C语言程序设计初阶学习笔记10
数据结构（1）
m0_71616132的博客
11-09 653
数据结构
C语言第十一周课——函数的调用
qq_58156721的博客
11-12 144
学习函数的调用:通过调用函数来实现二分法。通过调用函数来实现冒泡法。
数据结构合并两个有序链表
weixin_60489641的博客
11-09 248
循环条件为list1与list2均不为null，开始比较list1和list2中的大小，如果是最小值将其放入nextHead的数组中，然后list1走到下一个节点继续与list2匹配，每次都将最小值或相等值放入合并的链表中。这里我们可以创建一个新的对象作为合并后的新链表newHead，而NewHead.next就是我们要返回的头部的位置。在创建一个对象来获取nextHead.next下一个节点来作为我们新链表的起始位置防止我们的头部位置找不到。然后将list2的目标节点放入nextHead.next中。
【数据结构 | C++】字符串关键字的散列映射
等风来
11-12 242
例如将字符串AZDEG插入长度为1009的散列表中，我们首先将26个大写英文字母顺序映射到整数0~25；再通过移位将其映射为3×32^2+4×32+6=3206；然后根据表长得到3206%1009=179，即是该字符串的散列映射位置。给定一系列由大写英文字母组成的字符串关键字和素数P，用移位法定义的散列函数H(Key)将关键字Key中的最后3个字符映射为整数，每个字符占5位；再用除留余数法将整数映射到长度为P的散列表中。发生冲突时请用平方探测法解决。
希尔排序（C语言）
最新发布
N_N12的博客
11-12 443
希尔排序是在直接插入排序的基础上演变的1.先选定一个小于n的整数gap作为间隔（一般gap = n / 3 + 1），然后将所有距离为gap的元素分在同一组，并对每一组的元素进行直接插入排序。它将一组数组分为了gap组，一组中每个元素的间隔为gap。2.当gap的大小减到1时，就相当于整个序列被分到一组，进行一次直接插入排序，排序完成。图片讲解将上述同一颜色相连的数分为一组，一共分了gap组，一组中每个元素的间隔为gap，对同一组中的元素进行插入排序。
C语言第九周课——经典算法
qq_58156721的博客
11-12 864
C语言经典例题对于外层循环遍历到的每一个整数，内层循环用于具体检查该数是否能被 2 到它自身减 1 之间的数整除。在实际应用中，如果要判断更大范围的数是否为素数，通常会采用更高效的算法，比如埃拉托斯特尼筛法等，这些算法可以大大提高判断素数的效率。总体而言，这段代码实现了一个基本的二分查找功能，但需要注意修正输出提示信息时的拼写错误以确保代码的正确性。，由于数组是降序排列的，所以目标元素应该在当前中间元素的左边，因此将。是要判断的数的范围，在本程序中是 100）。，用于存储用户从控制台输入的要查找的目标数字。
Java的六大排序
Yaml4的博客
11-12 507
先创建左右两个临时数组来存储左右两部分已排序的数组，然后通过比较将较小的元素依次放回原数组，最后将剩余的元素也放回原数组。通过一趟排序将待排序的数据分割成两部分，其中一部分的所有元素都比基准元素小，另一部分的所有元素都比基准元素大。采用分治策略，将待排序序列分成两部分，分别对这两部分进行排序，然后将排序好的两部分合并成一个有序序列。，如果是，则将数组分成左右两部分，分别对左右两部分进行归并排序，然后再将两部分已排序的数组合并。把待排序的元素插入到已经排序好的部分序列中的合适位置，使得插入后的序列仍然有序。
【数据结构】汇编 、机器语言 高级语言 简析。
weixin_44939430的博客
11-09 459
类型定义特点示例代码机器语言二进制编码的指令，直接执行高度依赖硬件，难以阅读和编写汇编语言符号化的机器语言使用助记符表示机器指令，依赖硬件平台高级语言接近人类语言的编程语言可读性高，跨平台，适合算法和逻辑开发（C# 示例）总结：机器语言和汇编语言都面向具体硬件，编写复杂；而高级语言抽象了底层细节，更易读、易写，适合开发复杂应用。
时间序列数据结构、持久数据结构详细解读
m0_61840987的博客
11-12 151
时间序列数据结构、持久数据结构详细解读
C语言实现数据结构链表操作示例
"这份资源是关于C语言实现数据结构中链表操作的通用范例源代码，包括了头插法建立单链表和限制链表长度建立长单链表的示例。" 在计算机科学中，链表是一种基础的数据结构，它由一系列节点（也称为元素或记录）组成...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值