1.数据结构之单链表

最新推荐文章于 2023-06-19 16:14:15 发布
最新推荐文章于 2023-06-19 16:14:15 发布
阅读量735 收藏 1
点赞数 1
分类专栏： 数据结构 C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/linux_player_c/article/details/49249951
版权

数据结构之链表

链表的简介

数据结构是编程中对数据处理的一种常见的容器，它们的发明总是从简单到复杂的一个过程，在C语言的编程中我们首先接触了基本数据类型，包括定点数（char、short、int、long）、浮点数（float、double）、指针类型。接着了解到了数组（相同数据类型的集合），结构体（不同数据类型的集合）。再往后随着数据规模的增大以及数据之间的复杂关系，又开发出了链表、栈、队列、树（二叉树、字典树、B树等）、图等数结构，使我们对数据的处理能力进一步加强，所以掌握好数据结构非常的重要，本次博客将会着重介绍相关数据结构的实现。首先让我们从最简单的链表开始数据结构之旅。

链表与数组

首先让我们来介绍下链表与数组之间的有缺点，关于数组我们有以下几种定义方式：

int array1[] = {12, 23, 34, 45, 56, 67, 78};  //方法1
int array2[100] = {0};    //方法2

int *array3 = NULL;

array3 = (int *)malloc(sizeof(int) * 100);    //方法3
if(array3 != NULL){
     fprintf(stderr, "the memory is full!\n");
     exit(1);
}

上述是我们定义数组的三种方式，他们对内存的占用位置是不同的，简单的叙述下:

array2和array3是我们的整型数组，它们存在于进程的栈上（后面会对内存的分布进行详细的介绍），而array3则和其他两个略有不同，array3被定义为一个int类型的指针，也就是说array3存储的是一个地址，我们在malloc函数调用中其实是在堆内存中分配了(4bytes * 100 = 400bytes)大小的空间，并且把该内存块的第一个字节的地址存在了array3中，这样相当于array3虽然在栈上，但是它所指向的空间是在堆上存放的。

不管上述的数组是如何定义的，数组都会满足以下几个特点：

1.数组在物理上还是逻辑上都是连续存储的，其中的元素都是可以通过首地址加偏移量进行定位的。
2.使用数组对元素进行查找，时间复杂度非常低，在O（1）的时间复杂度可以完成查找。
3.使用数组进行插入和删除的时候就不那么乐观了，如果被删除或插入的元素在数组的末位，O（1）的时间复杂度也可以完成。但是绝大多数情况下插入和删除的元素都是在数组的中间进行，这样的话时间复杂度将会上升到O（n）。
4.最关键的一点，一旦数组定义完成后，其大小是不可以更改的。这样就要求使用者能够精确的估计数据规模，但现实环境中很可能会造成数组过大或过小而引发浪费和不足的窘境。

由此我们可以发现数组有着很多的不足，还好我们发明了更加灵活的数据结构，链表应该是其中的一个代表（尽管它也不是那么的完美），链表由相同结构的链表节点构成，关于它们是如何能够链接在一起的，我们需要去关注链表节点的结构：
这里写图片描述

我们可以看到链表节点主要分为两大部分:数据域和链域。数据域是我们最要存储的内容，而链域则代表着一种指针，这个指针指向类型为链表节点，这样每一个节点就可以记录下下一个节点的位置，从而把原本毫不相干的链表节点串接起来。

关于链表节点的结构体定义如下所示：

#define TRUE      (1)
#define FALSE     (0)

typedef unsigned char Boolean;

typedef struct List_node
{
    int               data;   //数据域
    struct List_node *next;    //指针域
}List_node;

typedef List_node *List_head;

为了方便链表操作的实现我们重定义了Boolean类型作为逻辑上的真或假。

链表的操作也是在.h文件中进行声明的，我们叫这样的声明为接口，如下是单链表的接口声明:

List_head        init_list(void)                      ;    //链表的初始化
void             destroy_list(List_head *head)        ;    //链表的删除
Boolean          push_front(List_head head, int value);    //头部插入
Boolean          push_back(List_head head, int value) ;    //尾部插入
Boolean          pop_front(List_head head)            ;    //头部删除
Boolean          pop_back(List_head head)             ;    //尾部删除
Boolean          delete_list_node(List_head head,
                                  List_node *node)    ;    //删除某个指针的值
Boolean          find_value_node(List_head head, 
                          int value, List_node **node);    //找到指定值的地址
void             show_list(List_head head)            ;    //显示链表信息    
void             sort_list_ascend(List_head head)     ;    //链表的升序排序
void             sort_list_descend(List_head head)    ;    //链表的降序排序
int              list_length(List_head head)          ;    //链表的长度

设计完链表的接口，我们就需要全力以赴的实现这些接口，就好像我们在设计完产品的配料表和使用说明书之后就需要专心致志的设计具体的产品，所以关于链表接口的具体实现我们放在list.c中实现，如下所示：

List_head        init_list(void)    //链表的初始化
{
    List_head head = NULL;

    head = buy_node();

    return head;
}

void             destroy_list(List_head *head)    //链表的删除
{
     List_node *p = NULL;
     List_node *q = NULL;

     // List_node **
     if(head == NULL || *head == NULL){
        return ;
     }   

     p = *head;
     while(p != NULL){
         q = p;
         p = p->next;
         free(q);
     }
     *head = NULL;
}

Boolean          push_front(List_head head, int value)    //头部插入
{
    List_node *node = NULL;

    if(head == NULL){
        return FALSE;
    }

    //购买节点并进行赋值
    node = buy_node();
    node->data = value;

  //  printf("adfadf");
    //头部插入节点
    //                NULL->next;
    node->next = head->next;
    head->next = node;

    return TRUE;
}

Boolean          push_back(List_head head, int value)     //尾部插入
{
    List_node *node = NULL;
    List_node *p_node = NULL;

    if(head == NULL){
        return FALSE;
    }

    node = buy_node();
    node->data = value;    

    p_node = head;
    //1.找到末尾
    while(p_node->next != NULL){
        p_node = p_node->next;
    }
    //2.插入到末尾
    p_node->next = node;

    return TRUE;
}

Boolean          pop_front(List_head head)    //头部删除
{
    List_node *p_node = NULL;

    if(head == NULL || head->next == NULL){
        //链表为空或者没有有效节点，头部删除失败
        return FALSE;
    }

    p_node = head->next; 
    head->next = head->next->next;
    free(p_node);

    return TRUE;
}

Boolean          pop_back(List_head head)    //尾部删除
{
    List_node *p_node = NULL;

    if(head == NULL || head->next == NULL){
        return FALSE;
    }

    p_node = head;
    //找到最后一个节点并且删除
    while(p_node->next->next != NULL){
        p_node = p_node->next;
    }
    free(p_node->next);
    p_node->next = NULL;
    return TRUE;
}


//talk  
Boolean          delete_list_node(List_head head,
                                  List_node *node)    //删除某个指针的值
{
    List_node *p_node = NULL;

    if(head == NULL || head->next == NULL || node == NULL){
        return FALSE;
    }

    p_node = head;

    while(p_node->next != node){
        p_node = p_node->next;
        if(p_node == NULL){    //已经遍历完整个链表也没有找到指定的节点
            break ;
        }
    }
    if(p_node == NULL){   //没找到，返回删除失败
        return FALSE;
    }
    //找到并且删除
    p_node->next = node->next;
    free(node);    
    return TRUE;
}

Boolean          find_value_node(List_head head, 
                          int value, List_node **node)    //找到指定值的地址
{
    List_node *p_node = NULL;

    if(head == NULL || head->next == NULL || node == NULL){
         return FALSE;
    }    

    p_node = head->next;
    while(p_node != NULL){
        if(p_node->data == value){
            *node = p_node;
            return TRUE;
        }
        p_node = p_node->next;
    }

    return FALSE;    
}

void             show_list(List_head head)    //显示链表信息    
{
    List_node *p_node = NULL;

    if(head == NULL){
        return ;
    }

    for(p_node = head->next; p_node != NULL; p_node = p_node->next){
        printf("%d ", p_node->data);
    }
    printf("\n");
}

/*
 *    int i = 0;
 *    int j = 0;
 *      
 *    for(i = 0; i < length - 1; ++i){
 *        for(j = i + 1; j < length; ++j){
 *            if(array[i] > array[j]){
 *                 swap(&array[i], &array[j], sizeof(array[i]));
 *            }
 *        }
 *    }
 *
 * */

#define POINTER_SIZE (sizeof(void *))

#define data_size(p_node) (((char *)((p_node) + 1) - (POINTER_SIZE)) - ((char *)(p_node)))

void             sort_list_ascend(List_head head)    //链表的升序排序
{
    List_node *p_node = NULL;
    List_node *q_node = NULL;

    //如果链表为空，没有元素或者只有一个元素，不进行排序操作
    if(head == NULL || head->next == NULL 
    || head->next->next == NULL){
        return ;
    }

    for(p_node = head->next; p_node != NULL; p_node = p_node->next){
        for(q_node = p_node->next; q_node != NULL; q_node = q_node->next){
            if(p_node->data > q_node->data){
                //只交换数据域
                swap(p_node, q_node, data_size(p_node));
            }
        }
    }

}
void             sort_list_descend(List_head head)    ;    //链表的降序排序

int list_length(List_head head)   //链表的长度
{
    List_node *p_node = NULL;
    int length = 0;

    if(head == NULL){
        return length;
    }
    p_node = head->next;

    while(p_node != NULL){
        length++;
        p_node = p_node->next;
    }
    return length;
}

static void      swap(void *a, void *b, int length)    //交换函数 
{
    void *temp = Malloc(length);

    memcpy(temp, a, length);  
    memcpy(a, b, length);
    memcpy(b, temp, length);
    free(temp);
}

static void      *Malloc(size_t size)    //内存申请
{
    void *result = malloc(size);
    if(result == NULL){
        fprintf(stderr, "the memory is full!\n");
        exit(1);
    }
    return result;
}



static List_node *buy_node(void)    //生成一个链表节点
{
    List_node *result = NULL;

    result = (List_node *)Malloc(sizeof(List_node));
    bzero(result, sizeof(List_node));   
    //  int data;
    //  struct List_node *next;

    return result;
}

设计完链表的操作后我们需要对这个功能进行测试，测试代码如下所示：

int main(int argc, char **argv)
{
    List_head head = NULL;
    int i = 0;

    head = init_list();   //链表的初始化
    for(i = 0; i < 10; ++i){
        push_front(head, rand() % 100);
    }   

   // push_back(head, 10); 
   // push_back(head, 20);
   // push_back(head, 30); 
   // push_back(head, 40); 
   // push_back(head, 50); 
   // push_back(head, 60); 

    show_list(head);

    pop_front(head);
    pop_back(head);

    show_list(head); 
   // List_node *find = NULL;

   // Boolean ok = find_value_node(head, 30, &find);

   // if(ok == TRUE){
   //     printf("the %d value found\n", find->data);
   // }

    sort_list_ascend(head);
    show_list(head); 

    destroy_list(&head);    //链表的销毁
    return 0;
}

上述就是我们关于链表的基本操作，虽然非常简单（确实它的功能十分单一，操作不是那么的完善，而且与数据域的类型息息相关），但是清晰的描述出一个链表应该具有的操作。在后续的章节中我们将会介绍更加实用的链表操作，敬请期待。

linux_player_c
关注
专栏目录
【最佳实践】gorm 联表查询 joins
qq_43490312的博客
11-24 1万+
使用gorm的一些技巧、经验 常规使用示例 如何在一对一、一对多、多对一的关系下使用gorm进行联表查询
gorm联表查询-实战
EGXXM的博客
08-02 1574
gorm实现联表查询，项目实战
使用gorm可以通过联结表查询的方式，同时拉取订单记录和每条订单的总价
yqymzj的博客
06-19 454
在上述代码中，我们使用gorm的Table、Select、Joins和Group方法进行联结表查询。首先，我们指定查询的表为"orders"，并使用Select方法选择了所有的订单字段以及计算每个订单的总价（使用SUM函数和乘法运算符）。然后，使用Joins方法指定了"orders.order"和"goods.order"之间的联结关系，通过LEFT JOIN将两个表关联起来。最后，我们使用Find方法将查询结果保存到orders切片中，并遍历输出每个订单的记录和总价。
使用 grom 后所有操作数据库的代码都使用同一个表-链式调用
蜂蜜味的哈士奇
04-19 532
使用 grom 后所有操作数据库的代码都使用同一个库
gorm多表联合查询
面向未来的历史
08-27 1万+
使用golang 中的orm， 即gorm 进行多表联合查询 环境： Gin, gin-vue-admin, mysql 1、定义get请求参数 type ReqArticleItem struct { Page int. `form: page` PageSize int `form:"pageSize"` CategoryNameCn string `form:"categoryNameCn"` ContentNameCn string `form:"contentNa
单链表-C++数据结构之单链表实现.zip
03-13
单链表是计算机科学中一种基础且重要的数据结构，它在C++中有着广泛的应用。在C++中实现单链表，需要理解链表的基本概念、节点结构以及相关的操作。以下是对这一主题的详细讲解： 1. **链表概念**： 链表是一种...
数据结构之单链表操作合集.zip
最新发布
06-16
这个“数据结构之单链表操作合集.zip”文件显然是针对大学生学习数据结构而准备的资源，包含了丰富的学习材料。下面将详细讨论单链表的相关知识点。 单链表是一种线性数据结构，由一系列节点（也称为元素或记录）...
数据结构C语言版之单链表的逆置.cpp
10-07
数据结构老师布置的作业，运用课本代码，较为基础经典，适合大学本科在上数据结构这门课的同学参考，简单易懂，关于单链表的逆置问题
Python数据结构之单链表详解
09-21
### Python数据结构之单链表详解 #### 一、单链表基础概念 单链表是一种常见的线性数据结构，其特点是每个元素包含一个指向下一个元素的引用（指针），因此形成一个链接的数据序列。与数组相比，单链表的优势在于...
gorm 关联查询总结
qq_28053177的博客
08-24 9459
结构体： type Device struct { ID int64 `gorm:"column:id" json:"id"` HardwareId string `gorm:"column:hardware_id" json:"hardwareId"` ModelId int64 ...
Golang中gorm+gin的简单使用
小小程序员Eric的博客
11-23 1924
自己做记录，方便查看 package main import ( &quot;fmt&quot; &quot;github.com/gin-gonic/gin&quot; _ &quot;github.com/go-sql-driver/mysql&quot; &quot;github.com/jinzhu/gorm&quot; ) type User struct { Id int `js
【GORM】GORM链式执行输出执行的SQL
时光、疏离了记忆づ童话的博客
04-11 7823
在上篇文章GORM jinzhu版本和io版本连接MySQL数据库问题中我们讲解了两个版本的GORM数据库连接问题，在GROM使用链式操作过程中，我们想要知道最终执行的SQL是什么，本文讲解三种常见的SQL日志打印方法。 一、全局打印所有的SQL 在gorm.io版本中，我们可以在建立连接时指定打印info级别的sql。 注意gorm版本的io版本 import ( "time" "gorm.io/driver/mysql" "gorm.io/gorm" "gorm.io/gorm/logger
有头节点的单链表
NICHUN12345的博客
10-03 272
程序源码 /*带头节点的单链表*/ #include <stdio.h> #include <stdlib.h> typedef int datatype; //类型重定义，方便以后修改变量类型 typedef struct node_st { datatype data; //数据域 struct node_st *next; //指针域 }list; /*函数声明*/ list *list_create(); //创建链表
【Golang】GORM使用技巧之动态查询及动态联表
Jcrazy Blog
05-04 4767
开发过程中，经常会有需要根据某些条件判断进而进行联表或动态拼接查询条件的需求。 在使用GORM框架的情况下，我们该如何优雅地处理动态联表和动态查询条件问题呢？ 本文通过使用GORM的Clauses、Scopes方法实践了一种较优雅的解决方案与大家分享。
gorm多条数据级联查询关联查询gorm连接池gorm事务
hotqin888的专栏
11-17 1万+
因为gorm支持级联查询。xorm的jion查询虽然很棒，但是查出来的不能生成嵌套结构体。而gorm就可以，经过摸索，这种关联啊，预加载啊，虽然没搞清楚他们之间的区别，但总算能满足自己的查询需要了。 网络上都是单条记录的关联查询，而我需要对多条记录进行关联查询，目前只知道使用preload //查询某个用户打赏记录 func GetUserPay(uid int64, limit, offse...
go的GORM的链式操作、错误处理、钩子、事务
k393393的博客
01-21 3728
1.链式操作 当使用链式写法时候，后面的方法将复用前面的方法的搜索条件（不包含内联条件） db.Where("username LIKE ?", "%大旺%").Find(&users, "id IN (?)", []int{1, 2, 3}).Count(&count) 生成的数据库语句 SELECT * FROM t_user WHERE username LIKE '%大旺%' AND id IN (1, 2, 3) SELECT count(*) FROM t_user WHERE
GORM 文档
peng_lixuan的博客
11-30 429
GORM 中文文档
gorm 连接查询（两表联查，三表联查）预加载的坑
丁涛的博客
12-26 2万+
@ GO gorm 连接查询 gorm 连接查询（两表联查，三表联查） 新人一枚，代码不够漂亮，望多多担待 1，gorm模型如下： // 文章 type Topics struct { Id int `gorm:&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;quot;primary_key&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;quot;` Title
关于gorm多表联合查询（left join）的小记
热门推荐
f95_sljz的博客
12-24 3万+
Golang很流行，但是有些方面资料很少而且不详实，譬如：gorm的联合查询，当然，也不推荐复杂语句使用orm模型。 现将自己总结的写法和遇到的坑记录如下： Golang要求使用“驼峰命名法”，比如systemId，因为我以前用的是Python，使用Django的orm序列化后返回的参数和数据库表字段一致，基于这个不适合Go的思路，我将表字段也建成了systemId，和struct映射参数相同。（...
C++实现数据结构单链表操作
"数据结构中单链表的程序实现" 在计算机科学中，数据结构是组织、管理和存储数据的方式，而单链表是一种基础且重要的数据结构。单链表由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。这个...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值