C 语言实现单链表

最新推荐文章于 2021-05-19 13:41:10 发布
最新推荐文章于 2021-05-19 13:41:10 发布
阅读量478 收藏 1
点赞数
分类专栏： 数据结构 # 链表 文章标签： C语言实现单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hong_smallgod/article/details/100730285
版权

单链表的实现有两种：有无头结点
        一般有头节点的会容易实现。写在这里方便以后查看。下面的这一些功能, 只是自己一些臆想出来的。之所以把功能做出来,是为了增加自己的一些积累。在实际的工程当中，应当根据具体应用场景进行相应的改动，大致的框架是不会怎么改动的。
下面的函数都通过了我的验证，在Ubuntu上使用gdb调试器验证的。
关于命名要好好想一下

目前我能想到的拓展:

  • ascending order (升序)、descending order (降序)、unordered(无序)
  • 有无头结点
  • 遇到相同关键值改如何处理
  • 传参是头指针还是头指针地址
  • 元素的类型 emmmmmm…

这些拓展有时间就实现一下吧，其实都差不多

/********************************************************************************
* Copyright(c) 2019-20xx
* All right resered.
*
* @file  	single_linked_list.h
* @author 	hongsmallgod
* @version	V1.0.1
* @data		2019-9-12 10:56:21
* @brief	单链表头文件
********************************************************************************/
#ifndef _SINGLE_LINKED_LIST_H
#define _SINGLE_LINKED_LIST_H

#undef element
#define element int

typedef struct node node;
struct node {
    element data;
    node *next;
};

extern int sll_insert1(node *head, element data);
extern int sll_insert2(node *head, element data);
extern int sll_insert3(node *head, element data);
extern int sll_delete1(node *head, element data);
extern int sll_delete2(node *head, element data);
#if 0
extern void sll_traversal(node *head);
extern node *create_sll(void);
extern void sll_sort(node *head);
#endif
extern int sll_insert4(node *head, element data);
extern int sll_insert5(node *head, element data);
extern int sll_delete3(node *head, element data);

extern void sll_destroy(node *head);
extern size_t get_sll_node_num(node *head);
extern int sll_insert6(node **rootp, element data);
extern int sll_delete_tail(node *head);
extern int sll_delete_head(node *head);
extern int sll_get_head(node *head, element *data);
extern int sll_get_tail(node *head, element *data);
extern int sll_get_and_delete_head(node *head, element *data);
extern int sll_get_and_delete_tail(node *head, element *data);
#endif

/********************************************************************************
* Copyright(c) 2019-20xx
* All right resered.
*
* @file  	single_linked_list.c
* @author 	hongsmallgod
* @version	V1.0.1
* @data		2019-9-12 10:56:21
* @brief	单链表源文件
********************************************************************************/
#include <stdlib.h>
#include <stdio.h>
#include "single_linked_list.h"

/*
** function  : sll_insert1
** author	 : hongsmallgod
** brief     : 升序单链表插入函数, 如果链表中有相同的值, 不进行插入
** argument  : @head: 头结点指针; @data: 关键值
** return 	 : 1: 插入成功; -1: 内存不足; 0:链表当中有相同的内容
*/
int sll_insert1(node *head, element  data)
{
    node *current = head;
    node *new = (node *)malloc(sizeof(node));
    if (NULL == new)
        return -1;
    new->data = data;

    for (; current->next && current->next->data <= data; current = current->next) {
        if (current->next->data == data)
            return 0;
    }
    new->next = current->next;
    current->next = new;

    return 1;
}

/*
** function  : sll_insert2 (单链表的插入函数, 区别不大)
** author	 : hongsmallgod
** brief     : 升序单链表插入函数, 如果链表中有相同的值, 插入到最后
** argument  : @head: 头结点指针; @data: 关键值
** return 	 : 1: 删除成功; -1: 内存不足;
*/
int sll_insert2(node *head, element  data)
{
    node *current = head;
    node *new = (node *)malloc(sizeof(node));
    if (NULL == new)
        return -1;
    new->data = data;

    for (; current->next && current->next->data <= data; current = current->next);

	new->next = current->next;
	current->next = new;
    return 1;
}

/*
** function  : sll_insert3 (单链表的插入函数, 区别不大)
** author	 : hongsmallgod
** brief     : 升序单链表插入函数, 如果链表中有相同的值, 插入到起始
** argument  : @head: 头结点指针; @data: 关键值
** return 	 : 1: 删除成功; -1: 内存不足;
*/
int sll_insert3(node *head, element  data)
{
    node *current = head;
    node *new = (node *)malloc(sizeof(node));
    if (NULL == new)
        return -1;
    new->data = data;

    for (; current->next && current->next->data < data; current = current->next);

	new->next = current->next;
	current->next = new;
    return 1;
}

/*
** function  : sll_delete1
** author	 : hongsmallgod
** brief     : 升序单链表节点删除函数, 如果相邻节点有相同的值, 删除第一个
** argument  : @head: 链表头结点指针; @data: 关键值
** return 	 : 1: 删除成功; 0: 链表当中没有所要删除的元素
*/
int sll_delete1(node *head, element  data)
{
    node *current = head;
    node *tmp = NULL;
    for (; current->next; current = current->next) {
        if (current->next->data == data) {
        	tmp = current->next->next;
        	free(current->next);
            current->next = current->next->next;
            return 1;
        }
        if (current->next->data > data)
            return 0;
    }
    return 0;
}

/*
** function  : sll_delete2
** author	 : hongsmallgod
** brief     : 升序单链表节点删除函数, 如果相邻节点有相同的值, 一并删除
			   例: 2 2 1 2 3 4 5 6(这个不是升序链表), 调用这个函数删除 2 , 结果  1 3 4 5 6
** argument  : @head: 链表头结点指针; @data: 关键值
** return 	 : 1: 删除成功; 0: 链表当中没有所要删除的元素
*/
int sll_delete2(node *head, element  data)
{
    node *current = head;
    node *tmp = NULL;
    int status = 0;
    while (current->next) {
        if (current->next->data == data) {
        	tmp = current->next->next;
        	free(current->next);
            current->next = tmp ;
            status = 1;
            continue;
        }
        if (current->next->data > data)
            break;
        current = current->next;
    }

    if (1 == status)
        return 1;
    return 0;
}
#if 0
/*
** function  : sll_traversal
** author	 : hongsmallgod
** brief     : 遍历单链表， 只适用于 数据域为 int 型数据
** argument  : @head: 链表头结点指针
** return 	 : none
*/
void sll_traversal(node *head)
{
    node *current = head->next;
    while (current) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
}
#endif
/*
** function  : sll_insert4
** author	 : hongsmallgod
** brief     : 无序单链表插入函数, 插入到链表尾部
** argument  : @head: 头结点指针; @data: 关键值
** return 	 : 1: 插入成功; -1: 内存不足
*/
int sll_insert4(node *head, element  data)
{
    node *current = head;
    node *new = NULL;
    new = (node *)malloc(sizeof(node));
    if (NULL == new)
        return -1;
    new->data = data;
    new->next = NULL;
    for (; current->next; current = current->next);
    current->next = new;
    return 1;
}

/*
** function  : sll_insert5
** author	 : hongsmallgod
** brief     : 无序单链表插入函数, 插入到链表头
** argument  : @head: 头结点指针; @data: 关键值
** return 	 : 1: 删除成功; -1: 内存不足;
*/
int sll_insert5(node *head, element  data)
{
    node *new = (node *)malloc(sizeof(node));
    if (NULL == new)
        return -1;
    new->data = data;

    new->next = head->next;
    head->next = new;
    return 1;
}

/*
** function  : sll_delete3
** author	 : hongsmallgod
** brief     : 单链表节点删除函数, 如果链表有相同的值, 一并删除
** argument  : @head: 链表头结点指针; @data: 关键值
** return 	 : 1: 删除成功; 0: 链表当中没有所要删除的元素
*/
int sll_delete3(node *head, element  data)
{
    node *current = head;
    node *tmp = NULL;
    int status = 0;
    while (current->next) {
        if (current->next->data == data) {
        	tmp = current->next->next;
        	free(current->next);
            current->next = tmp ;
            status = 1;
            continue;
        }

        current = current->next;
    }

    if (1 == status)
        return 1;
    return 0;
}

/*
** function  : sll_delete_head
** author	 : hongsmallgod
** brief     : 删除单链表第一个节点(首元结点)
** argument  : @head: 链表头结点指针
** return 	 : 1:删除成功; 0: 链表为空
*/
int sll_delete_head(node *head)
{
    if (NULL == head->next)
        return 0;
    node *tmp = head->next->next;
    free(head->next);
    head->next = tmp;
    return 1;
}

/*
** function  : sll_delete_tail
** author    : hongsmallgod
** brief     : 删除单链表最后一个节点(尾结点)
** argument  : @head: 链表头结点指针
** return    : 1:删除成功; 0: 链表为空
*/
int sll_delete_tail(node *head)
{
    node *current = head;
    if (NULL == head->next)
        return 0;
    for (; current->next->next; current = current->next);
    free(current->next);
    current->next = NULL;
    return 1;
}
#if 0
/*
** function  : create_sll
** author    : hongsmallgod
** brief     : 创建单链表, 无序
** argument  : void
** return    : NULL:内存不足; else: 链表头节点指针
*/
node *create_sll(void)
{
    int data = -1;
    /*
    ** 创建头节点
    */
    node *head = (node *)malloc(sizeof(node));
    if (NULL == head)
            return NULL;
    head->data = 0;
    head->next = NULL;

    while (scanf("%d", &data) == 1 && data != -1) {
       sll_insert3(head, data);
    }
    return head;
}
#endif
/*
** function  : sll_destroy
** author	 : hongsmallgod
** brief     : 销毁单链表
** argument  : 链表头节点指针
** return 	 : none
*/
void sll_destroy(node *head)
{
    node *tmp;
    node *current = head;

    while (current) {
        tmp = current->next;
        free(current);
        current = tmp;
    }
}

/*
** function  : get_sll_node_num
** author	 : hongsmallgod
** brief     : 获取单链表节点数
** argument  : @head: 链表头结点指针
** return 	 : @count: 节点数
*/
size_t get_sll_node_num(node *head)
{
    int count = 0;
    node *current = head;
    while (current->next) {
        count++;
        current = current->next;
    }
    return count;
}
#if 0
/*
** function  : sll_sort
** author	 : hongsmallgod
** brief     : 单链表排序函数(冒泡法)
** argument  : @head: 链表头结点指针
** return 	 : none
*/
void sll_sort(node *head)
{
    int num = get_sll_node_num(head);
    node *current = head->next;
    int flag;
    int tmp;
    if (num == 0)
        return;
    int k = num - 1;
    while (k) {
    	flag = 0;
        for (int i = 0; i < k; i++) {
            if (current->data > current->next->data) {
                tmp = current->data;
                current->data = current->next->data;
                current->next->data = tmp;
                flag = i;
            }
            current = current->next;
        }
        k = flag;
        current = head->next;
    }
}
endif
/*
** function  : sll_insert6
** author	 : hongsmallgod
** brief     : 单链表节点插入函数
** argument  : @rootp: 链表头指针的指针(链表头指针的地址); @data: 关键值
** return 	 : -1: 内存不足; 1:插入成功
*/
int sll_insert6(node **rootp, element  data)
{
    node *current;
    node *new = (node *)malloc(sizeof(node));
    if (NULL == new)
            return -1;
    new->data = data;

    while ((current = *rootp) && current->data < data)
        rootp = &current->next;

    *rootp = new;
    new->next = current;

    return 1;
}
/*
** function  : sll_get_head
** author    : hongsmallgod
** brief     : 获取单链表第一个元素
** argument  : @head: 链表头结点指针; @data: 数据指针
** return    : 1:获取成功; 0: 链表为空
*/
int sll_get_head(node *head, element *data)
{
    if (head->next == NULL)
        return 0;
    *data = head->next->data;
    return 1;
}

/*
** function  : sll_get_tail
** author    : hongsmallgod
** brief     : 获取单链表最后一个元素
** argument  : @head: 链表头结点指针; @data: 数据指针
** return    : 1:获取成功; 0: 链表为空
*/
int sll_get_tail(node *head, element *data)
{
    node *current = head->next;
    if (NULL == head->next)
        return 0;
    for (; current->next; current = current->next);
    *data = current->data;
    return 1;
}
/*
** function  : sll_get_and_delete_head
** author    : hongsmallgod
** brief     : 获取并删除单链表第一个元素
** argument  : @head: 链表头结点指针; @data: 数据指针
** return    : 1:获取成功; 0: 链表为空
*/
int sll_get_and_delete_head(node *head, element *data)
{
    if (NULL == head->next)
        return 0;
    node *tmp = head->next->next;
    *data = head->next->data;
    free(head->next);
    head->next = tmp;
    return 1;

}

/*
** function  : sll_get_and_delete_tail
** author    : hongsmallgod
** brief     : 获取并删除单链表最后一个元素
** argument  : @head: 链表头结点指针; @data: 数据指针
** return    : 1:获取成功; 0: 链表为空
*/
int sll_get_and_delete_tail(node *head, element *data)
{
    node *current = head;
    if (NULL == head->next)
        return 0;
    for (; current->next->next; current = current->next);
    *data = current->next->data;
    free(current->next);
    current->next = NULL;
    return 1;

}
hongsmallgod
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之链式表的实现--单向循环链表(C语言)
RSDTE
09-15 1124
 学习参考: 严蔚敏: 《数据结构-C语言版》 单向循环链表的基本操作 单向循环链表的建立 单向循环链表添加结点(头插法) 单向循环链表添加结点(尾插法) 单向循环链表的输出 单向循环链表的修改 单向循环链表的插入 单向循环链表的删除 单向循环链表按序号查找 单向循环链表按值查找  单向循环链表销毁 求单向循环链表的长度 基本操作代码实现 单向循环链表的结点定义 ...
数据结构 C语言实现循环单链表的实例
08-30
在本实例中，我们使用 C 语言实现了一个循环单链表的实例。该实例包括了循环单链表的初始化、建立、插入和删除等操作。 首先，我们定义了结点类型为 ElemType，并定义了一个结构体 Node，其中包括数据域 data 和...
C实现单链表
finewind的专栏
11-17 3074
#ifndef LIST_H_ #define LIST_H_ #include #define TSIZE 45 // 存放片名的数组大小 struct film { char title[TSIZE]; int rating; }; typedef struct film Item; // 一般类型定义 typedef struct node { Item item; struct node *next; }Node; // 链
c语言实现数据结构中的链式表
weixin_33923762的博客
08-18 152
以下是我用c语言实现数据结构中的链式表 #pragmaonce; #ifndef_STDLIB_H #include<stdlib.h> #endif #ifndef_ELEMTYPE_H typedefintElemType; ...
c语言线性表的链式表示和实现
qq_35938563的博客
11-21 984
线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素（这存储单元可以使连续的，也可以是不连续的）它包括另个域，数据与和指针域，数据域用来存储数据元素信息，指针域中存储的信息称为指针或链，n个节点链成一个链表，即为线性表的链式存储结构。
C语言实现线性表的链式存储结构
豆破苍琼
10-05 1173
线性表的链式存储结构
用C语言实现单链表的各种操作(一)
12-25
最近，从新复习了一下数据结构中比较重要的几个部分，现在把自己的成果...下面的基本的单链表的操作：其中，有一些宏，没有给出他们的一些定义，者可以通过，严蔚敏的《数据结构》（C 语言版），查看得到。 代码如下:/*
C语言实现单链表的增删查改
03-25
本篇文章将深入探讨如何用C语言实现单链表的增、删、查、改四种基本操作。 ### 1. 单链表的基本结构 首先，我们需要定义一个链表节点结构体，如下所示： ```c typedef struct Node { int data; // 数据域，这里...
C语言实现单链表反转
12-17
　有些语言有“指针”的概念，比如 C 语言；有些语言没有指针，取而代之的是“引用”，比如 Java、Python。不管是“指针”还是“引用”，实际上，它们的意思都是一样的，都是存储所指对象的内存地址。 　将某个变量...
学生简易通讯录管理系统（ C语言）（单链表）
05-29
1、实现软件：Dev-C++ 2、详细的测试页面可见我《资源》专栏下的《C语言系统资源测试》。 3、适合新手下载学习。 4、基于C语言的单链表实现。
C语言实现一般线性表的链式存储
linuxlsl的博客
10-22 407
C语言实现一般线性表的顺序存储,以下是在VS2013编译通过的，欢迎讨论。有关数据结构的概念可看我的另一篇文章http://blog.csdn.net/linuxlsl/article/details/45649655 一、头文件linklist.h #ifndef _LINKLIST_H_ #define _LINKLIST_H_ typedef void LinkList; typed
glib库单向链表
caoshunxin01的专栏
02-23 264
glib库单向链表介绍 glib库里实现了一些基本的数据结构，比如单向链表，双向链表、队列、树、hash表和数组。这篇文章里我主要介绍在linux平台下使用glib库中的单向链表进行编程，以后的文章我会陆续介绍双向链表、队列和其它数据结构的用法。 单向链表（即GSList）是glib库里最简单的容具，它把一系列的节点链接在一起，可以从一个节点访问到下一个节点。glib库里对GSLis
关于C语法实现链表的问题分析
0110_
09-13 121
问题1：
单链表实现
非典型程序员
09-12 146
使用头结点的好处： 插入删除等函数不需要额外考虑位于首结点的条件。 一些改变链表的函数在传参时，如不改变头结点，可只传递普通头结点的指针，否则的话，需要传递首结点指针的指针来应对更改首结点地址的情况。 #include<stdio.h> #include<stdlib.h> typedef struct Node//结点的存储结构 { int data; // s...
线性表的链式结构算法设计
ademoli的博客
09-12 155
package com; public class LinkNode { //单链表的结点 String key; //结点的关键字 int data; //结点的数据值 LinkNode nextNode; //指向下一个结点 public LinkNode( LinkNode node){ this.nextNode = node;...
线性表的顺序表示和实现(C语言)
fffzlfk的博客
09-08 287
点击跳转
转载一个比较有意思的程序函数,呵! result love(boy, girl)
清风一吹(清风博客)
04-26 1776
result love(boy, girl) 　　{ 　　　　if ( boy.有房() and boy.有车() ) 　　　　{ 　　　　　　boy.set(nothing); 　　　　　　return girl.嫁给(boy); 　　　　} 　　　　else if ( girl.愿意等() ) 　　　　{ 　　　　　　while( ! (boy.赚钱 ＞ 100,000 and girl.感情
c语言delete是标识符吗,C语言中SLL的Delete（node）的正确语法是什么？
weixin_33933280的博客
05-19 400
假设相关的头文件，声明了C中的单链接列表函数。Delete()的以下定义正确吗？/* The Structure for SLLtypedef struct SLL{int data;struct SLL *next;}node;Function Delete() deletes a node*/void Delete( node **head){node *temp, *prev;int key...
C语言一些常用结点和结点操作
HMT的博客
10-22 2077
C语言练习用的一些常用结点和操作 单列表 // 单列表结点 typedef struct { int value; struct SNode* next; }SinglyLinkedListNode,SLLNode,SNode; /* value：新单列表结点的值 return：新结点，next会被赋值为空 */ SNode* createSNode(int value) { SNode* node = (SNode*)malloc(sizeof(SNode)); node
在linuxc语言实现单链表的增删改查
最新发布
04-02
在Linux C语言中，可以通过结构体来实现单链表，结构体包含一个数据成员和一个指向下一个节点的指针成员。 下面是一个简单的单链表结构体定义： ```c typedef struct node { int data; struct node *next; } ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值