C++单链表头插法和尾插法实现

最新推荐文章于 2024-05-16 12:21:36 发布
最新推荐文章于 2024-05-16 12:21:36 发布
阅读量494 收藏 9
点赞数 5
分类专栏： 数据结构 文章标签： c++ 数据结构 算法 链表 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cbzwq1314/article/details/137978472
版权

C++单链表头插法和尾插法实现

简介

​ 这份笔记介绍了一个用 C++ 实现的单链表，提供了两种常见的链表构建方法：头插法和尾插法。单链表是一种基础而重要的数据结构，它由一系列节点组成，每个节点包含了数据元素和指向下一个节点的指针。这份实现通过结构体 LNode 和指针 LinkList 来定义链表节点和链表，其中 ElemType 类型定义了节点中存储的数据类型，Status 则定义了操作的状态码。

​ 在实现中，常量和宏定义被用于提高代码的可读性和可维护性，如 MAXSIZE 定义了链表的最大容量，各种状态码则方便了对操作结果的判断。

​ 此外，提供了一系列操作函数，包括链表的初始化、判空、销毁、清空以及使用头插法和尾插法建立链表，还有一些基本的操作，如插入、删除、按位查找和按值查找等。这些函数为使用者提供了丰富的链表操作接口，方便了链表的创建、修改和查询。

​ 通过这份笔记，读者可以学习到如何使用 C++ 实现单链表，并了解到链表的基本操作和常用技巧，为进一步深入学习和应用链表打下了良好的基础。

数据结构和定义

  • struct LNode：定义了链表中的节点，包含一个数据元素和指向下一个节点的指针。
typedef struct LNode {
    ElemType data;//数据域
    LNode* next;//指针域
}LNode,*LinkList;

  • typedef int ElemType：定义了节点中存储的数据类型。

  • typedef int Status：定义了操作的状态码。

  • typedef struct LNode* LinkList：定义了指向链表节点的指针。

  • 常量：

    • MAXSIZE：链表的最大容量。
    • ERROR、TRUE、FALSE、OK：操作状态码。

  • 宏定义

#define MAXSIZE 100 // 顺序表最大容量
#define ERROR 0 // 错误状态码
#define TRUE 1 // 真状态码
#define FALSE 0 // 假状态码
#define OK 1 // 正确状态码
#define INFEASIBLE -1 // 不可行状态码
#define OVERFLOW -2 // 溢出错误状态码

typedef int ElemType;
typedef int Status;

函数说明

  • Status InitList(LinkList &L): 初始化链表，创建头结点。
  • int isEmpty(LinkList &L): 判断链表是否为空。
  • Status DestoryList(LinkList &L): 销毁链表。
  • Status ClearList(LinkList &L): 清空链表。
  • void H_Insert(LinkList &L, int n): 使用头插法建立链表（指定长度）。
  • void H_Insert(LinkList &L): 使用头插法建立链表（不知道长度）。
  • void L_Insert(LinkList &L, int n): 使用尾插法建立链表（指定长度）。
  • void L_Insert(LinkList &L): 使用尾插法建立链表（不知道长度）。
  • void PrintList(LinkList L): 打印链表。
  • int GetLength(LinkList L): 获取链表长度。
  • Status List_Insert(LinkList &L, int x, ElemType e): 在指定位置插入元素。
  • ElemType FindByPos(LinkList &L, int x): 按位查找元素值。
  • int FindByVal(LinkList &L, int val): 按值查找元素位置。
  • ElemType ListDelte(LinkList &L, int x): 删除指定位置的元素。

函数详解

Status InitList(LinkList &L) 初始化链表，创建头结点。

Status InitList(LinkList &L) {
    L=new LNode;//创建头结点,.返回一个指针直接给L就行了
    L->next=NULL;
    return OK;
}

int isEmpty(LinkList &L) 判断链表是否为空。

int isEmpty(LinkList &L) {
    if(L->next) {//feikonh
        return 0;
    }else {
        return 1;
    }
}

Status DestoryList(LinkList &L) 销毁链表。

Status DestoryList(LinkList &L) {
    while(L) {
        LinkList p=L;
        delete p;
        L=L->next;
    }
    return OK;
}

Status ClearList(LinkList &L) 清空链表。

Status ClearList(LinkList &L) {
    while(L->next) {
        LinkList p=L->next,q;
        q=p->next;
        delete p;
        p=q;
    }

    return OK;
}

void H_Insert(LinkList &L, int n) 使用头插法建立链表（指定长度）。

void H_Insert(LinkList &L, int n) {
    cout<<"please input "<<n<<" num:"<<endl;
    L->data=0;
    for(int i=0;i<n;i++) {
        LinkList p=new LNode;
        int k;
        cin>>k;
        p->data=k;
        p->next=L->next;
        L->next=p;
        L->data++;
    }
}

void H_Insert(LinkList &L) 使用头插法建立链表（不知道长度）。

void H_Insert(LinkList &L) {
    L->data=0;
    int x;
    cout<<"请连续输入要插入链表的值,输入一个按下回车,输入9999结束输入:"<<endl;
    cin>>x;
    while(x!=9999){
        LinkList p=new LNode;
        p->data=x;
        p->next=L->next;
        L->next=p;
        L->data++;
        cin>>x;
    }
}

void L_Insert(LinkList &L, int n) 使用尾插法建立链表（指定长度）。

void L_Insert(LinkList &L, int n) {
    L->data=n;
    cout<<"please input "<<n<<" num:"<<endl;
    LinkList r=L;
    for(int i=0;i<n;i++) {
        LinkList p=new LNode;
        int data;
        cin>>data;
        p->data=data;
        // p->next=r->next;
        r->next=p;
        r=p;
    }
    r->next=NULL;
}

void L_Insert(LinkList &L) 使用尾插法建立链表（不知道长度）。

void L_Insert(LinkList &L) {
    L->data=0;
    LinkList r=L;
    cout<<"请连续输入要插入链表的值,输入一个按下回车,输入9999结束输入:"<<endl;
    int x;
    cin>>x;
    while(x!=9999){
        LinkList p=new LNode;
        p->data=x;
        // p->next=r->next;
        r->next=p;
        r=p;
        L->data++;
        cin>>x;
    }
    r->next=NULL;
}

void PrintList(LinkList L) 打印链表。

void PrintList(LinkList L) {
    cout<<"the length of the list is : "<<L->data<<endl;
    LinkList p=L->next;
    int i=1;
    while(p!=NULL) {
        cout<<"the "<<i<<"TH element is "<<p->data<<endl;
        p=p->next;
        i++;
    }
}

int GetLength(LinkList L) 获取链表长度。

int GetLength(LinkList L) {
    int i=0;
    LinkList p=L->next;
    while(p) {
        i++;
        p=p->next;
    }
    return i;
}

Status List_Insert(LinkList &L, int x, ElemType e) 在指定位置插入元素。

Status List_Insert(LinkList &L, int x, ElemType e) {
    if(x<=0||x>L->data) return ERROR;
    LinkList p=new LNode;
    LinkList q=L;
    p->data=e;
    for(int i=1;i<x;i++) {
        q=q->next;
    }
    p->next=q->next;
    q->next=p;
    L->data++;
    return OK;
}

ElemType FindByPos(LinkList &L, int x) 按位查找元素值。

ElemType FindByPos(LinkList &L, int x) {
    LinkList p=L;
    if(x<=0||x>L->data) return ERROR;
    for(int i=0;i<x;i++) {
        p=p->next;
    }
    return p->data;
}

int FindByVal(LinkList &L, int val) 按值查找元素位置。

int FindByVal(LinkList &L, int val) {
    LinkList p=L;
    for(int i=0;i<L->data;i++) {
        p=p->next;
        if(p->data==val) {
            return i+1;
        }
    }
    cout<<"此链表中没有此值"<<endl;
    return ERROR;
}

ElemType ListDelte(LinkList &L, int x) 删除指定位置的元素。

ElemType ListDelte(LinkList &L, int x) {
    LinkList p=L;
    for(int i=1;i<x;i++) {
        p=p->next;
    }
    LinkList q=p->next;
    p->next=q->next;
    ElemType e=q->data;
    L->data--;
    delete q;
    return e;
}

完整单链表实现代码

#include <iostream>
using namespace std;

// 定义一些常用的符号常量
#define MAXSIZE 100 // 顺序表最大容量
#define ERROR 0 // 错误状态码
#define TRUE 1 // 真状态码
#define FALSE 0 // 假状态码
#define OK 1 // 正确状态码
#define INFEASIBLE -1 // 不可行状态码
#define OVERFLOW -2 // 溢出错误状态码

typedef int ElemType; // 定义数据类型ElemType为int
typedef int Status; // 定义状态类型Status为int

// 定义链表结点结构体
typedef struct LNode {
    ElemType data; // 数据域
    LNode* next; // 指针域
}LNode,*LinkList;

// 初始化链表
Status InitList(LinkList &L) {
    L=new LNode; // 创建头结点
    L->next=NULL; // 头结点的next指针置空
    return OK; // 返回正确状态码
}

// 判断链表是否为空
int isEmpty(LinkList &L) {
    if(L->next) { // 头结点的next指针不为空则链表非空
        return 0; // 返回0表示非空
    }else {
        return 1; // 返回1表示空
    }
}

// 销毁单链表
Status DestoryList(LinkList &L) {
    while(L) {
        LinkList p=L;
        delete p;
        L=L->next; // 向后移动指针
    }
    return OK;
}

// 清空单链表
Status ClearList(LinkList &L) {
    while(L->next) {
        LinkList p=L->next,q;
        q=p->next;
        delete p;
        p=q; // 向后移动指针
    }
    return OK;
}

// 头插法建立链表
void H_Insert(LinkList &L,int n) {
    cout<<"please input "<<n<<" num:"<<endl;
    L->data=0; // 初始化链表长度为0
    for(int i=0;i<n;i++) {
        LinkList p=new LNode;
        int k;
        cin>>k;
        p->data=k;
        p->next=L->next; // 将新节点的next指针指向头结点的next指针所指向的节点
        L->next=p; // 将头结点的next指针指向新节点
        L->data++; // 链表长度加1
    }
}

// 头插法建立链表（不指定长度）
void H_Insert(LinkList &L) {
    L->data=0; // 初始化链表长度为0
    int x;
    cout<<"请连续输入要插入链表的值,输入一个按下回车,输入9999结束输入:"<<endl;
    cin>>x;
    while(x!=9999){
        LinkList p=new LNode;
        p->data=x;
        p->next=L->next; // 将新节点的next指针指向头结点的next指针所指向的节点
        L->next=p; // 将头结点的next指针指向新节点
        L->data++; // 链表长度加1
        cin>>x;
    }
}

// 尾插法建立链表
void L_Insert(LinkList &L,int n) {
    L->data=n; // 设置链表长度为n
    cout<<"please input "<<n<<" num:"<<endl;
    LinkList r=L;
    for(int i=0;i<n;i++) {
        LinkList p=new LNode;
        int data;
        cin>>data;
        p->data=data;
        r->next=p; // 将尾节点的next指针指向新节点
        r=p; // 将尾节点指针指向新节点
    }
    r->next=NULL;
}

// 尾插法建立链表（不指定长度）
void L_Insert(LinkList &L) {
    L->data=0; // 初始化链表长度为0
    LinkList r=L;
    cout<<"请连续输入要插入链表的值,输入一个按下回车,输入9999结束输入:"<<endl;
    int x;
    cin>>x;
    while(x!=9999){
        LinkList p=new LNode;
        p->data=x;
        r->next=p; // 将尾节点的next指针指向新节点
        r=p; // 将尾节点指针指向新节点
        L->data++; // 链表长度加1
        cin>>x;
    }
    r->next=NULL;
}

// 打印链表
void PrintList(LinkList L) {
    cout<<"the length of the list is : "<<L->data<<endl;
    LinkList p=L->next;
    int i=1;
    while(p!=NULL) {
        cout<<"the "<<i<<"TH element is "<<p->data<<endl;
        p=p->next; // 向后移动指针
        i++;
    }
}

// 获取链表长度
int GetLength(LinkList L) {
    int i=0;
    LinkList p=L->next;
    while(p) {
        i++;
        p=p->next; // 向后移动指针
    }
    return i;
}

// 在指定位置插入元素
Status List_Insert(LinkList &L,int x,ElemType e) {
    if(x<=0||x>L->data) return ERROR;
    LinkList p=new LNode;
    LinkList q=L;
    p->data=e;
    for(int i=1;i<x;i++) {
        q=q->next; // 向后移动指针
    }
    p->next=q->next; // 新节点的next指针指向q的下一个节点
    q->next=p; // 将q的next指针指向新节点
    L->data++; // 链表长度加1
    return OK;
}

// 按位查找元素值
ElemType FindByPos(LinkList &L,int x) {
    LinkList p=L;
    if(x<=0||x>L->data) return ERROR;
    for(int i=0;i<x;i++) {
        p=p->next; // 向后移动指针
    }
    return p->data;
}

// 按值查找元素位置
int FindByVal(LinkList &L,int val) {
    LinkList p=L;
    for(int i=0;i<L->data;i++) {
        p=p->next;
        if(p->data==val) {
            return i+1
        }
    }
    cout<<"此链表中没有此值"<<endl;
    return ERROR;
}

// 删除指定位置的元素
ElemType ListDelte(LinkList &L,int x) {
    LinkList p=L;
    for(int i=1;i<x;i++) {
        p=p->next; // 移动指针到要删除节点的前一个节点
    }
    LinkList q=p->next;
    p->next=q->next; // 将前一个节点的next指针指向被删除节点的下一个节点
    ElemType e=q->data; // 保存被删除节点的值
    L->data--; // 链表长度减1
    delete q; // 释放被删除节点的内存
    return e; // 返回被删除节点的值
}

// 主函数
int main() {
    LinkList L;
    InitList(L); // 初始化链表
    L_Insert(L); // 尾插法建立链表
    PrintList(L); // 打印链表
    List_Insert(L,2,222222222); // 在第2个位置插入元素222222222
    PrintList(L); // 打印链表
    cout<<"length::::::::::::"<<GetLength(L)<<endl; // 输出链表长度
    cout<<"第3位数是"<<FindByPos(L,3)<<endl; // 输出链表中第3个元素的值
    cout<<"4在第几位::::::::"<<FindByVal(L,4)<<endl; // 输出值为4的元素在链表中的位置
    cout<<"删除的数是"<<ListDelte(L,2)<<endl; // 删除链表中第2个位置的元素并输出其值
    PrintList(L); // 打印链表
    return 0; // 返回0表示成功
}
可摘星程
关注
  • 5
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C/C++ 链 表 头插法 尾插法
weixin_39010646的博客
03-12 3869
写这篇是为了给还在为理解链表而发愁的同学们节约时间，我在学习链表的时候也是一头雾水，尽管书上，视频里都有讲解，但是你们有没有发现都是狗屁官方语言，对帮助理解没有多大作用，许多其他的学习也类似就不说编程了，作为一名读过多年书的你是不是也这样感觉，那这次我将源代码全部写下来，注释也是用最好理解的白话写的希望能帮助到你。 #include "stdafx.h" #include"iostream" u...
初学c++笔记——链表(二)
serve_YogSothoth的博客
02-07 50
一道简单的链表题，将两个升序链表合并成一个新的升序链表
C/C++学习（七）单链表的头插法，尾插法，元素插入、删除和查找 .
阳仔的博客
12-20 8711
链表也是线性表的一种，与顺序表不同的是，它在内存中不是连续存放的。在C语言中，链表是通过指针相关实现的。而单链表是链表的其中一种，关于单链表就是其节点中有数据域和只有一个指向下个节点的指针域。创建单链表的方法有两种，分别是头插法和尾插法。所谓头插法，就是按节点的逆序方法逐渐将结点插入到链表的头部。反之尾插法就是按节点的顺序逐渐将节点插入到链表的尾部。相对来说，头插法要比尾插法算法简单，但是最后产生
数据结构C++单链表的头插法和尾插法
最新发布
weixin_74453229的博客
05-16 879
这个代码的存在的意义就是定义一个整形变量，有人会问整形变量不是int吗，你怎么用的Element，这里我在说明一下，这里也是考研的重点其中typedef int Element是为了在以后需要更改数据类型的时候方便更改，相当于就是将int 重命名为了Element.（请考研的各位同学务必记住）//这个指针的作用是指向申请的新的节点，一定要对不画图的读者说明，申请的这个指针是为了指向新的节点。这个代码的存在的意义就是头指针指向头结。这个代码的存在的意义就是头结点的下一个指针指向空NULL的意思就是空。
带头结点的链表头插法C++实现
CppPlayer
11-07 2429
#include using namespace std; //带头结点的头插法实现链表 typedef int DATA; struct SNode { DATA data; SNode* pNext; }; struct SList { SNode* m_pHead; SList() { m_pHead = new
带头结点的单链表操作（头插法）-c++实现
weixin_30945039的博客
05-05 269
c++编写 带头结点的单链表操作（头插法）（和c语言差不多） #include<iostream> #include<conio.h> using namespace std; typedef int ElemType; typedef struct LNode { ElemType data; struct LNode *next; ...
C实现链表的头插法
二哈
06-29 385
1. 问题描述： 将数组的所有元素使用头插法插入到一个链表中，最终的序列与插入的序列是相反的 2. 下面是具体的C语言代码： #include<stdio.h> #include<malloc.h> typedef struct node{ int data; node *next; }LNode; LNode *C; LNode* createListF(...
数据结构：单链表前插法（头插法）C++
一季南凉的博客
08-18 4347
#include<iostream> using namespace std; #include<stdlib.h> #define ok 1 #define error 0 typedef int ElemType; typedef int status; //单链表的存储结构 typedef struct LNode{ ElemType data;//结点的数据域 struct LNode *next; //结点的指针域 }LNode,*LinkList; //定义结
单链表头插法和尾插法的算法程序
01-19
头插法是用结构体数组来实现的。 具体的思路是:在建立邻接表时，记录的不是点而是边，对于每一个点所对应的邻接表都是以栈的形式存储的，也就是说先添加的边在遍历时后取出，除此以外，所有的边用一个结构体数组...
C实现单链表的头插法和尾插法来构建单链表.zip
04-17
本资源围绕“C实现单链表的头插法和尾插法来构建单链表”展开，旨在帮助学习者掌握这两种插入方法，并通过实际编程练习加深理解。以下是关于单链表、头插法和尾插法的详细知识点： **单链表** 单链表是一种线性...
单链表尾插法(C++源代码)Linklist.7z
04-12
单链表尾插法(C++源代码)
c++头插法和尾插法创建、删除、遍历单链表.zip
04-17
这个压缩包文件“c++头插法和尾插法创建、删除、遍历单链表.zip”可能包含了关于如何使用这两种方法来操作单链表的课程设计示例。下面将详细讨论头插法、尾插法以及单链表的基本操作。 1. 头插法（Front Insertion...
单链表 创建 头插法 尾插法 就地逆置
05-02
单链表的创建可以通过头插法和尾插法来实现。 头插法 头插法是指在单链表的头部插入新节点的方法。其基本思想是首先生成头节点，然后在头节点后面插入新的节点。头插法的实现步骤如下： 1. 生成头节点 2. 输入要...
字节跳动反转链表--头插法c++
weixin_44026260的博客
09-07 430
字节跳动反转链表--头插法c++ 题目描述 给一个链表，将其倒置后返回新的头节点即可 题目链接： (https://www.nowcoder.com/practice/75e878df47f24fdc9dc3e400ec6058ca?tpId=188&&tqId=35160&rp=1&ru=/activity/oj&qru=/ta/job-code-high-week/question-ranking) 可能面临的问题： 1.指针报错（越界或者循环过多）： 看一下是不
c++单链表的头插尾插法
weixin_42831564的博客
03-02 354
输入3 4 5 6 7 9999一串整数，9999代表结束，通过头插法新建链表，并输出，通过尾插法新建链表并输出。//打印链表中每个结点的值。
考研C++/C数据结构之单链表头插法
Nanqipro的研究日常
03-26 2103
最众所周知单链表是408考研常考的一个数据结构考点之一，那么今天给大加分享一下我的学习成果。 今天我学了单链表的创建和读取，采用头插和尾插法可以新建一个单链表，以及打印单链表。 #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> typedef int ElemType; typedef struct LNode { ElemType data; struct LNode* next
C++手写链表（头插法和尾插法）
m0_72470311的博客
04-25 165
/第一步是将p的下一个节点置为空（就是尾节点），然后第二步往后就是将新节点的下一个值指向老节点。//将p的下一个置为空，一直要保证p可能为最后一个节点。//尾指针指向头指针,记住现在还没有节点。//不能调用头指针，调用尾指针。//LNode,*LinkList均为LNode的别名，//先将头节点开辟空间，l->next = p;void out_list(lnode *L)//输出链表。
C/C++实现单链表基本操作之头插法、尾插法、A、B并归成C
weixin_44774546的博客
09-27 1711
C/C++实现单链表基本操作之头插法、尾插法、A、B并归成C C/C++实现单链表基本操作 1.尾插法建立链表 假设有n个元素已经存储在数组a中，用尾插法建立链表L: void creatlistR(LNode *&L,int a[],int n) //尾插法建立链表 { LNode *s,*r; //s用来指向新申请的结点，r始终指向L的终端结点 int i; L=(LNode *)malloc(sizeof(LNode));
单链表头插法和尾插法的实现（C++）
weixin_45973487的博客
07-14 1532
单链表头插法和尾插法的实现 单链表的功能特点主要用于频繁增删数据，而不适宜查找。因而，下面代码主要实现单链表的创建（头插法和尾插法），增加，删除，清空以及遍历功能。 #include <iostream> #include <string> using namespace std; typedef struct{ int num; string name; }ElemType; typedef struct Node{ ElemType data; Node* next;
单链表头插法和尾插法
10-18
单链表有两种插入方式：头插法和尾插法。 头插法是将新节点插入到链表的头部，即新节点的 next 指针指向原来的头节点，然后将新节点设置为头节点。代码实现如下： ```python class ListNode: def __init__(self, ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值