单链表的尾删、尾插、头插、头删、随机插、删的操作

最新推荐文章于 2022-12-03 22:08:33 发布
原创 最新推荐文章于 2022-12-03 22:08:33 发布 · 2k 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了单链表的基本操作，包括尾部删除、尾部插入、头部插入、头部删除、随机位置插入和删除等。通过实例解析，帮助理解链表数据结构的操作技巧。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

seqlink.h
#include<stdio.h>

#pragma once


//单向链表
//双向链表
//

typedef char LinkNodeType; 

typedef struct LinkNode { 
LinkNodeType data; 
struct LinkNode* next; 
    //next = NULL 结束标志    不带环
    //next = 第一个节点位置   带环
    //
    //带头结点
    //不带头节点
} LinkNode; 

LinkNode* CreatNode(LinkNodeType value);//创造新节点

// 初始化链表 
void LinkListInit(LinkNode** node); 

void LinkListPrintChar(LinkNode* head,const char* msg);

void LinkListDestory(LinkNode** head );
//尾插一个元素到链表中 
void LinkListPushBack(LinkNode** head, LinkNodeType value); 

void LinkListPopBack(LinkNode** head);//尾删

void LinkListPushFrout(LinkNode** head,LinkNodeType value);//头插

void LinkListPopFourt(LinkNode** head);//头删

void LinkListInsert(LinkNode*pos,LinkNodeType value);
    //新节点插入在pos之后
void LinkListEarse(LinkNode** head,LinkNode* pos);//删除指定位置

LinkNode* LinkListFind(LinkNode* head,LinkNodeType value);//查找位置

void LinkListInsertBef(LinkNode** head,LinkNode* pos,LinkNodeType value);
//在pos之前插入元素

void LinkListDelVal(LinkNode** head,LinkNodeType value);//删除指定元素

void LinkListDelAll(LinkNode** head,LinkNodeType value);//删除相同元素

size_t LinkListSize(LinkNode* head);//元素个数


seqlink.c

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

LinkNode* CreatNode(LinkNodeType value)
{
    LinkNode* NewNode = (LinkNode*)malloc(sizeof(LinkNode));
    NewNode->data = value;
    NewNode->next = NULL;
    return NewNode;
}

void DestoryNode(LinkNode* node)
{
    free(node);
}

void LinkListInit(LinkNode** node)
{
    //if(node == NULL)
    //{
    //    //error
    //    printf("非法输入！\n");
    //    return;
    //}
    *node = NULL;
}

void LinkListDestory(LinkNode** head)
{
    if(head == NULL)
    {
        //error
        return;
    }
    if(*head == NULL)
    {
        //空链表
        return;
    }
    LinkNode* cur = *head;
    while(*head)
    {
        cur = (*head)->next;
        DestoryNode(*head);
        *head = cur;
    }
    return;
}

void LinkListPushBack(LinkNode** head,LinkNodeType value)
{
    if(head == NULL)
    {
        //error
        printf("非法输入！\n");
        return;
    }
    if(*head == NULL)
    {
        //printf("空链表\n");
       *head =  CreatNode(value);
        return;
    }
    LinkNode* cur = *head;
    while(cur->next != NULL)
    {
        cur = cur->next;
    }
    LinkNode* NewNode = CreatNode(value);
    cur->next = NewNode;
   // NewNode->next = NULL;没必要    CreatNode中已经实现置空
    return;
}

void LinkListPrintChar(LinkNode* head,const char* msg)
{
    printf("[%s]\n",msg);
    LinkNode* cur = head;
    for(;cur != NULL;cur = cur->next)
    {
        printf("[%c|%p]\t",cur->data,cur);
    }
    printf("\n");
}

void LinkListPopBack(LinkNode** head)
{
    if(head == NULL)
    {
        //error
        return;
    }
    if(*head == NULL)
    {
        //printf("空链表！\n");
        return;
    }
    if((*head)->next == NULL)
    {
        //只有一个元素 
        DestoryNode(*head);
        *head = NULL;
        return;
    }
    LinkNode* pre = NULL;
    LinkNode* cur = *head;
    while(cur->next != NULL)
    {
        pre = cur;
        cur = cur->next;
        //cur指向最后一个节点
        //pre指向倒数第二个节点
    }
    pre->next = NULL;
    DestoryNode(cur);
    return;
}

void LinkListPushFrout(LinkNode** head,LinkNodeType value)
{
    if(head == NULL)
    {
        //error
        return;
    }

    LinkNode* NewNode = CreatNode(value);
    NewNode->next = *head;
    *head = NewNode;
    return;
}

void LinkListPopFourt(LinkNode** head)
{
     if(head == NULL)
    {
        //error
        return;
    }
    if(*head == NULL)
    {
        //空链表
        return;
    }
    LinkNode* cur = *head;
    *head = (*head)->next;
    DestoryNode(cur);
    return;
}


void LinkListInsert(LinkNode*pos,LinkNodeType value)
{
    //if(head == NULL)
    //{
    //    //空链表
    //    return
    //}
    if(pos == NULL)
    {
        //error
        //pos表示节点指针  若为null 不存在节点
        return;
    }
    LinkNode* NewNode = CreatNode(value);
    NewNode->next = pos->next;
    pos->next = NewNode;
    return;
}

void LinkListEarse(LinkNode** head,LinkNode* pos)
{
    if(head == NULL || pos == NULL)
    {
        //error
        return;
    }
    if(*head == NULL)
    {
        //空链表
        return;
    }
    LinkNode* cur = *head;
    for(;cur != NULL;cur= cur->next)
    {
        if(cur->next == pos)
        {
            break;
        }
    }
    //退出原因
    if(cur == NULL)
    {
        return;
    }
    cur->next = pos->next;
    DestoryNode(pos);
}

LinkNode* LinkListFind(LinkNode* head,LinkNodeType value)
{
    if(head == NULL)
    {
        //空链表
        return NULL;
    }
  //找到了返回节点对应的地址，若没有，返回NULL；
    LinkNode* cur = head;
    for(;cur!=NULL;cur=cur->next)
    {
        if(cur->data == value)
        {
            return cur;
        }
    }
    return NULL;
}
void LinkListInsertBef(LinkNode** head,LinkNode* pos,LinkNodeType value)
{
    if(head == NULL)
    {
        //error
        return;
    }
    if(*head == NULL)
    {
        //空链表
        return;
    }
    if(pos == NULL)
    {
        return;
    }
    LinkNode* NewNode = CreatNode(value);
    NewNode->next = pos->next;
    pos->next = NewNode;
    NewNode->data = pos->data;
    pos->data = value;
    return;
}

void LinkListDelVal(LinkNode** head,LinkNodeType value)
{
    if(head == NULL)
    {
        //error
        return;
    }
    if(*head == NULL)
    {
        //error
        return;
    }
    LinkNode* cur = *head;
    LinkNode* pos = LinkListFind(*head,value);
    for(;cur!=NULL;cur=cur->next)
    {
        if(cur->next->data == value)
        break;
    }
    if(cur == NULL)
    {
        return;
    }
    cur->next = pos->next;
    DestoryNode(pos);
}

void LinkListDelAll(LinkNode** head,LinkNodeType value)
{
    if(head == NULL)
    {
        //error
        return;
    }
    if(*head == NULL)
    {
        //error
        return;
    }
    LinkNode* cur = *head;
    while(cur != NULL)
    {
        while(cur->data == value)
        {
            cur = cur->next;
        }
        *head = cur;
        LinkNode* pos = *head;
        cur = cur->next;

        while(cur != NULL)
        {
            if(cur->data != value)
            {
                pos->next = cur;
                pos = pos->next;
            }
            cur = cur->next;
        }
        pos->next = NULL;
        pos = pos->next;
        DestoryNode(pos);
    }
    return;
}

size_t LinkListSize(LinkNode* head)
{
    if(head == NULL)
    {
        //空链表
        return 0;
    }
    LinkNode* pos = head;
    size_t count = 0;
    while(pos != NULL)
    {
        ++count;
        pos = pos->next;
    }
    return count;
}

//Test Code
/////////////////////////////////

void TestInit()
{
    LinkNode* head;
    LinkListInit(&head);
}

void TestPushBack()
{
    LinkNode* head;
    LinkListInit(&head);
    LinkListPushBack(&head ,'a');
    LinkListPushBack(&head ,'b');
    LinkListPushBack(&head ,'c');
    LinkListPushBack(&head ,'d');
    LinkListPrintChar(head,"尾插");
}

void TestPopBack()
{
    LinkNode* head;
    LinkListInit(&head);
    LinkListPopBack(&head);
    LinkListPrintChar(head,"空链表删除");

    LinkListPushBack(&head ,'a');
    LinkListPopBack(&head);
    LinkListPrintChar(head,"只有一个元素删除");

    LinkListPushBack(&head ,'b');
    LinkListPushBack(&head ,'c');
    LinkListPushBack(&head ,'d');
    LinkListPopBack(&head);
    LinkListPrintChar(head,"尾删1个元素");
}

void TestLinkListPushFrout()
{
    LinkNode* head;
    LinkListInit(&head);
    LinkListPushFrout(&head,'a');
    LinkListPushFrout(&head,'b');
    LinkListPushFrout(&head,'c');
    LinkListPushFrout(&head,'d');
    LinkListPrintChar(head,"头插元素");
}

void TestLinkListPopFrout()
{
    LinkNode* head;
    LinkListInit(&head);
    LinkListPrintChar(head,"空链表头删");
    LinkListPushBack(&head,'a');
    LinkListPushBack(&head,'b');
    LinkListPushBack(&head,'c');
    LinkListPopFourt(&head);
    LinkListPrintChar(head,"头删元素");
}

void TestInster()
{
    LinkNode* head;
    LinkListInit(&head);
    LinkListPushBack(&head,'a');
    LinkListPushBack(&head,'b');
    LinkListPushBack(&head,'c');
    LinkNode* pos = head->next;
    LinkListInsert(pos,'x');
    LinkListPrintChar(head,"b之后插入");
}

void TestEarse()
{
    LinkNode* head;
    LinkListInit(&head);
    LinkListPushBack(&head,'a');
    LinkListPushBack(&head,'b');
    LinkListPushBack(&head,'c');
    LinkNode* pos = head->next;
    LinkListEarse(&head,pos);
    LinkListPrintChar(head,"删除b位置的元素");
}

void TestFind()
{
    LinkNode* head;
    LinkListInit(&head);
    LinkListPushBack(&head,'a');
    LinkListPushBack(&head,'b');
    LinkListPushBack(&head,'c');
    LinkListPushBack(&head,'d');
    LinkNode* pos =  LinkListFind(head,'b');
    printf("pos except %p , actual %p\n",head->next,pos);
}

void TestInsterBef()
{
    LinkNode* head;
    LinkListInit(&head);
    LinkListPushBack(&head,'a');
    LinkListPushBack(&head,'b');
    LinkListPushBack(&head,'c');
    LinkListPushBack(&head,'d');
    LinkNode* pos = LinkListFind(head,'d');
    LinkListInsertBef(&head,pos,'x');
    LinkListPrintChar(head,"在d之前插入x");

}

void TestDelVal()
{
    LinkNode* head;
    LinkListInit(&head);
    LinkListPushBack(&head,'a');
    LinkListPushBack(&head,'b');
    LinkListPushBack(&head,'c');
    LinkListPushBack(&head,'d');
    LinkListDelVal(&head,'b');
    LinkListPrintChar(head,"删除元素b");
}

void TestDelAll()
{
    LinkNode* head;
    LinkListInit(&head);
    LinkListPushBack(&head,'a');
    LinkListPushBack(&head,'b');
    LinkListPushBack(&head,'k');
    LinkListPushBack(&head,'k');
    LinkListPushBack(&head,'e');
    LinkListPushBack(&head,'t');
    LinkListDelAll(&head,'a');
    LinkListPrintChar(head,"删除所有a元素");

}

void TestSize()
{
    LinkNode* head;
    LinkListInit(&head);
    LinkListPushBack(&head,'a');
    LinkListPushBack(&head,'b');
    LinkListPushBack(&head,'c');
    LinkListPushBack(&head,'d');
    LinkListPushBack(&head,'a');
    LinkListPushBack(&head,'a');
    size_t ret = LinkListSize(head);
    printf("size = %d\n",ret);
}

void TestDestoryLink()
{
    LinkNode* head;
    LinkListInit(&head);
    LinkListPushBack(&head,'a');
    LinkListPushBack(&head,'b');
    LinkListPushBack(&head,'c');
    LinkListPushBack(&head,'d');
    LinkListPushBack(&head,'a');
    LinkListPushBack(&head,'a');
    LinkListDestory(&head);
    LinkListPrintChar(head,"销毁链表");
}

int main()
{
    TestInit();
    TestPushBack();
    TestPopBack();
    TestLinkListPushFrout();
    TestLinkListPopFrout();
    TestInster();
    TestEarse();
    TestFind();
    TestInsterBef();
    TestDelVal();
    TestDelAll();
    TestSize();
    TestDestoryLink();
    return 0;
}
单向链表 尾插法
m0_46615101的博客
04-21 318
#include <stdio.h> #include <stdlib.h> //malloc函数头文件 //1设计节点(放置数据和指针)不同数据用结构体 //结构体模板 struct node { //结构体内容 int data; struct node* next; //指向下一个节点 ，下一个节点类型为结构体，所以指针类型为struct ...
【数据结构】尾插法和头插法-单链表的创建和销毁
BUG从入门到精通
11-08 1009
前文《【数据结构】链表元素查找、插入和删除-线性表的链式存储》记过了链表的元素查找、插入和删除，本文记链表的创建。 目录 头插法和尾插法概述 代码 头插法 尾插法 其他 测试代码 头插法和尾插法概述 链表的创建有两种方法，一种是头插法（下图），另一种是尾插法。 头插法是直接将头结点的下一个节点交给新节点，然后头结点指向新节点。 尾插法是直接让单链表的最后一个节点的指向新节点，然后让新节点指向NULL。 尾插法时，千万不要忘了最后一个节点指向NULL，否则会出大错！无论什么...
单链表的基本操作头插法尾插法创建插入删除遍历
12-08
单链表的基本操作，单链表头插法、尾插法、创建、插入、删除、遍历
链表的头删
laly123321的博客
09-08 350
package com.monkey1024; class Node{ int val; Node next; Node (int val){ this.val=val; this.next=null; } } public class test01 { public static Node pushFron...
链表的头插、尾插、头删、尾删
fll980205的博客
05-06 1883
头插：将一个结点头插到一个链表中，比如：原来链表中元素为：b ->c->d，要将结点a头插到原来链表中，则要让a的下一个结点（next）为b，即a.next=b，在链表中b就为头结点head，所以a.next=head;然后再使a成为链表的头结点：head=a； //头插 结点node private void addFront(Node node){ n...
删除链表最后尾节点（1319 P103）
热门推荐
hacker_crazy的专栏
08-12 1万+
问题：删除一个链表最后一个节点，只知道首节点first. 思路：因为只知道首节点，所以只能历遍链表，找到最后两个节点，将倒数第二个节点的next定义为null，无法关联最后一个节点，就可以实现。（之所以不直接让最后一个为空，是为了保证准确性） 代码： package chapter1.a3; public class Example1319 { priva
线性表基本操作，单链表的建立(头插法，尾插法)、插入、删除、遍历操作的实现（c++ 数据结构 实验二）
weixin_44790790的博客
11-15 3044
大学数据结构课程的实验题目，掌握线性表的链接存储结构，用c++语言描述 一、实验要求 1.分别用头插法和尾插法建立一个含有若干结点的单链表 2.对已建立的单链表进行插入、删除、遍历输出等操作 二、代码： #include<iostream> #include <stdlib.h> using namespace std; template <class DataType> //模板声明 struct Node {
C++单链表实现：头插法与尾插法详解
资源摘要信息:"cpp代码-单链表的建立（头插法、尾插法）" 知识点： 1. 单链表的基本概念 单链表是一种基本的数据结构，由一系列节点组成，每个节点包含两个部分：一部分存储数据，另一部分存储指向下一个节点的...
关于单链表的增删查改等操作（c语言版）
BUDAXIHUANCHICU的博客
08-09 2904
单链表的一系列操作（含菜单）
关于链表的尾节点删除
垂皎的博客
04-23 1455
创建两个节点 void delete(LinkList &L){ LNode *p=L; LNode *q; while(p->next!=NULL){ q=p; p=p->next; } q->next=NULL; delete§； }
单链表、删除、头插法、尾插法
04-16
大家都来看看吧，很好的看看吧，啊 啊 啊啊啊啊啊 啊 啊啊啊 啊 啊 啊 啊 啊啊啊啊
单链表插入、删除、头插法、尾插法
04-16
单链表插入的很好的学习材料，大家都来看看
单向链表的尾删
laly123321的博客
09-16 1081
链表的尾删依然分为空链表和非空链表，对于空链表来说，链表中没有节点无法删除，所以直接返回null，对于非空链表，要实现链表的尾删就要找到倒数第二个节点，让倒数第二个节点的next指向null，这样就实现了删除最后一个节点，最后返回链表的头节点head. public class Node { int val; Node next=null; Node(int val)...
单链表--删除尾节点
weixin_47311994的博客
08-02 4788
目的：删除一个链表中的末尾节点。 实现思路：新建一个指向头节点的节点。遍历循环链表，直到找到链表尾节点，让新建的节点的next为空，尾节点的value为null，再把新建的节点更新至尾节点的位置。 public void removeTail() { if(head==null){//链表为空 return; } else if(size==1){//只有一个节点 head.value=null; head=null;
python链表删除尾部节点_删除单链表最后一个节点
weixin_34666714的博客
02-21 3791
从链表的末尾删除节点，有两种情况。链表中只有一个节点，需要删除。链表中有多个节点，链表的最后一个节点将被删除。1. 链表中只有一个节点条件head → next = NULL将继续存在，因此，链表的唯一节点head将被指定为null。 这将通过使用以下语句来完成。ptr = head;head = NULL;free(ptr);2. 链表中有多个节点条件head→next = NULL将失败，因此...
单链表——移除单链表中的元素
wshuoi的博客
12-03 489
移除链表中的元素
单向链表的头删
laly123321的博客
09-16 397
链表的头删分为空链表和非空链表两种情况，对于空链表，链表中一个节点都没有，所以无法删除，返回null，对于非空链表，头删就是让head(头节点)指向head的下一个节点，这样原来的头节点就被删除，此时head指向的节点就是删除原来头节点之后的头节点，直接返回现在的head即可。 public class Node { int val; Node next=null; N...
单向链表的头插法和尾插法
chengchaonan的博客
03-25 634
#include #include typedef int data_t; typedef struct node{ data_t data; struct node *next; }list; list *list_head() { list *q=(list *)malloc(sizeof(list)); q->next=NULL; return q;
单链表操作
LYHVOYAGE的专栏
08-08 1022
typedef struct LNode { int data; struct LNode *next; } LNode; void CreateF(LNode *&L, int n) //头插法创建链表 { int i; LNode *p; L = (LNode *)malloc(sizeof(LNode)); L->next = NULL;
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值