【数据结构】【王道】【线性表】无头结点单链表的实现及基本操作（可直接运行）

已于 2022-10-07 23:57:44 修改
阅读量2.9k 收藏 105
点赞数 19
分类专栏： 数据结构 c/c++ 文章标签： 数据结构 链表
于 2022-07-11 17:06:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/treesorshining/article/details/125725186
版权

总目录

文章目录


各部分的解释已经以注释形式写于代码中。

1.基本操作

1.1 结构体定义

// 不带头结点
typedef struct LNode {  // 定义单链表结点类型
    int data;   // 数据域
    struct LNode *next; // 指针域
} LNode, *LinkList;

1.2 初始化

//初始化一个空的单链表
bool InitList(LinkList &L){
    L = NULL;   //空表，暂时还没有任何结点
    return true;
}

1.3 判空

// 判断单链表是否为空
bool Empty(LinkList L) {
    // 无头结点，那么头指针指向NULL，单链表即为空
    if(L == NULL) {
        return true;
    } else {
        return false;
    }
    // 简洁
    // return  (L == NULL);
}

1.4 按位序插入

// 按位序插入
// 在第i个位置插入元素e
bool ListInsert(LinkList &L, int i, int e) {
    // 链表为空时的情况
    // 若为空，则取指针域或数据域会报错
    // 判断插入位序是否存在问题
    if(L == NULL || i < 1) {
        return NULL;
    }
    // 判断插入的位置是否是第1个
    // 由于没有头指针，所以此处操作与其它结点不同，需要单独处理，以更新头指针
    if(i == 1) {
        LNode *s = (LNode *)malloc(sizeof(LNode));
        s->data = e;
        // 令新结点指向之前头指针所指的结点
        s->next = L;
        // 头指针指向新结点
        L = s;
        return true;
    }
    LNode *p;   // 指针p指向当前扫描到的结点
    int j = 1;  // 当前p指向的是第几个结点
    p = L;      // 初始令p指向第一个结点
    // 通过循环，找到第i-1个结点
    // 如果i大于链表长度，则不可插入，此时p指向最后结点的指针域，即NULL
    while(p != NULL && j < i - 1){
        p = p->next;
        j++;
    }
    // p值为NULL说明遍历完成后仍未为找到位序为i的结点，说明i大于链表长度，i不合法
    if (p == NULL)       
        return false;
    // 在第i-1个结点后插入新结点
    LNode *s = (LNode *)malloc(sizeof(LNode));
    // 注意顺序，应该先让要插入结点的指针域指向后一结点
    // 之后再断开前一结点与后一结点的指针，使前一结点指向要插入结点
    s->data = e; 
    s->next = p->next;
    //将结点s连到p后
    p->next = s;
    return true;
}

1.5 指定结点后插操作

// 指定结点后插操作：在p结点之后插入元素e
// 此操作与带头结点情况相同，由于是指定结点后插，所以即使是第一个结点也无需特殊处理
// LNode强调为结点
bool InsertNextNode(LNode *p, int e) {
    // p不合理的情况
    if(p == NULL) {
        return false;
    }
    LNode *s = (LNode *)malloc(sizeof(LNode));
    // 内存分配失败的情况
    if(s == NULL) {
        return false;
    }
    // 此处先将要插入结点的指针域指向前一个结点的指针域，即后一个结点的地址
    // 之后再令前一个结点的指针域指向要插入结点
    // 顺序不可颠倒，否则可能出现找不到之后结点的情况
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

1.6 指定结点前插操作_1

// 指定结点前插操作：在p结点之前
// 此处需要传入头指针，因为是在p前插入
// 而由于此为单链表，如果只知道p节点，只能遍历找到p后的元素，而找不到p前的元素
// 所以只能通过头结点遍历，找到p的前驱结点
bool InsertPriorNodeRoutine(LinkList L, LNode *p, int e) {
    // 链表为空时的情况
    // 若为空，则取指针域或数据域会报错
    // p不合理的情况
    if(L == NULL || p == NULL) {
        return false;
    }
    LNode *s = (LNode *)malloc(sizeof(LNode));
    // 内存分配失败的情况
    if(s == NULL) {
        return false;
    }
    // 插入时是第一个结点的情况，需要特殊处理，以更新头指针
    if(L == p) {
        s->data = e;
        s->next = p;
        L = s;
        return true;
    }
    // 定义一个指针，初始指向第一个结点
    LNode *p1 = L;
    // 遍历找到p结点的前驱结点
    while(p1 != NULL && p1->next != p) {
        p1 = p1->next;
    }
    // p1若等于NULL，表示p不存在或是链表无元素
    if(p1 == NULL) {
        return false;
    }
    // 插入操作
    s->data = e;
    s->next = p;
    p1->next = s;
    return true;
}

1.7 指定结点前插操作_2

// 指定结点前插操作：在p结点之前
// 此处可以通过一种特殊方法完成前插
// 本质上还是后插操作
bool InsertPriorNode(LNode *p, int e) {
    // p不合理的情况
    if(p == NULL) {
        return false;
    }
    LNode *s = (LNode *)malloc(sizeof(LNode));
    // 内存分配失败的情况
    if(s == NULL) {
        return false;
    }
    // 插入操作
    // 通过将s插入p结点之后，然后将s结点与p结点的数据域进行互换
    // 可以视作完成了前插操作
    s->next = p->next;
    p->next = s;
    s->data = p->data;
    p->data =e;
    return true;
}

1.8 按位序删除

// 按位序删除
bool ListDelete(LinkList &L, int i, int &e) {
    // 链表为空时的情况
    // 若为空，则取指针域或数据域会报错
    // i不合理的情况
    if(L == NULL || i < 1) {
        return false;
    }
    // 删除第一个结点的情况
    // 需要更新头指针，要单独处理
    if(i == 1) {
        LNode* q = L;
        e = q->data;
        // 一般情况为p->next = q->next
        // 但由于无头结点，所以需要直接令L指向q->next，以此更新头指针
        L = q->next;
        free(q);
        return true;
    }
    LNode *p;   // 指针p指向当前扫描到的结点
    int j = 1;  // 当前p指向的是第几个结点
    // 初始令p指向头指针
    p = L;
    // 通过遍历找到第i - 1个结点，即要删除结点的前驱结点
    while(p != NULL && j < i - 1) {
        p = p->next;
        j++;
    }
    // 若p等于NULL，则要么此链表为空，要么i值大于链表长度，显然不合理
    // p->next为空表示第i-1个结点之后已经没有其他结点了，无法进行删除操作
    if(p == NULL || p->next == NULL) {
        return false;
    }
    // 删除操作
    // 就是将前驱结点指针域指向后继结点
    LNode *q = p->next;    
    e = q->data;
    p->next = q->next;
    // 不要忘记释放空间！！！
    free(q); 
    return true;
}

1.9 按位查找

// 按位查找，返回第i个元素
// 之前操作部分按位查找部分可以以此部分代码代替，提高代码复用性（封装）
LNode* GetElem(LinkList L, int i) {
    // 链表为空时的情况
    // 若为空，则取指针域或数据域会报错
    if(L == NULL) {
        return NULL;
    }
    // 判断插入位序是否存在问题
    // 由于此是不带头结点的情况，所以i值不能小于1，因为第一个结点前是头指针
    // 带头结点的第一个结点前是头结点
    if(i < 1)
        return NULL;
    LNode *p;   // 指针p指向当前扫描到的结点
    int j = 1;  // 当前p指向的是第几个结点
    p = L;      // 初始令p指向第一个结点
    // 通过循环，找到第i个结点
    // 如果i大于链表长度，则找不到此节点，此时p指向最后结点的指针域，即NULL
    // 如果i初始为1，会直接返回第一个结点结点地址
    while(p != NULL && j < i) {
        p = p->next;
        j++;
    }
    return p;
}

1.10 按值查找

// 按值查找，找到数据域等于e的结点
LNode* LocateElem(LinkList L, int e) {
    // 链表为空时的情况
    // 若为空，则取指针域或数据域会报错
    if(L == NULL) {
        return NULL;
    }
    LNode* p = L;
    // 从第一个结点开始查找数据域为e的结点
    // 找不到，则会在遍历后指向NULL
    while (p != NULL && p->data != e) {
        p = p->next;
    }
    return p;
}

1.11 表的长度

// 求表的长度
// 就是通过遍历所有结点，然后通过计数器来累加得到长度
int Length(LinkList L) {
    // 链表为空时的情况
    // 若为空，则取指针域或数据域会报错
    if(L == NULL) {
        return 0;
    }
    int len = 0;
    LNode* p = L;
    while(p->next != NULL) {
        p = p->next;
        len++;
    }
    return len;
}

1.12 单链表建立（尾插法）

// 尾插法
// 通过尾插法建立的链表，顺序为插入时元素的顺序
LinkList TailInsert(LinkList &L) {
    // 设置ElemType为整型
    int x;
    // 定义表尾指针
    // 对于尾插法，如果只通过头结点遍历的话
    // 每次插入时都要先遍历到表尾，时间复杂度为O(1+2+...+n-1)=O(n^2)
    // 所以选择增加一个尾指针，来避免遍历
    // s为要插入的结点，r为表尾指针
    LNode *s, *r = L;
    // 输入结点的值
    scanf("%d", &x);
    // 第一个结点需要特殊处理
    L = (LNode*)malloc(sizeof(LNode));
    L->data = x;
    r = L;
    L->next = NULL;
    // 输入结点的值
    scanf("%d", &x);
    // 表示键入9999后建表结束
    while(x != 9999) {
        s = (LNode*)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        // r指向新的表尾结点
        r = s;
        // 继续输入下一个结点的值，直至输入9999结束
        scanf("%d", &x);
    }
    // 尾指针置空
    r->next = NULL;
    return L;
}

1.13 单链表建立（头插法）

// 头插法
// 通过头插法建立的链表，顺序为插入时元素的逆序
LinkList HeadInsert(LinkList &L) {
    // 设置ElemType为整型
    int x;
    // 不同于尾插法，头插法无需定义更多指针
    LNode* s;
    // 输入结点的值
    scanf("%d", &x);
    // 第一个结点需要特殊处理
    L = (LNode*)malloc(sizeof(LNode));
    L->data = x;
    L->next = NULL;
    // 输入结点的值
    scanf("%d", &x);
    // 表示键入9999后建表结束
    while(x != 9999) {
        s = (LNode*)malloc(sizeof(LNode));
        s->data = x;
        s->next = L;
        // 更新头指针
        L = s;
        // 继续输入下一个结点的值，直至输入9999结束
        scanf("%d", &x);
    }
    return L;
}

1.14 输出所有链表元素

// 输出所有链表元素
void PrintList(LinkList L) {
    if(Empty(L)) {
        printf("the list is empty");
    }
    LNode* p = L;
    while(p !=  NULL) {
        printf("%d  ", p->data);
        p = p->next;
    }
    printf("\n");
}

2.完整代码

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

/**
 * 注意：对于不带头结点的情况，一定要考虑L为NULL的可能性
 * 因为在没有头结点的情况下，头指针为NULL是不能够取数据域或者指针域的
 */

// 不带头结点
typedef struct LNode {  // 定义单链表结点类型
    int data;   // 数据域
    struct LNode *next; // 指针域
} LNode, *LinkList;

//初始化一个空的单链表
bool InitList(LinkList &L){
    L = NULL;   //空表，暂时还没有任何结点
    return true;
}

// 判断单链表是否为空
bool Empty(LinkList L) {
    // 无头结点，那么头指针指向NULL，单链表即为空
    if(L == NULL) {
        return true;
    } else {
        return false;
    }
    // 简洁
    // return  (L == NULL);
}

// 按位序插入
// 在第i个位置插入元素e
bool ListInsert(LinkList &L, int i, int e) {
    // 链表为空时的情况
    // 若为空，则取指针域或数据域会报错
    // 判断插入位序是否存在问题
    if(L == NULL || i < 1) {
        return NULL;
    }
    // 判断插入的位置是否是第1个
    // 由于没有头指针，所以此处操作与其它结点不同，需要单独处理，以更新头指针
    if(i == 1) {
        LNode *s = (LNode *)malloc(sizeof(LNode));
        s->data = e;
        // 令新结点指向之前头指针所指的结点
        s->next = L;
        // 头指针指向新结点
        L = s;
        return true;
    }
    LNode *p;   // 指针p指向当前扫描到的结点
    int j = 1;  // 当前p指向的是第几个结点
    p = L;      // 初始令p指向第一个结点
    // 通过循环，找到第i-1个结点
    // 如果i大于链表长度，则不可插入，此时p指向最后结点的指针域，即NULL
    while(p != NULL && j < i - 1){
        p = p->next;
        j++;
    }
    // p值为NULL说明遍历完成后仍未为找到位序为i的结点，说明i大于链表长度，i不合法
    if (p == NULL)       
        return false;
    // 在第i-1个结点后插入新结点
    LNode *s = (LNode *)malloc(sizeof(LNode));
    // 注意顺序，应该先让要插入结点的指针域指向后一结点
    // 之后再断开前一结点与后一结点的指针，使前一结点指向要插入结点
    s->data = e; 
    s->next = p->next;
    //将结点s连到p后
    p->next = s;
    return true;
}

// 指定结点后插操作：在p结点之后插入元素e
// 此操作与带头结点情况相同，由于是指定结点后插，所以即使是第一个结点也无需特殊处理
// LNode强调为结点
bool InsertNextNode(LNode *p, int e) {
    // p不合理的情况
    if(p == NULL) {
        return false;
    }
    LNode *s = (LNode *)malloc(sizeof(LNode));
    // 内存分配失败的情况
    if(s == NULL) {
        return false;
    }
    // 此处先将要插入结点的指针域指向前一个结点的指针域，即后一个结点的地址
    // 之后再令前一个结点的指针域指向要插入结点
    // 顺序不可颠倒，否则可能出现找不到之后结点的情况
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

// 指定结点前插操作：在p结点之前
// 此处需要传入头指针，因为是在p前插入
// 而由于此为单链表，如果只知道p节点，只能遍历找到p后的元素，而找不到p前的元素
// 所以只能通过头结点遍历，找到p的前驱结点
bool InsertPriorNodeRoutine(LinkList L, LNode *p, int e) {
    // 链表为空时的情况
    // 若为空，则取指针域或数据域会报错
    // p不合理的情况
    if(L == NULL || p == NULL) {
        return false;
    }
    LNode *s = (LNode *)malloc(sizeof(LNode));
    // 内存分配失败的情况
    if(s == NULL) {
        return false;
    }
    // 插入时是第一个结点的情况，需要特殊处理，以更新头指针
    if(L == p) {
        s->data = e;
        s->next = p;
        L = s;
        return true;
    }
    // 定义一个指针，初始指向第一个结点
    LNode *p1 = L;
    // 遍历找到p结点的前驱结点
    while(p1 != NULL && p1->next != p) {
        p1 = p1->next;
    }
    // p1若等于NULL，表示p不存在或是链表无元素
    if(p1 == NULL) {
        return false;
    }
    // 插入操作
    s->data = e;
    s->next = p;
    p1->next = s;
    return true;
}

// 指定结点前插操作：在p结点之前
// 此处可以通过一种特殊方法完成前插
// 本质上还是后插操作
bool InsertPriorNode(LNode *p, int e) {
    // p不合理的情况
    if(p == NULL) {
        return false;
    }
    LNode *s = (LNode *)malloc(sizeof(LNode));
    // 内存分配失败的情况
    if(s == NULL) {
        return false;
    }
    // 插入操作
    // 通过将s插入p结点之后，然后将s结点与p结点的数据域进行互换
    // 可以视作完成了前插操作
    s->next = p->next;
    p->next = s;
    s->data = p->data;
    p->data =e;
    return true;
}

// 按位序删除
bool ListDelete(LinkList &L, int i, int &e) {
    // 链表为空时的情况
    // 若为空，则取指针域或数据域会报错
    // i不合理的情况
    if(L == NULL || i < 1) {
        return false;
    }
    // 删除第一个结点的情况
    // 需要更新头指针，要单独处理
    if(i == 1) {
        LNode* q = L->next;
        e = q->data;
        // 一般情况为p->next = q->next
        // 但由于无头结点，所以需要直接令L指向q->next，以此更新头指针
        L = q->next;
        free(q);
        return true;
    }
    LNode *p;   // 指针p指向当前扫描到的结点
    int j = 1;  // 当前p指向的是第几个结点
    // 初始令p指向头指针
    p = L;
    // 通过遍历找到第i - 1个结点，即要删除结点的前驱结点
    while(p != NULL && j < i - 1) {
        p = p->next;
        j++;
    }
    // 若p等于NULL，则要么此链表为空，要么i值大于链表长度，显然不合理
    // p->next为空表示第i-1个结点之后已经没有其他结点了，无法进行删除操作
    if(p == NULL || p->next == NULL) {
        return false;
    }
    // 删除操作
    // 就是将前驱结点指针域指向后继结点
    LNode *q = p->next;    
    e = q->data;
    p->next = q->next;
    // 不要忘记释放空间！！！
    free(q); 
    return true;
}

// 按位查找，返回第i个元素
// 之前操作部分按位查找部分可以以此部分代码代替，提高代码复用性（封装）
LNode* GetElem(LinkList L, int i) {
    // 链表为空时的情况
    // 若为空，则取指针域或数据域会报错
    if(L == NULL) {
        return NULL;
    }
    // 判断插入位序是否存在问题
    // 由于此是不带头结点的情况，所以i值不能小于1，因为第一个结点前是头指针
    // 带头结点的第一个结点前是头结点
    if(i < 1)
        return NULL;
    LNode *p;   // 指针p指向当前扫描到的结点
    int j = 1;  // 当前p指向的是第几个结点
    p = L;      // 初始令p指向第一个结点
    // 通过循环，找到第i个结点
    // 如果i大于链表长度，则找不到此节点，此时p指向最后结点的指针域，即NULL
    // 如果i初始为1，会直接返回第一个结点结点地址
    while(p != NULL && j < i) {
        p = p->next;
        j++;
    }
    return p;
}

// 按值查找，找到数据域等于e的结点
LNode* LocateElem(LinkList L, int e) {
    // 链表为空时的情况
    // 若为空，则取指针域或数据域会报错
    if(L == NULL) {
        return NULL;
    }
    LNode* p = L;
    // 从第一个结点开始查找数据域为e的结点
    // 找不到，则会在遍历后指向NULL
    while (p != NULL && p->data != e) {
        p = p->next;
    }
    return p;
}

// 求表的长度
// 就是通过遍历所有结点，然后通过计数器来累加得到长度
int Length(LinkList L) {
    // 链表为空时的情况
    // 若为空，则取指针域或数据域会报错
    if(L == NULL) {
        return 0;
    }
    int len = 0;
    LNode* p = L;
    while(p->next != NULL) {
        p = p->next;
        len++;
    }
    return len;
}

// 尾插法
// 通过尾插法建立的链表，顺序为插入时元素的顺序
LinkList TailInsert(LinkList &L) {
    // 设置ElemType为整型
    int x;
    // 定义表尾指针
    // 对于尾插法，如果只通过头结点遍历的话
    // 每次插入时都要先遍历到表尾，时间复杂度为O(1+2+...+n-1)=O(n^2)
    // 所以选择增加一个尾指针，来避免遍历
    // s为要插入的结点，r为表尾指针
    LNode *s, *r = L;
    // 输入结点的值
    scanf("%d", &x);
    // 第一个结点需要特殊处理
    L = (LNode*)malloc(sizeof(LNode));
    L->data = x;
    r = L;
    L->next = NULL;
    // 输入结点的值
    scanf("%d", &x);
    // 表示键入9999后建表结束
    while(x != 9999) {
        s = (LNode*)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        // r指向新的表尾结点
        r = s;
        // 继续输入下一个结点的值，直至输入9999结束
        scanf("%d", &x);
    }
    // 尾指针置空
    r->next = NULL;
    return L;
}

// 头插法
// 通过头插法建立的链表，顺序为插入时元素的逆序
LinkList HeadInsert(LinkList &L) {
    // 设置ElemType为整型
    int x;
    // 不同于尾插法，头插法无需定义更多指针
    LNode* s;
    // 输入结点的值
    scanf("%d", &x);
    // 第一个结点需要特殊处理
    L = (LNode*)malloc(sizeof(LNode));
    L->data = x;
    L->next = NULL;
    // 输入结点的值
    scanf("%d", &x);
    // 表示键入9999后建表结束
    while(x != 9999) {
        s = (LNode*)malloc(sizeof(LNode));
        s->data = x;
        s->next = L->next;
        // 更新头指针
        L = s;
        // 继续输入下一个结点的值，直至输入9999结束
        scanf("%d", &x);
    }
    return L;
}

// 输出所有链表元素
void PrintList(LinkList L) {
    if(Empty(L)) {
        printf("the list is empty");
    }
    LNode* p = L;
    while(p !=  NULL) {
        printf("%d  ", p->data);
        p = p->next;
    }
    printf("\n");
}

int main() {
    LinkList L;
    InitList(L);
    TailInsert(L);
    PrintList(L);
    printf("get_2:%d\n",  GetElem(L, 2)->data);
    printf("locate_5:%d\n",  LocateElem(L, 5)->data);
    printf("length:%d\n", Length(L));
    InsertPriorNode(GetElem(L, 2), 7);
    PrintList(L);
    InsertNextNode(GetElem(L, 2), 5);
    PrintList(L);
    ListInsert(L, 3, 3);
    PrintList(L);
    int e;
    ListDelete(L, 3, e);
    PrintList(L);
    printf("e:%d\n", e);
}

3.运行截图

在这里插入图片描述

Silver Star
关注
  • 19
    点赞
  • 踩
  • 105
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 8
    评论
专栏目录
数据结构-（无头结点）单链表的基本操作实现----------随笔记录（3）
yaoyao_ju的博客
04-06 1619
无头结点的单链表的基本操作
数据结构 无头结点的单链表
kira_981019的博客
03-15 2398
---------------start reading--------------- 前言 头结点是用来标记单链表的一个标志，有些时候我们可以不使用头结点，这时候操作就完全不一样了。 如何建立一个无头结点的单链表？不能在头结点的数据域中放数据再变成假的第一个数据节点在进行操作，那是自己骗自己。 在单链表中我们直接头结点进行解引用，但无头结点的链表最初其实就是一个指针，没有指向任何结点，在进行插入...
C++ 单链表（无头结点）
qq_43650934的博客
11-17 4962
文章目录总结归纳代码实现 总结归纳 头结点可以没有，头指针必须有。访问整个链表，是用过遍历头指针来进行的。 这里没有特别的设置一个头指针，因为当指针指向整个链表 L 时，该指针的实现效果就是头指针。 不带头结点的单链表，即单链表的第一个结点就存储数据，头指针也指向第一个结点；带头结点的单链表，第一个结点是头结点，不存储数据，从头结点的 next 开始存储，头指针可以从头结点的 next 开始遍历。 对于结点的前插操作，找到对应位置的结点，设新结点为该节点的后继结点，将该结点的 data 后移至新结点的 d
[ 数据结构_C实现 ] 无头单向非循环链表的简单实现(单链表)
CSDN博客
03-15 1833
目录 1. 链表 1.1 链表的概念及结构 1.2链表的分类 1.3接口 2. 接口实现 2.1 节点的创建 2.2 打印链表 2.3 创建新节点 2.4尾插 2.5头插 2.6 尾删 2.7 头删 2.8查找 2.9在pos位置之前插入 2.10在pos位置之后插入 2.11 删除pos位置 2.12删除pos后面的值 3.菜单 1. 链表 1.1 链表的概念及结构 概念：链表是一种物理存储结构上非连续、非顺序的存储结构...
单链表创建（有无头结点）
最新发布
2301_76657443的博客
04-28 199
在带头结点的方式下，头结点的作用是指向第一个实际的结点，并且它的data值通常为空，作为链表的起始位置，便于操作链表。而在不带头结点的方式下，直接使用第一个实际的结点作为链表的起始位置。创建链表时，带头结点的方式需要额外分配一个头结点的内存空间，并将头结点的next指针指向第一个实际的结点；总的来说，带头结点的方式相比不带头结点的方式多了一个头结点，用来标识链表的起始位置，并使链表的操作更加统一和便捷。在查找值为x的结点时，带头结点的方式需要将头结点的next指针作为参数传入查找函数中，以忽略头结点；
【数据结构入门】无头单向非循环链表（SList）详解（定义、增、删、查、改） | 图解链表，超生动详细哦~
codewinter的博客
08-28 2375
文章目录（1）链表介绍1）为什么引入链表2）链表的概念及结构3）链表的分类（2）无头单向非循环链表的实现1）单链表的定义2）动态申请一个节点3）打印单链表4）单链表尾插5）单链表头插6）单链表尾删7）单链表头删8）在单链表中查找指定值的节点9）单链表在pos位置之后插入10）单链表删除指定pos位置的节点11）单链表删除指定pos位置之后的节点12）求单链表长度13）判断单链表是否为空12）求单链表长度13）判断单链表是否为空 学习链表之前，建议先学习下顺序表，配合这篇文章食用更佳哦： 【数据结构入门】顺序
5-数据结构-单链表的初始化（头结点和无头结点）
奔心小韩的博客
01-19 807
单链表的初始化
数据结构 无头节点的单链表 创建
qq_44000144的博客
04-02 101
【代码】数据结构 无头节点的单链表 创建。
数据结构复习----线性表
qq_53732836的博客
04-05 1079
1.线性表的基本操作 &表示C++语言中的引用调用 什么时候要传入参数的引用“&”--对参数的修改结果需要“带回来” （1）未使用&时的代码
无头节点的单链表
07-17
无头节点单链表的实现可是说是对C语言指针一个最直接、最贴合实际、也是最具有归纳性的程序设计应用。许多C语言基础面试题都涉及单链表的实现和构造，其目的就是考察面试者对C语言基础数据类型是否有足够的了解，对C语言指针是否掌握。链表的实现可以简单也可以很复杂，只是我们对待问题的态度不同，回想起了大学刚学习链表的时候，总是对链表中用到的结构体和链表节点有很多的迷茫，直到后来仔细研究了一番，并且写下了这个代码才解开了心中很久的困惑。 回看了一下自己写的这个单链表的实现，注释写的非常详细了，包括了单链表中二级指针的应用场景，为什么要使用二级指针这些问题都有一个详细的总结，也包括链表节点的结构体和学生个人信息结构体的这些区分。可以说是楼主就是从这个阶段才正真开始对结构体，对指针，对链表的“数据域”，“指针域”有了较为清晰的了解。 上传这些代码完全因为楼主确实想把自己学习过程中的遇到到一些问题和错误认识，以及一些经验共享出来，希望帮助那些和曾经的我一样充满迷茫困惑的同学朋友。
链表(1)C语言实现 单链表 无头结点 基本操作 无头结点单链表的基本操作 详解 链表的概念及结构 数据结构
weixin_63666347的博客
04-28 2477
3.链表 3.1 链表的概念及结构 概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表 中的指针链接次序实现的 注意： 1.从上图可看出，链式结构在逻辑上是连续的，但是在物理上不一定连续 2.现实中的结点一般都是从堆上申请出来的 3.从堆上申请的空间是按照一定的策略来分配的，两次申请的空间可能连续也可能不连续 3.2 链表的分类 1. 单向或者双向 2. 带头或者不带头 3. 循环或者非循环 3.3 单链表的实现 ...
学习c++不带头结点的链队基本操作（王道数据结构队列的链式存储）
ytswld的博客
04-27 477
c++链队不带头结点
[C语言、C++]数据结构作业：线性表-单链表(无头节点)的基本操作
Yhisken的博客
09-30 674
[C语言、C++]数据结构作业：线性表-单链表(无头节点)的基本操作
（无头结点）单链表的基本操作（C++实现）
weixin_56781972的博客
03-17 113
void SList::SListInsert(Node* pos,SLDataType x)//在pos的前面插入x。SList::Node* SList::BuySListNode(SLDataType x)//开辟新结点。void SList::SListPushFront(SLDataType x)//头插。void SList::SListErase(Node* pos)//删除pos位置的值。void SList::SListPushBack(SLDataType x)//尾插。
【数据结构】-单链表(无头结点）
RunningSnail的博客
07-18 4075
单链表-无头结点1.头文件及类型定义2.单链表结点类型定义3.函数声明4.基本操作4.1 初始化单链表4.2 判空4.3 插入操作4.3.1 按位插入4.3.2 指定结点插入4.3.2.1 指定结点后插4.3.2.2 指定结点前插4.3.2.2.1 前插法1(时间复杂度为O(n))4.3.2.2.2 前插法2(时间复杂的为O(1))4.4 删除操作4.4.1 按位删除4.4.2 指定结点删除4.4.2.1 删除法1(时间复杂度为O(n))4.4.2.2 删除法2(时间复杂度为O(1))4.5 查找操作4.5
实参形参与指针5——无头结点循环链表与带头结点循环链表
weixin_42224065的博客
10-17 1775
虽然C语言的指针偏向底层，不利于上手和大型项目开发（某些），但是用C去实现链表基本操作是有利于我们的代码功底的。而且在实现的过程中，实现远比理解要复杂困难的多，尤其是循环链表，当你实现过就会发现，为啥你的大学老师总是劝你要带头结点了。
单链表实现（C语言版，无头结点）
05-02 6395
前言：单链表：它是一种链式储存的线性表，用一组地址任意的储存单元存放线性表的数据元素；称储存单元为一个结点；结点：值域+指针域 链表：二、代码实现（1）结点定义：typedef int DataType; typedef struct ListNode { struct ListNode* next; DataType data; }Node,*PNode;typedef stru
无头结点单链表基本操作
玩世不恭的博客
04-17 2388
linklist.h #pragma once #include &amp;lt;stdio.h&amp;gt; #include &amp;lt;assert.h&amp;gt; #include &amp;lt;malloc.h&amp;gt; #include &amp;lt;stdlib.h&amp;gt; #include &amp;lt;string.h&amp;gt; typedef int DataType;
数据结构之—线性表之—浅谈单链表有头结点和无头节点
weeks
04-26 7034
有头结点的链表统一了算法的实现，无头节点减少了节点个数，但是只有根据实际情况选用真正的有无头接链表 待续：//代码实现 待续：//代码实现 待续：//代码实现
试编写在无头结点的单链表上实现将元素x插入到线性表的第i个位置。
03-21
以下是在无头结点的单链表上实现将元素x插入到线性表的第i个位置的代码： ``` void insert(Node* &head, int i, int x) { Node* p = head; int j = 0; while (p != NULL && j < i - 1) { p = p->next; j++; } if (p == NULL || j > i - 1) { cout << "插入位置不合法" << endl; return; } Node* s = new Node; s->data = x; s->next = p->next; p->next = s; } ``` 其中，Node是链表节点的结构体，包含数据域data和指针域next。head是链表头指针，指向链表的第一个节点。在插入元素时，先遍历链表找到第i-1个节点，然后在其后面插入新节点。如果插入位置不合法，则输出错误信息。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Silver Star

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值