1-2 线性表——链表（C/C++语言）

已于 2023-02-28 15:37:50 修改
阅读量1.4k 收藏 3
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构 算法 c++
于 2022-03-12 16:43:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sdjzu_Nxy/article/details/123445546
版权

1-2 线性表——链表（C/C++语言）

结点定义

typedef struct Node
{
    int data;//结点存放的值
    struct Node *next;//后继
    int size;//便于记录链表长度
} Node, *LinkList;

实现的功能

bool initList(LinkList &L);//初始化一个链表
bool isEmpty(LinkList L);//判断链表是否为空
int getLength(LinkList &L);//获取链表长度
void listDisplay(LinkList &L);//输出链表
LinkList listHeadInsert(LinkList &L);//头插法建立链表
LinkList listTailInsert(LinkList &L);//尾插法建立链表
bool insertNextNode(Node* p, int elem);//后插操作（封装）
bool insertPriorNode(Node* p, int elem);//前插操作（封装）
bool listInsertByInsertNextNode(LinkList &L, int i, int elem);//使用后插操作插入元素
bool listInsertByInsertPriorNode(LinkList &L, int i, int elem);//使用前插操作插入元素
bool listDelete(LinkList& L, int i, int &elem);//删除元素
bool deleteNode(Node* p, int& elem);//删除节点（封装）
Node *getElem(LinkList L, int i);//按位查找
Node *locateElem(LinkList L,int data);//按值查找
void clear(LinkList &L);//清空链表

带头节点的链表实现

完整代码：

/*
    Name:LinkListWithHead 
    Copyright:
    Author: Sdjzu_Nxy
    Date: 2022 年 3 月 10 日 
    Description:
*/
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

typedef struct Node
{
    int data;
    struct Node *next;
    int size;
} Node, *LinkList;

bool initList(LinkList &L);
bool isEmpty(LinkList L);
int getLength(LinkList &L);
void listDisplay(LinkList &L);
LinkList listHeadInsert(LinkList &L);
LinkList listTailInsert(LinkList &L);
bool insertNextNode(Node* p, int elem);
bool insertPriorNode(Node* p, int elem);
bool listInsertByInsertNextNode(LinkList &L, int i, int elem);
bool listInsertByInsertPriorNode(LinkList &L, int i, int elem);
bool listDelete(LinkList& L, int i, int &elem);
bool deleteNode(Node* p, int& elem);
Node *getElem(LinkList L, int i);
Node *locateElem(LinkList L,int data);
void clear(LinkList &L);

//初始化链表
bool initList(LinkList &L){
    L = (Node *) malloc(sizeof(Node));
    if (L == NULL)
    {
        return false;
    }
    L->next = NULL;
    L->size = 0;
    return true;
}

//判断链表是否为空
bool isEmpty(LinkList L){
    // if (L->next == NULL)//L->size == 0
    // {
    //     return true;
    // }
    // else{
    //     return false;
    // }
    return (L->next == NULL);
}

//获得链表长度
int getLength(LinkList &L){
    return L->size;
}

//输出链表
void listDisplay(LinkList &L){
    Node *s = L->next;
    for (int i = 0; i < L->size; i++)
    {
        printf("%d\n",s->data);
        s = s->next;
    }
}

//头插法建立单链表（逆序）
LinkList listHeadInsert(LinkList &L){
    Node *s;
    int elem;
    if (initList(L)) {
        scanf_s("%d", &elem);
        while (elem != 9999)
        {
            s = (Node*)malloc(sizeof(Node));
            s->data = elem;
            s->next = L->next;
            L->next = s;
            L->size++;
            scanf_s("%d", &elem);
        }
        return L;
    }
}

//尾插法建立单链表（正序）
LinkList listTailInsert(LinkList &L){
    int elem;
    if (initList(L)) {
        scanf_s("%d", &elem);

        Node* s;//待插入结点
        Node* t = L;//尾结点

        while (elem != 9999)
        {
            s = (Node*)malloc(sizeof(Node));
            s->data = elem;
            t->next = s;
            t = s;
            L->size++;
            scanf_s("%d", &elem);
        }
        t->next = NULL;
        return L;
    }
}

//指定节点后插入（便于封装）
bool insertNextNode(Node* p, int elem) {
    if (p == NULL) {
        return false;
    }
    Node* s = (Node*)malloc(sizeof(Node));
    s->data = elem;
    s->next = p->next;
    p->next = s;
    return true;
}

//指定节点前插入（便于封装）
bool insertPriorNode(Node* p, int elem) {
    if (p == NULL) {
        return false;
    }
    Node* s = (Node*)malloc(sizeof(Node));
    s->data = p->data;
    s->next = p->next;
    p->next = s;
    p->data = elem;
    return true;
}

//按位序插入使用后插
bool listInsertByInsertNextNode(LinkList &L, int i, int elem) {
    if (i < 1) {
        return false;
    }
    Node* p = getElem(L, i - 1);
    if (p == NULL) {
        return false;
    }
    if (insertNextNode(p, elem)) {
        L->size++;
        return true;
    }
    else {
        return false;
    }
}

//按位序插入使用前插
bool listInsertByInsertPriorNode(LinkList &L, int i, int elem) {
    if (i < 1) {
        return false;
    }
    Node* p = getElem(L, i);
    if (p == NULL) {
        return false;
    }
    if (insertPriorNode(p, elem)) {
        L->size++;
        return true;
    }
    else {
        return false;
    }
}

//按位序删除
bool listDelete(LinkList &L, int i, int &elem) {
    if (i < 1) {
        return false;
    }
    Node* p = getElem(L, i - 1);
    if (p == NULL) {
        return false;
    }
    if (deleteNode(p, elem)) {
        L->size--;
        return true;
    }
    else {
        return false;
    }
}

//删除单个节点（便于封装）
bool deleteNode(Node* p, int& elem) {
    if (p->next == NULL) {
        return false;
    }
    Node* q = p->next;//待删除结点
    elem = q->data;
    p->next = q->next;
    free(q);
    return true;
}

//按位查找（便于封装）
Node* getElem(LinkList L, int i){
    if (i < 0) {
        return NULL;
    }
    Node* p = L;
    int j = 0;
    while (p != NULL && j < i) {
        p = p->next;
        j++;
    }
    return p;
}

//按值查找元素
Node *locateElem(LinkList L,int data){    
    Node* p = L;
    while (p != NULL && p->data != data) {
        p = p->next;
    }
    return p;
}
   
//清空链表
void clear(LinkList &L){
    Node* p = L->next;
    while (p != NULL) {
        Node* q = p;
        p = p->next;
        free(q);
    }
    L->next = NULL;
    L->size = 0;
} 

int main(){
    LinkList L;					//创建一个顺序表 
    initList(L);				//初始化顺序表 

    //头插法建立链表
    //listHeadInsert(L);

    //尾插法建立链表
    listTailInsert(L);

    //判断表是否为空
    printf("The Linklist is empty? %d.\n", isEmpty(L));

    //按位序插入使用尾插
    //listInsertByInsertNextNode(L, 3, 100);

    //按位序插入使用头插
    listInsertByInsertPriorNode(L, 3, 100);

    //按位序删除
    int delData;
    if (listDelete(L, 2, delData)) {
        printf("delete the 2 data is %d\n", delData);
    }
    else {
        printf("delete error!\n");
    }

    //按值查找
    Node* p = locateElem(L, 4);
    printf("The node address is %p\n", p);

    //输出
    listDisplay(L);

    //输出表长 
    printf("Get list length is %d.\n", getLength(L));

    //清空链表
    clear(L);
    printf("The Linklist is empty? %d.\n", isEmpty(L));

    return 0;    
}

运行结果：
在这里插入图片描述

不带头结点的单链表实现

完整代码：

/*
    Name:LinkListNoHead
    Copyright:
    Author: Sdjzu_Nxy
    Date: 2022 年 3 月 11 日 
    Description:
*/
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

typedef struct Node
{
    int data;
    struct Node *next;
    int size;
} Node, *LinkList;

bool initList(LinkList &L);
bool isEmpty(LinkList L);
int getLength(LinkList &L);
void listDisplay(LinkList &L);
LinkList listHeadInsert(LinkList &L);
LinkList listTailInsert(LinkList &L);
bool insertNextNode(Node* p, int elem);
bool insertPriorNode(Node* p, int elem);
bool listInsertByInsertNextNode(LinkList& L, int i, int elem);
bool listInsertByInsertPriorNode(LinkList& L, int i, int elem);
bool listDelete(LinkList& L, int i, int& elem);
bool deleteNode(Node* p, int& elem);
Node *getElem(LinkList L, int i);
Node *locateElem(LinkList L,int data);
void clear(LinkList &L);

//初始化链表
bool initList(LinkList &L){
    L = NULL;
    return true;
}

//链表是否为空
bool isEmpty(LinkList L){
    // if (L == NULL)//L->size == 0
    // {
    //     return true;
    // }
    // else{
    //     return false;
    // }
    return (L == NULL);
}

//获取链表长度
int getLength(LinkList &L){
    return L->size;
}

//输出链表
void listDisplay(LinkList &L){
    Node *s = L;
    for (int i = 0; i < L->size; i++)
    {
        printf("%d\n",s->data);
        s = s->next;
    }
}

//头插法建立链表
LinkList listHeadInsert(LinkList &L){
    Node *s;
    int elem;
    scanf_s("%d",&elem);
    L = (LinkList)malloc(sizeof(Node));//创建头结点
    L->data = elem;
    L->next = NULL;
    L->size = 1;
    scanf_s("%d", &elem);
    while (elem != 9999)
    {
        s = (Node*)malloc(sizeof(Node));
        s->data = elem;
        s->next = L;
        s->size = L->size + 1;
        L = s;
        scanf_s("%d",&elem);
    }
    return L;
}

//尾插法建立链表
LinkList listTailInsert(LinkList &L){
    Node *s, *t;
    int elem;
    scanf_s("%d", &elem);
    t = L = (LinkList)malloc(sizeof(Node));//创建头结点
    L->data = elem;
    L->next = NULL;
    L->size = 1;
    scanf_s("%d", &elem);
    while (elem != 9999)
    {
        s = (Node*)malloc(sizeof(Node));
        s->data = elem;
        t->next = s;
        t = s;
        L->size++;
        scanf_s("%d", &elem);
    }
    t->next = NULL;
    return L;
}

//指定节点后插入（便于封装）
bool insertNextNode(Node* p, int elem) {
    if (p == NULL) {
        return false;
    }
    Node* s = (Node*)malloc(sizeof(Node));
    s->data = elem;
    s->next = p->next;
    p->next = s;
    return true;
}

//指定节点前插入（便于封装）
bool insertPriorNode(Node* p, int elem) {
    if (p == NULL) {
        return false;
    }
    Node* s = (Node*)malloc(sizeof(Node));
    s->data = p->data;
    s->next = p->next;
    p->next = s;
    p->data = elem;
    return true;
}

//按位序插入使用后插
bool listInsertByInsertNextNode(LinkList& L, int i, int elem) {
    if (i < 1) {
        return false;
    }
    Node* p = getElem(L, i - 1);
    if (p == NULL) {
        return false;
    }
    if (insertNextNode(p, elem)) {
        L->size++;
        return true;
    }
    else {
        return false;
    }
}

//按位序插入使用前插
bool listInsertByInsertPriorNode(LinkList& L, int i, int elem) {
    if (i < 1) {
        return false;
    }
    Node* p = getElem(L, i);
    if (p == NULL) {
        return false;
    }
    if (insertPriorNode(p, elem)) {
        L->size++;
        return true;
    }
    else {
        return false;
    }
}

//按位序删除
bool listDelete(LinkList& L, int i, int& elem) {
    if (i < 1) {
        return false;
    }
    Node* p = getElem(L, i - 1);
    if (p == NULL) {
        return false;
    }
    if (deleteNode(p, elem)) {
        L->size--;
        return true;
    }
    else {
        return false;
    }
}

//删除单个节点（便于封装）
bool deleteNode(Node* p, int& elem) {
    if (p->next == NULL) {
        return false;
    }
    Node* q = p->next;//待删除结点
    elem = q->data;
    p->next = q->next;
    free(q);
    return true;
}

//按位查找元素
Node *getElem(LinkList L, int i){
    if (i < 1) {
        return NULL;
    }
    Node* p = L;
    int j = 0;
    while (p != NULL && j < i - 1) {
        p = p->next;
        j++;
    }
    return p;
}

//按值查找元素
Node *locateElem(LinkList L,int data){
    Node* p = L;
    while (p != NULL && p->data != data) {
        p = p->next;
    }
    return p;
}

//清空链表
void clear(LinkList &L){
    Node* p = L;
    while (p != NULL) {
        Node* q = p;
        p = p->next;
        free(q);
    }
    L = NULL;
}

int main(){
    LinkList L;					//创建一个顺序表 
    initList(L);				//初始化顺序表 

    //头插法建立链表
    //listHeadInsert(L);

    //尾插法建立链表
    listTailInsert(L);

    //判断表是否为空
    printf("The Linklist is empty? %d.\n", isEmpty(L));

    //使用后插操作插入元素
    listInsertByInsertNextNode(L, 3, 100);

    //使用前插操作插入元素
    listInsertByInsertPriorNode(L, 4, 99);

    //删除元素
    int data;
    if (listDelete(L, 4, data)) {
        printf("The delete data is %d\n", data);
    }
    else {
        printf("Delete error!\n");
    }

    //按值查找
    Node* p = locateElem(L, 4);
    printf("The node address %p\n", p);

    //输出
    listDisplay(L);

    //输出表长 
    printf("Get list length is %d.\n", getLength(L));

    //清空链表
    clear(L);
    printf("The Linklist is empty? %d.\n", isEmpty(L));

    return 0;    
}

运行结果：
在这里插入图片描述

注意：写的代码有点不好的地方，就是把结点作为了链表，我觉得更好的方式是结点是结点，链表是链表 更好的加以区分，及建立两个结构体，如下代码（各位大佬批评指正）

typedef struct Node
{
    int data;
    struct Node *next;
} Node;

typedef struct LinkList
{
    Node* p = NULL;
    int size;
} LinkList;
IT_St_Ning
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值