无头结点无环的单链表实现

最新推荐文章于 2023-03-21 20:21:56 发布
最新推荐文章于 2023-03-21 20:21:56 发布
阅读量221 收藏
点赞数
分类专栏： 日常练习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/erwuhuoche/article/details/79701036
版权 
//linklist.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "linklist.h"

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

//初始化链表
void LinkListInit(LinkNode** phead) {
    if (phead == NULL) {
        return;
    }
    *phead = NULL;
}

//LinkListInit的测试代码
void TestPrintChar(LinkNode* phead, char* msg) {
    printf("%s\n", msg);
    if (phead == NULL) {
        return;
    }
    LinkNode* cur = phead;
    for (; cur != NULL; cur = cur->next) {
        printf("[%c | %p] ->", cur->data, cur->next);
    }
    printf("\n");
}


//创建一个新结点
LinkNode* LinkNodeCreate(LinkNodeType value) {
    LinkNode* new_node = (LinkNode*)malloc(sizeof(LinkNode));
    new_node->data = value;
    new_node->next = NULL;
}

//销毁一个结点
void LinkNodeDestroy(LinkNode** phead) {
    free(*phead);
    *phead = NULL;
}

//尾插一个元素

void LinkListPushBack(LinkNode** phead, LinkNodeType value) {
    if (phead == NULL) {
        return;//非法输入
    }
    if (*phead == NULL) {
        LinkNode* new_node = LinkNodeCreate(value);
        *phead = new_node;
        return;
    }
    LinkNode* cur = *phead;
    for (; cur->next != NULL; cur = cur->next) {
    }
    LinkNode* new_node = LinkNodeCreate(value);
    cur->next = new_node;
}

//尾删一个元素
void  LinkListPopBack(LinkNode** phead) {
    if (phead == NULL) {
        return;//非法输入
    }
    if (*phead == NULL) {
        return;//空链表
    }
    LinkNode* cur = *phead;
    if (cur->next == NULL) {//只有一个结点
        LinkNodeDestroy(phead);
        return;
    }
    for (; cur->next->next != NULL; cur = cur->next) {
    }
    LinkNodeDestroy(&(cur->next));
}

//头插
void LinkListPushFront(LinkNode** phead, LinkNodeType value) {
    if (phead == NULL) {
        return;//非法输入
    }
    if (*phead == NULL) {
        LinkListPushBack(phead, value);
        return;
    }
    LinkNode* new_head= LinkNodeCreate(value);
    new_head->next = *phead;
    *phead = new_head;
}


//LinkListPushFront测试代码
void TestPushFront() {
    TESTHEADER;
    LinkNode* head;
    LinkListInit(&head);
    LinkListPushFront(&head, 'a');
    LinkListPushFront(&head, 'b');
    LinkListPushFront(&head, 'c');
    LinkListPushFront(&head, 'd');
    TestPrintChar(head, "头插四个元素");
}

//头删
void LinkListPopFront(LinkNode** phead) {
    if (phead == NULL) {
        return;//非法输入
    }
    if (*phead == NULL) {
        return;//空链表
    }
    if ((*phead)->next == NULL) {
        LinkListPopBack(phead);
        return;
    }
    LinkNode* new_head = *phead;
    *phead = new_head->next;
    LinkNodeDestroy(&new_head);
}

//LinkListPopFront测试代码
void TestPopFront() {
    TESTHEADER;
    LinkNode* head;
    LinkListInit(&head);
    LinkListPopFront(&head);
    TestPrintChar(head, "头删空链表");

    LinkListPushFront(&head, 'a');
    TestPrintChar(head, "头插一个元素");
    LinkListPopFront(&head);
    TestPrintChar(head, "头删一个元素");
}

//查找指定元素（to_find）
LinkNode* LinkListFind(LinkNode* phead, LinkNodeType to_find){
    if (phead == NULL){
        return NULL;//非法输入
    }
    LinkNode* cur = phead;
    for (; cur != NULL; cur = cur->next){
        if (cur->data == to_find){
            return cur;
        }
    }
    return NULL;
}

//LinkListFind测试代码
void TestFind()
{
    TESTHEADER;
    LinkNode* head;
    LinkListInit(&head);
    LinkListPushFront(&head, 'b');
    LinkListPushFront(&head, 'a');
    LinkListPushFront(&head, 'c');
    LinkListPushFront(&head, 'd');
    LinkListPushFront(&head, 'e');
    LinkListPushFront(&head, 'f');
    LinkNode* ret = LinkListFind(head, 'a');
    TestPrintChar(head, "头插六个元素");
    printf("&a = %p\n", ret);
}

//在指定位置元素（pos）前插入新元素（value）
void LinkListInsert(LinkNode** phead, LinkNode* pos, LinkNodeType value){
    if (phead == NULL){
        return;//非法输入
    }
    if (*phead == NULL || (*phead)->next == NULL){
        LinkListPushFront(phead, value);
        return;
    }
    LinkNode* cur = *phead;
    LinkNode* new_node = LinkNodeCreate(value);
    while (1)
    {
        if (cur->next == pos){
            new_node->next = pos;
            cur->next = new_node;
            return;
        }
        cur = cur->next;
    }
}

//LinkNodeInsert测试代码
void TestInsert()
{
    TESTHEADER;
    LinkNode* head;
    LinkListInit(&head);
    LinkListPushFront(&head, 'a');
    LinkListPushFront(&head, 'c');
    LinkListPushFront(&head, 'd');
    LinkListPushFront(&head, 'e');
    LinkListPushFront(&head, 'f');
    LinkListInsert(&head, head->next, '1');
    TestPrintChar(head, "往e前面插入元素‘1’：");
}

//在指定位置元素（pos）后插入一个新元素（value）
void LinkListInsertAfter(LinkNode** phead, LinkNode* pos, LinkNodeType value){
    if (phead == NULL){
        return;//非法输入
    }
    if (*phead == NULL){
        LinkListPushBack(phead, value);
        return;
    }

    LinkNode* new_node = LinkNodeCreate(value);
    new_node->next = pos->next;
    pos->next = new_node;
}

//LinkListInsertAfter测试代码
void TestInsertAfter()
{
    TESTHEADER;
    LinkNode* head;
    LinkListInit(&head);
    LinkListPushFront(&head, 'a');
    LinkListPushFront(&head, 'c');
    LinkListPushFront(&head, 'd');
    LinkListPushFront(&head, 'e');
    LinkListPushFront(&head, 'f');
    LinkListInsertAfter(&head, head->next->next, '1');
    TestPrintChar(head, "往d后面插入元素‘1’：");
}

//删除指定位置(pos)元素
void LinkListEraser(LinkNode** phead, LinkNode* pos){
    if (phead == NULL || pos == NULL){
        return;//非法输入
    }
    if (*phead == NULL){
        return;//链表为空
    }
    if ((*phead)->next == NULL){
        LinkNodeDestroy(phead);
        return;
    }
    LinkNode* cur = *phead;
    while (cur->next != pos){
        cur = cur->next;
    }
    LinkNode* to_eraser = cur->next;
    LinkNodeDestroy(&pos);
    cur->next = to_eraser->next;
}

//LinkListEraser测试代码

void TestEraser(){
    LinkNode* head;
    LinkListInit(&head);
    LinkListPushFront(&head, 'a');
    LinkListPushFront(&head, 'c');
    LinkListPushFront(&head, 'd');
    LinkListPushFront(&head, 'e');
    LinkListPushFront(&head, 'f');
    TestPrintChar(head, "头插5个元素：");
    LinkListEraser(&head, head->next);
    TestPrintChar(head, "删除e:");
}

//不遍历在指定位置前插入一个元素
void LinkNodeInsertBefor(LinkNode** phead, LinkNode* pos, LinkNodeType value){
    if (phead == NULL || pos == NULL){
        return;//非法输入
    }
    if (*phead == NULL){
        LinkListPushFront(phead, value);
        return;
    }
    LinkNode* new_node = LinkNodeCreate(value);
    new_node->data = pos->data;
    pos->data = value;
    new_node->next = pos->next;
    pos->next = new_node;
}

//LinkNodeInsertBefor测试代码

void TestInsertBefor(){
    TESTHEADER;
    LinkNode* head;
    LinkListInit(&head);
    LinkListPushFront(&head, 'a');
    LinkListPushFront(&head, 'c');
    LinkListPushFront(&head, 'd');
    LinkListPushFront(&head, 'e');
    LinkListPushFront(&head, 'f');
    LinkListInsert(&head, head->next, '1');
    TestPrintChar(head, "往e前面插入元素‘1’：");
}

//删除指定值元素
void LinkListRemove(LinkNode** phead, LinkNodeType to_delete){
    if (phead == NULL){
        return;//非法输入
    }
    if (*phead == NULL){
        return;//链表为空
    }
    LinkNode* cur;
    cur = *phead;
    while (cur != NULL){
        if (cur->data == to_delete){
            break;
        }
        cur = cur->next;
    }
    if (cur == NULL){
        return;
    }
    LinkListEraser(phead, cur);
    return;
}

//LinkListRemove测试代码
void TestRemove(){
    TESTHEADER;
    LinkNode* head;
    LinkListInit(&head);
    LinkListInit(&head);
    LinkListPushFront(&head, 'a');
    LinkListPushFront(&head, 'c');
    LinkListPushFront(&head, 'd');
    LinkListPushFront(&head, 'e');
    LinkListPushFront(&head, 'f');
    TestPrintChar(head, "插入5个元素：");
    LinkListRemove(&head, 'e');
    TestPrintChar(head, "删除‘e’：");
}

//删除指定值所有元素

void LinkListRemoveAll(LinkNode** phead, LinkNodeType value){
    if (phead == NULL){
        return;//非法输入
    }
    if (*phead == NULL){
        return;//链表为空
    }
    LinkNode* cur = *phead;
    while (cur != NULL){
        if (cur->data == value){
            LinkListRemove(phead, value);
        }
        cur = cur->next;
    }
}

//LinkListRemove测试代码
void TestRemoveAll(){
    TESTHEADER;
    LinkNode* head;
    LinkListInit(&head);
    LinkListPushFront(&head, 'a');
    LinkListPushFront(&head, 'c');
    LinkListPushFront(&head, 'd');
    LinkListPushFront(&head, 'a');
    LinkListPushFront(&head, 'c');
    LinkListPushFront(&head, 'd');
    LinkListPushFront(&head, 'a');
    LinkListPushFront(&head, 'c');
    LinkListPushFront(&head, 'd');
    TestPrintChar(head, "插入9个元素");
    LinkListRemoveAll(&head, 'a');
    TestPrintChar(head, "删除链表中的'a':");
}

//链表元素和
size_t LinkNodeSize(LinkNode* phead){
    if (phead == NULL){
        return 0;
    }
    int count = 0;
    LinkNode* cur = phead;
    for (; cur != NULL; cur = cur->next){
        count++;
    }
    return count;
}

//LinkNodeSize测试代码
void TestSize(){
    LinkNode* head;
    LinkListInit(&head);
    LinkListPushFront(&head, 'a');
    LinkListPushFront(&head, 'c');
    LinkListPushFront(&head, 'd');
    LinkListPushFront(&head, 'a');
    LinkListPushFront(&head, 'c');
    LinkListPushFront(&head, 'd');
    LinkListPushFront(&head, 'a');
    LinkListPushFront(&head, 'c');
    LinkListPushFront(&head, 'd');
    int count = 0;
    count = LinkNodeSize(head);
    printf("expected count = %d, actuall count = %d\n", 9, count);
}


int main() {
    TestCreat();
    TestPushFront();
    TestPopFront();
    TestFind();
    TestInsert();
    TestInsertAfter();
    TestEraser();
    TestInsertBefor();
    TestRemove();
    TestRemoveAll();
    TestSize();
    return 0;
}

//linklist.h
#pragma once

typedef char LinkNodeType;

typedef struct LinkNode {
    LinkNodeType data;
    struct LinkNode* next;
}LinkNode;

typedef LinkNode* PLinkNode;

void LinkListInit(LinkNode** phead);

void LinkListPushBack(LinkNode** phead, LinkNodeType value);

LinkNode* LinkNodeCreate(LinkNodeType value);

void LinkListPopFront(LinkNode** phead);

void LinkListPushFront(LinkNode** phead, LinkNodeType value);

void LinkListPopBack(LinkNode** phead);

void LinkNodeDestroy(LinkNode** phead);

LinkNode* LinkListFind(LinkNode* phead, LinkNodeType to_find);

void LinkListInsert(LinkNode** phead, LinkNode* pos, LinkNodeType value);

void LinkListInsertAfer(LinkNode** phead, LinkNode* pos, LinkNodeType value);

void LinkListInsertBefor(LinkNode** phead, LinkNode* pos, LinkNodeType value);

void LinkListEraser(LinkNode** phead, LinkNode* pos);

void LinkListRemove(LinkNode** phead, LinkNodeType to_delet);

void LinkListRemoveAll(LinkNode** phead, LinkNodeType value);

void LinkListSize(LinkNode* phead);
猫呢被鱼吃了吗
关注
专栏目录
c实现无头结点单链表
rzzrwjh的博客
06-21 591
头文件 #ifndef __LINKLIST_H__ #define __LINKLIST_H__ #include #include #include #include typedef int DataType; typedef struct Node { DataType _data; struct Node* _next; }Node,*pNode,*pList;
无头结点的单链表（java实现）
huxing0501的专栏
09-01 748
import java.util.Random; class Node { int data; Node next; Node(int data) { this.data = data; next = null; } } class List { Node first = null; List(int n) { Random rand = new
无头结点链表实现
12-01
用C++简单实现无头结点的建表，插入，删除操作
无头结点链表
qq_38417856的博客
02-20 348
linklist.c文件: #include<stdio.h> #include"linklist.h" struct Node* Create_LinkList()//Creat_Linklist:根据用户输入,创建一个单链表 { ElemType num; struct Node* first=NULL; struct Node* last=NULL; while (1) { sc...
无头结点的链表
weixin_41807122的博客
03-18 422
#include "stdio.h" #include "stdlib.h" typedef struct LNode { int data; struct LNode *next; } LNode; typedef LNode* LinkedList; LinkedList create_list() { LinkedList ls = 0; LNod...
无头结点的单链表
最新发布
明里灰的博客
03-21 591
先来了解头结点是什么：头结点是在首元结点之前设的一个结点，其 next 指针指向首元结点，其数据域可以不存储任何信息，但是头结点一定指向是链表中第一个结点的指针，而且头指针不能变。无头结点时，如果增加的元素放在第一个结点前，或者删除第一个结点时，要换新的首元结点，此时要用到二级指针。有头结点时，对链表的第一个数据元素的操作（插入、删除）与其他的数据元素相同，无需进行特殊处理。无论链表是否为空，头指针都是非空指针，指向首元结点。首先，无头结点的链表和有头结点的链表有什么区别呢？
在无头结点的动态单链表上实现线性表操作 INSERT(L, i, B)，并和在带头结点的动态单链表上实现相同操作的算法进行比较。
qq_41109668的博客
02-28 2855
题目： 在无头结点的动态单链表上实现线性表操作 INSERT(L, i, B)，并和在带头结点的动态单链表上实现相同操作的算法进行比较。 分析： 首先我们要先初始化一个单链表，接下来要给这个单链表中添加数据元素，最后再在某一位置前插入某一数据元素 代码： 链表初始化： #include<stdio.h> #include<stdlib.h> #define ...
在无头结点的动态单链表上实现线性表操作DELETE(L, i)，并和在带头结点的动态单链表上实现相同操作的算法进行比较
qq_41109668的博客
02-28 940
题目： 在无头结点的动态单链表上实现线性表操作DELETE(L, i)，并和在带头结点的动态单链表上实现相同操作的算法进行比较 分析： 删除节点的操作一般步骤为：找到该节点的直接前驱，然后使其直接前驱的 next 指向该节点的直接后继 代码： 初始化： #include<stdio.h> #include<stdlib.h> #define OK 1 ty...
在无头结点的动态单链表上实现线性表操作Insert(L,i,b)
积极奋斗的蜗牛
04-09 8984
在无头结点的动态单链表上实现线性表操作Insert(L,i,b) 单链表类型定义如下：
无头结点链表的建立
04-09
本程序所实现的功能： 1.建立无头结点的线性链表 2.成功运行LOCATE（L，X）函数 3.成功运行DELETE（L，i）函数 4.成功运行INSERT（L，i，x）函数
在无头结点的动态单链表上实现线性表操作Delete(L,i)
积极奋斗的蜗牛
04-09 3987
在无头结点的动态单链表上实现线性表操作DELETE(L,i)
无头结点单链表删除
m0_53591689的博客
06-26 415
1
无头结点的链表实现
LX370ZZZ的博客
08-05 470
链表的插入(任何位置): int Link1Insert(Node **l, int p, int e) { int i = 1, count = 1; if((NULL == *l) &amp;&amp; (p == 1)) { (*l) = (Node *)malloc(sizeof(Node)); (*l)-&gt;next = N...
无环单链表+无环单链表--相交
Alice_lihao的博客
06-03 309
单链表+单链表–相交 判断相交 若末节点相同则相交，不相同则不相交 求解相交点 1.遍历链表 目的：移动链表到最后一个节点判断是否相交+判断链表长度； 2.将长链表向下移动两链表差值个节点 3.用两个指针从短链表的头和长链表的当前位置（头位置向下移动两链表差值的位置）开始移动；从头开始判断是否相等，然后每移动一次判断连个链表是否相等，若相等，当前节点位置则为两链表相交位置； ...
无环单链表+有环单链表（有环单链表+无环单链表）
Alice_lihao的博客
06-03 344
无环单链表+有环单链表or有环单链表+无环单链表 判断相交 必定不相交
无头节点--单链表
qq_53010164的博客
04-01 1998
目录 一、单链表打印： 二、增容 三、单链表尾插 四、单链表头插 五、单链表尾删 六、单链表头删 七、单链表的查找 八、单链表在pos之后插入X 九、单链表在pos之前插入X 十、删除pos位置 十一、删除pos之后的位置 十二、销毁链表 总代码： Slistexe.h Slistexe.c test.c 部分运行结果：​ 一、单链表打印： //打印 void SListprint(SL* phead) { SL* cur = phead; whil...
创建一个没有头结点的单链表（附完整代码）
HPAlways的博客
03-13 1500
两种链表创建的方法
小白学编程之单向链表（无头节点）
Super_Market_Z的博客
08-20 854
小白学编程之单向链表（无头节点）
C语言无头结点单链表实现与接口详解
在C语言中实现单链表是数据结构编程的基础之一，这里主要关注不带头节点的单向链表。首先，我们定义了基本的数据类型`DataType`和链表节点结构`Node`，其中包含指向数据`data`的指针和指向下一个节点的指针`next`。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值