单链表的基本操作

最新推荐文章于 2022-07-19 20:22:32 发布
原创 最新推荐文章于 2022-07-19 20:22:32 发布 · 320 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #单链表 #C语言

数据结构-单链表-基本操作-C语言实现

LinkList.h

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

#define TEST_HEAD printf("=====%s=====\n", __FUNCTION__);

typedef int ElemType; 

typedef struct LinkList
{
    ElemType data;//数据域
    struct LinkList* next;//指针域
}LinkList, *Plinklist;

void LinkListInit(Plinklist* Plinkhead);//链表初始化
int LinkListLength(Plinklist* Plinkhead);//获取链表长度
void LinkListPushFront(Plinklist* Plinkhead, ElemType data);//头插
void LinkListPopFront(Plinklist* Plinkhead);//头删
void LinkListPushBack(Plinklist* Plinkhead, ElemType data);//尾插
void LinkListPopBack(Plinklist* Plinkhead);//尾删
Plinklist LinkListFindPos(Plinklist* Plinkhead, ElemType data);//查找pos位置的元素
void LinkListInsertBeforePos(Plinklist* Plinkhead, int pos, ElemType data);//在pos之前插入元素
void LinkListInsertAfterPos(Plinklist* Plinkhead, int pos, ElemType data);//在pos之后插入元素
void LinkListInsertBefore(Plinklist* Plinkhead, Plinklist pos, ElemType data);//不允许遍历链表, 在 pos 之前插入
void LinkListErase(Plinklist* Plinkhead, int pos);//删除指定位置元素
void LinkListRemove(Plinklist* Plinkhead, ElemType data);//删除指定值的元素
int LinkListFindData(Plinklist* Plinkhead, ElemType data);//查找指定值的位置
void LinkListPrint(Plinklist* Plinkhead);//打印链表
int LinkListEmpty(Plinklist* Plinkhead);//判断链表是否为空
size_t LinkListSize(Plinklist* Plinkhead);//求元素个数
void LinkListReversePrint(Plinklist* Plinkhead);//逆序打印
LinkList.c

#include "linklist.h"

//创建结点
Plinklist CreatNode()
{
    Plinklist Node = (Plinklist)malloc(sizeof(LinkList));
    return Node;
}
//销毁结点
void DestoryNode(Plinklist Node)
{
    free(Node);
}

//链表初始化
void LinkListInit(Plinklist *Plinkhead)
{
    TEST_HEAD;
    *Plinkhead = CreatNode();//给头结点申请空间
    (*Plinkhead)->next = NULL;//令头结点的指针域为空
    printf("初始化完成\n");//即创建了一个只有头结点的单链表
}

//获取链表长度
int LinkListLength(Plinklist *Plinkhead)
{
    TEST_HEAD;
    int len = 0;
    Plinklist p;
    p = (*Plinkhead)->next;//令p指向第一个结点
    while(p != NULL)
    {
        len++;
        p = p->next;//p后移
    }
    printf("len = %d\n", len);
    return len;
}
//头插建立链表
void LinkListPushFront(Plinklist *Plinkhead, ElemType data)
{
    TEST_HEAD;
    if(Plinkhead == NULL)
    {
        printf("非法输入\n");
        return;
    }
    Plinklist Node;
    Plinklist temp;
    if((*Plinkhead)->next == NULL)
    {

        Node = CreatNode();
        Node->data = data;
        (*Plinkhead)->next = Node;
        Node->next = NULL;
    }
    else
    {
        temp = *Plinkhead;
        Plinklist after_temp;
        Node = CreatNode();
        Node->data = data;
        after_temp = temp->next;
        temp->next = Node;
        Node->next = after_temp;
        printf("头插成功\n");
    }
    LinkListPrint(Plinkhead);
}
//头删
void LinkListPopFront(Plinklist *Plinkhead)
{
    TEST_HEAD;
    if((*Plinkhead)->next == NULL)
    {
        printf("链表已经为空\n");
        return ;
    }
    else
    {
        Plinklist temp = *Plinkhead;
        Plinklist del = temp->next;
        temp->next = temp->next->next;
        DestoryNode(del);
        del = NULL;
        printf("头删成功\n");
    }
    LinkListPrint(Plinkhead);
}

//尾插建立链表
void LinkListPushBack(Plinklist *Plinkhead, ElemType data)//Plinkhead头结点 Node要插入的节点
{
    TEST_HEAD;
    Plinklist Node;
    Plinklist temp;
    if((*Plinkhead)->next == NULL)
    {
        Node = CreatNode();
        Node->data = data;
        (*Plinkhead)->next = Node;
        Node->next = NULL;
    }
    else if((*Plinkhead)->next != NULL)
    {
        temp = *Plinkhead;
        while(temp->next)
        {
            temp = temp->next;
        }
        Node = CreatNode();
        Node->data = data;
        temp->next = Node;
        Node->next = NULL;
        temp = Node;
    }
    printf("尾插成功\n");
    LinkListPrint(Plinkhead);
}

//void Destory()

//尾删一个元素
void LinkListPopBack(Plinklist *Plinkhead)
{
    TEST_HEAD;
    Plinklist before_temp = NULL;
    if((*Plinkhead)->next == NULL)
    {
        printf("链表已经为空\n");
        return ;
    }
    else
    {
        Plinklist temp = *Plinkhead;
        while(temp->next)
        {
            before_temp = temp;
            temp = temp->next;
        }
        DestoryNode(temp);
        temp = NULL;
        before_temp->next = NULL;
        printf("尾删成功\n");
    }
    LinkListPrint(Plinkhead);
}
//查找元素在链表中的位置
Plinklist LinkListFindPos(Plinklist *Plinkhead, ElemType data)
{
    TEST_HEAD;
    if((*Plinkhead)->next == NULL)
    {
        printf("链表为空\n");
        return NULL;
    }
    else
    {
        Plinklist temp = *Plinkhead;
        while(temp->next != NULL)
        {
            //printf("进入循环\n");
            if(temp->next->data == data)
            {
                printf("%d的位置: ", temp->next->data);
                printf("[%p]->[%d]\n", temp->next, temp->next->data);
                return temp->next;
            }
            temp = temp->next;
        }
        printf("链表中没有此元素\n");
    }
    printf("\n");
}
//在位置pos之前插入元素
void LinkListInsertBeforePos(Plinklist *Plinkhead, int pos, ElemType data)
{
    TEST_HEAD;
    if((*Plinkhead)->next == NULL)
    {
        printf("链表为空，直接尾插\n");
        LinkListPushBack(Plinkhead, data);
        return ;
    }
    else
    {
        Plinklist temp = *Plinkhead;
        Plinklist Node;
        Node = CreatNode();
        Node->data = data;
        Plinklist after_temp;
        int ret = pos - 1;
        while(ret--)
        {
            //printf("进入循环\n");
            temp = temp->next;
        }

        after_temp = temp->next;
        temp->next = Node;
        Node->next = after_temp;
        printf("在第%d个元素之前插入[%d]成功\n", pos, data);
    }
    LinkListPrint(Plinkhead);
}
//在位置pos之后插入元素
void LinkListInsertAfterPos(Plinklist *Plinkhead, int pos, ElemType data)
{
    TEST_HEAD;
    if((*Plinkhead)->next == NULL)
    {
        printf("链表为空，直接尾插\n");
        LinkListPushBack(Plinkhead, data);
        return ;
    }
    else
    {
        Plinklist temp = *Plinkhead;
        Plinklist Node;
        Node = CreatNode();
        Node->data = data;
        Plinklist after_temp;
        int ret = pos;
        while(ret--)
        {
            //printf("进入循环\n");
            temp = temp->next;
        }

        after_temp = temp->next;
        temp->next = Node;
        Node->next = after_temp;
        printf("在第%d个元素之后插入[%d]成功\n", pos, data);
    }
    LinkListPrint(Plinkhead);
}
//删除指定位置的元素
void LinkListErase(Plinklist *Plinkhead, int pos)
{
    TEST_HEAD;
    if((*Plinkhead)->next == NULL)
    {
        printf("链表已经为空\n");
        return ;
    }
    Plinklist temp = *Plinkhead;
    Plinklist before_pos;
    Plinklist pos_Node;
    int ret = pos - 1;
    while(ret--)
    {
        //printf("进入循环\n");
        temp = temp->next;
    }
    before_pos = temp;
    pos_Node = before_pos->next;
    before_pos->next = pos_Node->next;
    int del_data = pos_Node->data;
    DestoryNode(pos_Node);
    pos_Node = NULL;
    printf("成功删除第%d个元素[%d]\n", pos, del_data);
    LinkListPrint(Plinkhead);
}
//查找指定值的位置
int LinkListFindData(Plinklist *Plinkhead, ElemType data)
{
    if(NULL == (*Plinkhead)->next)
    {
        printf("链表为空\n");
        return -1;
    }
    Plinklist temp = *Plinkhead;
    int pos = 0;
    while(temp)
    {
        if(temp->data == data)
        {
            return pos;
        }
        pos++;
        temp = temp->next;
    }
    return -1;
}
//删除指定值的元素
void LinkListRemove(Plinklist *Plinkhead, ElemType data)
{
    int pos = LinkListFindData(Plinkhead, data);
    LinkListErase(Plinkhead, pos);
}
//打印单链表
void LinkListPrint(Plinklist *Plinkhead)
{
    //TEST_HEAD;
    Plinklist temp;
    temp = (*Plinkhead)->next;
    printf("=====顺序输出链表=====\n");
    if(temp == NULL)
    {
        printf("链表为空\n");
        return;
    }
    while(temp)
    {
        printf("[%d|%p]\n", temp->data, temp->next);
        temp = temp->next;
    }
    printf("\n");
}


//指定值的所有元素都删掉
void LinkListRemoveAll(Plinklist *Plinkhead, ElemType data)
{
    //TODO
    if((*Plinkhead)->next == NULL)
    {
        printf("链表已经为空\n");
        return;
    }
    Plinklist temp = *Plinkhead;
    while(temp)
    {
        if(temp->data == data)
        {

        }
    }
}

//判定链表为空 链表为空, 返回1, 否则返回0
int LinkListEmpty(Plinklist *Plinkhead)
{
    TEST_HEAD;
    if((*Plinkhead)->next == NULL)
        return 1;
    else
        return 0;
}

//求链表的元素个数
size_t LinkListSize(Plinklist *Plinkhead)
{
    TEST_HEAD;
    if(LinkListEmpty(Plinkhead) == 1)
    {
        printf("链表为空\n");
        return 0;
    }
    size_t count = 0;
    Plinklist temp = *Plinkhead;
    while(temp->next)
    {
        count++;
        temp = temp->next;
    }
    return count;
}

//逆序打印单链表.
void LinkListReversePrint(Plinklist *Plinkhead)
{
    Plinklist temp = *Plinkhead;
    if(temp == NULL)
    {
        //printf("链表为空\n");
        return ;
    }
    //int len = LinkListLength(Plinkhead);
    //printf("len = %d\n", len);
    if(temp)
    {
        LinkListReversePrint(&(temp->next));
    }
    printf("[%d|%p]\n", temp->data, temp->next);
}

//不允许遍历链表, 在 pos 之前插入
void LinkListInsertBefore(Plinklist *Plinkhead, Plinklist pos, ElemType data)
{
    TEST_HEAD;
    if(Plinkhead == NULL || pos == NULL)
    {
        printf("非法输入\n");
        return;
    }
    if((*Plinkhead) == NULL)
    {
        Plinklist Node = CreatNode();
        Node->data = data;
        (*Plinkhead)->next = Node;
        Node->next = NULL;
    }
    //先把Node插入pos之后
    Plinklist Node = CreatNode();
    Node->data = data;
    Node->next = pos->next;
    pos->next = Node;
    //交换pos和Node的值
    ElemType tmp = pos->data;
    pos->data = Node->data;
    Node->data = tmp;
    LinkListPrint(Plinkhead);
}

//约瑟夫环问题
//LinkNode* JosephCycle(Plinklist* Plinkhead, size_t food)
//{
//  //TODO
//}
mian.c

#include "linklist.h"


int main()
{
    Plinklist myLinkList;//定义一个链表
    LinkListInit(&myLinkList);//初始化链表

    LinkListLength(&myLinkList);//获取链表长度
    //尾插元素
    LinkListPushBack(&myLinkList, 9);
    LinkListPushBack(&myLinkList, 5);
    LinkListPushBack(&myLinkList, 2);
    LinkListPushBack(&myLinkList, 7);
    //头插元素
    LinkListPushFront(&myLinkList, 2);
    LinkListPushFront(&myLinkList, 4);
    LinkListPushFront(&myLinkList, 6);
    LinkListPushFront(&myLinkList, 8);
    //寻找元素位置
    LinkListFindPos(&myLinkList, 7);
    LinkListFindPos(&myLinkList, 2);
    LinkListFindPos(&myLinkList, 5);
    LinkListFindPos(&myLinkList, 9);
    //指定位置之前插入
    LinkListInsertBeforePos(&myLinkList, 3, 6);
    //指定位置之后插入
    LinkListInsertAfterPos(&myLinkList, 3, 4);
    //删除指定位置元素
    LinkListErase(&myLinkList, 2);
    //删除指定元素
    LinkListRemove(&myLinkList, 7);
    //printf("size = %d\n", LinkListSize(&myLinkList));
    //判断链表是否为空 求链表元素个数
    //  if(LinkListEmpty(&myLinkList) == 1)
    //      printf("链表为空\n");
    //  else
    //      printf("size = %d\n", LinkListSize(&myLinkList));

    //顺序打印链表
    LinkListPrint(&myLinkList);
    //逆序打印链表
    printf("=====逆序输出链表=====\n");
    LinkListReversePrint(&myLinkList);
    //头删元素
    LinkListPopFront(&myLinkList);
    LinkListPopFront(&myLinkList);
    //尾删元素
    LinkListPopBack(&myLinkList);
    LinkListPopBack(&myLinkList);
    //不允许遍历链表, 在 pos 之前插入
    Plinklist pos = myLinkList->next->next;
    LinkListInsertBefore(&myLinkList, pos, 18);
    return 0;
}

这里写图片描述

单链表的基本操作---插入，删除，交，并，相邻元素的交换等
weixin_30797027的博客
12-23 215
这个链表是带有表头的单链表。实现链表的一些规范操作，初始化，插入，删除等。包括两个头文件list.h，fatal.h，库函数list.c，测试函数testlist.c。头文件放的都是函数声明，库函数list.c放的的函数的定义。 头文件list.h 1 typedef int ElementType; 2 #ifndef _List_H//如果没有编译过 3 st...
单链表的基本操作！！！
weixin_41445507的博客
06-06 395
//定义typedef int DataType;typedef Sstruct SListNode { DataType data;  struct ListNode *pNext; // 指向下一个结点 } SListNode;//开辟新结点SListNode _GreateNewNode(DataType data){ SListNode*pNewNode = (SListNode*)mal...
精选资源
单链表基本操作.rar
04-01
这个压缩包文件“单链表基本操作.rar”包含了一个名为“单链表基本操作.docx”的文档，我们可以从中学习到关于单链表的各种核心概念和操作。 单链表是由一系列节点构成的线性数据结构，每个节点包含两部分：数据域...
基于Java实现的单链表基本操作之链表排.zip
04-26
在这个基于Java实现的单链表基本操作项目中，我们主要关注的是链表的排序。下面将详细讲解单链表的基本概念、Java中如何实现单链表以及如何进行链表排序。 **一、单链表的基本概念** 单链表是由一系列节点组成的...
基于Java实现的单链表基本操作之链表合并.zip
04-26
本项目聚焦于Java实现的单链表基本操作，特别是链表的合并这一关键操作。下面将详细介绍单链表的概念、基本操作以及如何在Java中实现链表合并。 单链表是一种线性数据结构，每个节点包含两部分：数据域，用于存储...
单链表数据结构，包括单链表定义与特点、单链表的C语言描述、单链表基本形态、单链表基本操作实现、单链表的运用
09-15
单链表基本操作实现主要包含以下几个方面：创建链表、插入节点、删除节点、查找节点、访问节点、链表的清空及销毁等。创建链表通常从空链表开始，通过逐个添加节点进行构建。插入节点操作允许在链表中的任意位置加入...
基于Java实现的单链表基本操作之链表反转.zip
04-26
在这个基于Java实现的单链表基本操作中，我们将重点关注链表反转这一特定操作。 链表反转是编程面试中常见的问题，它要求我们改变链表中节点的顺序，使得原链表的最后一个节点成为新链表的第一个节点，原链表的第一...
单链表的基础操作
eminemi的博客
07-19 2985
在学习数据结构的过程中，首先接触到的就是线性表，线性表中的单链表，博主在一开始的时候真的是一头雾水，首先是对于指针的了解甚浅，其次是觉得这玩意太抽象了。但是后来重新看了之后发现，这玩意儿，也就这样吧！下面，以单链表为例，展开单链表的一些基础操作。...
单链表基本操作
最新发布
09-28
### 单链表的基本操作详解 #### 结构定义 单链表由一系列节点组成，每个节点包含数据域和指向下一个节点的指针域。典型的结构体定义如下： ```c #include #include typedef struct Node { int data; struct ...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值