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

已于 2022-10-07 23:57:44 修改
阅读量2.9k 收藏 108
点赞数 21
分类专栏： 数据结构 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
关注
  • 21
    点赞
  • 踩
  • 108
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 8
    评论
专栏目录
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
代码包含顺序表和单链表的基本操作（增删改查等，详见注释），并展示了两个具体使用例子，包括对基本操作的验证和合并两个有序线性表为一个有序表。代码均已通过Dev-C++5.4.0，为了防止误修改，文档已限制编辑，密码...
无头结点的单链表的实现
yahid的博客
05-09 3908
链表是基于顺序表之后的一种更加高效的数据结构，他能够有效的增删改查，比顺序表的效率提高了很多。下面我们来实现这一数据结构。 不光是实现，我们还需要通过几个功能来加深大家对链表的理解，这列功能包括链表中的节点我们都设置在一个Linkedlist类里面 public class Linkedlist { } 然后让主类来实现它Linkedlist类里面的方法 public class MyLinkedlist { public static void main(String[] args)
【数据结构与算法】 - (不带头结点)单链表详细实现思路及代码(C/C++语言)
wkd_007的博客
03-26 5796
文章先介绍 “头结点” 在链表的作用，以及 “有头结点” 和 “无头结点” 的区别，然后再详细介绍了“无头结点链表” 的实现步骤，最后给出了 “无头结点单链表” 的C语言实现代码，同时也给出了 “有头结点单链表” 的C语言实现代码。读者可以对比这两份代码，将会对单链表的“头结点”有非常深刻的理解。
单链表创建（有无头结点）
最新发布
2301_76657443的博客
04-28 200
在带头结点的方式下，头结点的作用是指向第一个实际的结点，并且它的data值通常为空，作为链表的起始位置，便于操作链表。而在不带头结点的方式下，直接使用第一个实际的结点作为链表的起始位置。创建链表时，带头结点的方式需要额外分配一个头结点的内存空间，并将头结点的next指针指向第一个实际的结点；总的来说，带头结点的方式相比不带头结点的方式多了一个头结点，用来标识链表的起始位置，并使链表的操作更加统一和便捷。在查找值为x的结点时，带头结点的方式需要将头结点的next指针作为参数传入查找函数中，以忽略头结点；
单链表（不带头结点）
qq_39628738的博客
02-19 6004
单链表不带头结点结构体设计： //不带头结点的结构体设计： typedef int ELEM_TYPE; //有效数据节点结构体设计 typedef struct Node { ELEM_TYPE data;//数据域 （1.头结点：不保存任何数据 2.有效数据节点：保存有效值） struct Node* next;//指针域 (1.头结点：保存第一个元素的地址 2.有效数据节点：保存下一个有效元素的地址) }Node, * PNode; 老规矩，实现链表的基本功能：增删
无头节点--单链表
qq_53010164的博客
04-01 1710
目录 一、单链表打印： 二、增容 三、单链表尾插 四、单链表头插 五、单链表尾删 六、单链表头删 七、单链表的查找 八、单链表在pos之后插入X 九、单链表在pos之前插入X 十、删除pos位置 十一、删除pos之后的位置 十二、销毁链表 总代码： Slistexe.h Slistexe.c test.c 部分运行结果：​ 一、单链表打印： //打印 void SListprint(SL* phead) { SL* cur = phead; whil...
数据结构 严薇敏 单链表（无头结点）的实现(增 删 改 查)及其使用方法详解
qq_50119037的博客
03-19 1318
1.与顺序表的对比 书接上回！我们修炼了顺序表的内功，但是在很多使用场景，他都很受限制！ 缺点： 插入删除的时候，还记得吗！我们都要搬运元素到指定位置，时间复杂度是O(N). 你的顺序表容量是提前给的，扩容的时候还要拷贝数据，开辟新空间，释放旧空间，会有很大的性能消耗。 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。若每次扩容扩少一点，则会导致频繁扩容，频繁扩容同样也会有性能消耗
数据结构C语言版-线性表的单链表存储结构表示和实现优质资料.doc
12-02
4. 线性表的单链表存储结构表示：使用C语言实现单链表的存储结构，包括头结点和数据结点，每个结点包含数据域和指针域。 5. 线性表的操作：对线性表的基本操作包括构造空表、销毁表、清空表、判断表是否为空、获取...
数据结构实验一线性表的基本操作.docx
03-28
数据结构实验一线性表的基本操作 一、线性表的概念和类型 ...数据结构实验一线性表的基本操作的实验结果证明了线性表的基本操作的实现，并且实现了多项式相加的功能。实验结果表明了线性表的重要性和实用性。
头歌数据结构单链表的基本操作
05-18
头歌数据结构单链表的基本操作 第1关单链表的插入操作 第2关单链表的删除操作 第3关单链表的按照序号查找值操作 第4关单链表的按照值查找结点位序的操作 第5关单链表的逆置操作 第6关两个有序单链表的合并操作 稳过 ...
带头结点的单链表结构实现线性表操作.cpp
09-25
带头结点的单链表结构实现线性表操作.cpp
无头结点的单链表（C语言）
weixin_33863087的博客
09-22 3116
1.单链表： 　　在顺序表中，用一组地址连续的存储单元来一次存放线性表的结点，因此结点的逻辑顺序与物理顺序是一致的。但链表却不同，链表是用一组任意的存储单元来存放 线性表的结点，这组存储单元可以是连续的，也可以是非连续的，甚至是零散分布在内存的任何位置上。因此，链表中结点的逻辑顺序与物理顺序不一定相同。为了正确表示节点间的逻辑关系，必须在存储线性表的每个数据元素的同时，存储指示其后继结点的地址信...
数据结构基础-C/C++实现单链表（无头结点）
qq_42908756的博客
04-11 1540
定义一个结构体 /** * @brief 链表节点 */ typedef struct LinkedNode{ // 存储数据 int data; // 下一个节点的地址 LinkedNode *next; }LinkedNode, *LinkedList; 初始化 /** * @brief 初始化一个不带头结点的单链表 * * @return LinkedList NULL */ LinkedList initLinkedListNoHead() { // 因为.
C++ 单链表（无头结点）
qq_43650934的博客
11-17 5001
文章目录总结归纳代码实现 总结归纳 头结点可以没有，头指针必须有。访问整个链表，是用过遍历头指针来进行的。 这里没有特别的设置一个头指针，因为当指针指向整个链表 L 时，该指针的实现效果就是头指针。 不带头结点的单链表，即单链表的第一个结点就存储数据，头指针也指向第一个结点；带头结点的单链表，第一个结点是头结点，不存储数据，从头结点的 next 开始存储，头指针可以从头结点的 next 开始遍历。 对于结点的前插操作，找到对应位置的结点，设新结点为该节点的后继结点，将该结点的 data 后移至新结点的 d
[ 数据结构_C实现 ] 无头单向非循环链表的简单实现(单链表)
CSDN博客
03-15 1837
目录 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 链表的概念及结构 概念：链表是一种物理存储结构上非连续、非顺序的存储结构...
王道代码版单链表头插法,不带头的头插法,尾插法,不带头的尾插法的总结
Abigail路小雨的博客
09-17 2905
在编译器上面编译发现很容易控制台打印不出来,这可能就是细节所在,但是网上也没有很全的全代码输出的案例.我做题的感觉写的是对的其实并不对,你只是第六感感觉是对的仅此而已!!!要注意引以为戒,下面总结一下我自己写的可以运行的非伪码 首先定义结构体 typedef int Elemtype; //定义结构体 typedef struct node{ Elemtype data; struct node * next; }LNode,*LinkList; 1.1⚠️ 头插法建立单链表 //1.1⚠
无头单向链表
Ljiyu0506的博客
06-14 405
链表的概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。 结构示意图：由前一个链表中的指针指向下一个链表的地址，在逻辑上是连续的。 优点：1. 无头单向链表可以轻松地插入或删除链表的头部和尾部，因为它不需要像有头链表一样先找到头部节点。 2. 在某些情况下，无头单向链表可以在空间上更加高效，因为它不需要额外的头节点。
数据结构：单向链表（无头非循环）
Yikefore的博客
04-22 824
数据结构：单向无头非循环链表的详细介绍以及实现过程。
C++ 无/有表头节点单链表——头插法
qq_62015542的博客
03-26 2959
单链表头插法的算法
试编写在无头结点的单链表上实现将元素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、付费专栏及课程。

余额充值