数据结构之不带头结点和带头结点的单链表操作

最新推荐文章于 2023-10-12 11:21:08 发布
最新推荐文章于 2023-10-12 11:21:08 发布
阅读量278 收藏
点赞数 1
分类专栏： 算法 文章标签： 数据结构 链表 单链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45106146/article/details/106460950
版权 
// list.h 
#pragma once
#ifndef __LIST_H
#define __LIST_H

typedef struct _LinkNode {
    void* data;
    struct _LinkNode* next;
} LinkList, LinkNode;

typedef struct _List {
    LinkList* head;
    LinkList* tail;
    int (*Compar)(const void* key1, const void* key2);
    void (*Destroy)(void* data);
    void (*Display)(void* data);
} List;

#define LIST_DATA(node) ((node)->data)
#define LIST_NEXT(node) ((node)->next)
#define LIST_HEAD(L)    ((L)->head)
#define LIST_TAIL(L)    ((L)->tail)     

void ListInit(List* L,
    void (*Destroy)(void* data),
    int (*Compar)(const void* key1, const void* key2),
    void (*Display)(void* data));
void ListDestroy(List* L);
int  ListEmpty(List* L);
int  ListInsNext(List* L, LinkNode* node, const void* data);
int  ListRemNext(List* L, LinkNode* node, void** data);
int  ListSize(List* L);
int  ListInsByIdx(List* L, int idx, const void* data);
int  ListRemByIdx(List* L, int idx, void** data);
LinkNode* ListSearch(List* L, const void* data);
void ListDisplay(List* L);

void ListInit_WH(List* L,
    void (*Destroy)(void* data),
    int (*Compar)(const void* key1, const void* key2),
    void (*Display)(void* data));
void ListDestroy_WH(List* L);
int  ListEmpty_WH(List* L);
int  ListInsNext_WH(List* L, LinkNode* node, const void* data);
int  ListRemNext_WH(List* L, LinkNode* node, void** data);
int  ListSize_WH(List* L);
int  ListInsByIdx_WH(List* L, int idx, const void* data);
int  ListRemByIdx_WH(List* L, int idx, void** data);
LinkNode* ListSearch_WH(List* L, const void* data);
void ListDisplay_WH(List* L);

#endif

// list.c 
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include "list.h"


/* 不带头结点的单链表操作 */
void ListInit(List* L,
    void (*Destroy)(void* data),
    int (*Compar)(const void* key1, const void* key2),
    void (*Display)(void* data))
{
    LIST_HEAD(L) = NULL;
    LIST_TAIL(L) = NULL;
    L->Destroy = Destroy;
    L->Compar = Compar;
    L->Display = Display;

    return;
}

void ListDestroy(List* L)
{
    LinkNode* p;

    for (p = LIST_HEAD(L); p != NULL; p = LIST_NEXT(p)) {
        L->Destroy(LIST_DATA(p));
        free(p);
    }

    (void)memset(L, 0, sizeof(List));
    return;
}

int  ListEmpty(List* L)
{
    if (!LIST_HEAD(L)) {
        return 1;
    }
    else {
        return 0;
    }
}

int  ListInsNext(List* L, LinkNode* node, const void* data)
{
    LinkNode* newNode;

    
    newNode = (LinkNode*)malloc(sizeof(LinkNode));
    if (!newNode) { return -1; }
    newNode->data = (void*)data;
    newNode->next = NULL;

    /* 当node为NULL时，表示在链表第一个结点之前插入 */
    if (node == NULL) {
        if (ListEmpty(L)) {
            LIST_TAIL(L) = newNode;
        }
        newNode->next = LIST_HEAD(L);
        LIST_HEAD(L) = newNode;
    }
    else {
        if (node->next == NULL) {
            LIST_TAIL(L) = newNode;
        }
        newNode->next = node->next;
        node->next = newNode;
    }
    return 0;
}

/* node为NULL，表示删除第一个结点 */
int  ListRemNext(List* L, LinkNode* node, void** data)
{
    LinkNode* p;

    if (ListEmpty(L)) {
        *data = NULL;
        return 0;
    }

    if (node == NULL) {
        p = LIST_HEAD(L);
        *data = p->data;
        LIST_HEAD(L) = p->next;
        if (p->next == NULL) { /* 链表只有一个结点 */
            LIST_TAIL(L) = NULL;
        }
    }
    else {
        if (node == LIST_TAIL(L)) {
            *data = NULL;
            return 0;
        }
        else {
            p = node->next;
            *data = p->data;
            node->next = p->next;
            if (p->next == NULL) {
                LIST_TAIL(L) = node;
            }
        }
    }
    free(p);
    return 0;
}

LinkNode* ListSearch(List* L, const void* data)
{
    LinkNode* p;

    for (p = LIST_HEAD(L); p != NULL; p = LIST_NEXT(p)) {
        if (L->Compar(p->data, (void*)data) == 0) {
            return p;
        }
    }
    return NULL;
}

int ListSize(List* L)
{
    int size = 0;
    LinkNode* p;

    for (p = LIST_HEAD(L); p != NULL; p = LIST_NEXT(p)) {
        size++;
    }

    return size;
}

int ListInsByIdx(List* L, int idx, const void* data)
{
    int size;
    int i;
    LinkNode* p;

    size = ListSize(L);
    if (idx < 1 || idx > size + 1) {
        return -1;
    }

    if (idx == 1) {
        return ListInsNext(L, NULL, data);
    }

    if (idx == size + 1) {
        return ListInsNext(L, LIST_TAIL(L), data);
    }

    i = 1;
    p = LIST_HEAD(L);
    while (p && (i < idx - 1)) {
        p = LIST_NEXT(p);
        i++;
    }

    return ListInsNext(L, p, data);
}

int ListRemByIdx(List* L, int idx, void** data)
{
    int size;
    int i;
    LinkNode* p;

    size = ListSize(L);
    if (idx < 1 || idx > size) {
        return -1;
    }

    if (idx == 1) {
        return ListRemNext(L, NULL, data);
    }

    i = 1;
    p = LIST_HEAD(L);
    while (p && (i < idx - 1)) {
        p = LIST_NEXT(p);
        i++;
    }

    return ListRemNext(L, p, data);
}

void  ListDisplay(List* L)
{
    LinkNode* p;

    if (ListEmpty(L)) {
        printf("\nList is Empty.");
        return ;
    }

    p = LIST_HEAD(L)->data;
    printf("\nHEAD:%d", *(int*)p);
    p = LIST_TAIL(L)->data;
    printf("\nTAIL:%d\n", *(int*)p);

    for (p = LIST_HEAD(L); p != NULL; p = LIST_NEXT(p)) {
        L->Display(p->data);
    }

    return;
}

/* 带头结点的单链表操作 */
void ListInit_WH(List* L,
    void (*Destroy)(void* data),
    int (*Compar)(const void* key1, const void* key2),
    void (*Display)(void* data))
{
    LinkNode* p;

    p = (LinkNode*)malloc(sizeof(LinkNode));
    if (!p) { return ; }
    p->next = NULL;

    LIST_HEAD(L) = p;
    LIST_TAIL(L) = p;
    L->Destroy = Destroy;
    L->Compar = Compar;
    L->Display = Display;

    return;
}

void ListDestroy_WH(List* L)
{
    LinkNode* p;

    for (p = LIST_HEAD(L)->next; p != NULL; p = LIST_NEXT(p)) {
        L->Destroy(LIST_DATA(p));
        free(p);
    }

    if (LIST_HEAD(L)) { free(LIST_HEAD(L)); }
    (void)memset(L, 0, sizeof(List));
    return;
}

int  ListEmpty_WH(List* L)
{
    LinkNode* p = LIST_HEAD(L)->next;

    if (!p) {
        return 1;
    }
    else {
        return 0;
    }
}

int  ListInsNext_WH(List* L, LinkNode* node, const void* data)
{
    LinkNode* newNode;

    if (!node) { return -1; }

    newNode = (LinkNode*)malloc(sizeof(LinkNode));
    if (!newNode) { return -1; }
    newNode->data = (void*)data;
    newNode->next = NULL;

    if (node->next == NULL) {
        LIST_TAIL(L) = newNode;
    }
    newNode->next = node->next;
    node->next = newNode;
    
    return 0;
}

int  ListRemNext_WH(List* L, LinkNode* node, void** data)
{
    LinkNode* p;

    if (ListEmpty_WH(L)) {
        *data = NULL;
        return 0;
    }

    if (node == LIST_TAIL(L)) {
        *data = NULL;
        return 0;
    }
    else {
        p = node->next;
        *data = p->data;
        node->next = p->next;
        if (p->next == NULL) {
            LIST_TAIL(L) = node;
        }
    }
    
    free(p);
    return 0;
}

LinkNode* ListSearch_WH(List* L, const void* data)
{
    LinkNode* p;

    for (p = LIST_HEAD(L)->next; p != NULL; p = LIST_NEXT(p)) {
        if (L->Compar(p->data, (void*)data) == 0) {
            return p;
        }
    }
    return NULL;
}

int ListSize_WH(List* L)
{
    int size = 0;
    LinkNode* p;

    for (p = LIST_HEAD(L)->next; p != NULL; p = LIST_NEXT(p)) {
        size++;
    }

    return size;
}

int ListInsByIdx_WH(List* L, int idx, const void* data)
{
    int size;
    int i;
    LinkNode* p;

    size = ListSize_WH(L);
    if (idx < 1 || idx > size + 1) {
        return -1;
    }

    if (idx == size + 1) {
        return ListInsNext_WH(L, LIST_TAIL(L), data);
    }
    
    i = 0;
    p = LIST_HEAD(L);
    while (p && (i < idx - 1)) {
        p = LIST_NEXT(p);
        i++;
    }

    return ListInsNext_WH(L, p, data);
}

int ListRemByIdx_WH(List* L, int idx, void** data)
{
    int size;
    int i;
    LinkNode* p;

    size = ListSize(L);
    if (idx < 1 || idx > size) {
        return -1;
    }

    i = 0;
    p = LIST_HEAD(L);
    while (p && (i < idx - 1)) {
        p = LIST_NEXT(p);
        i++;
    }

    return ListRemNext(L, p, data);
}

void  ListDisplay_WH(List* L)
{
    LinkNode* p;

    if (ListEmpty_WH(L)) {
        printf("\nList is Empty.");
        return;
    }

    p = LIST_HEAD(L)->next->data;
    printf("\nHEAD:%d", *(int*)p);
    p = LIST_TAIL(L)->data;
    printf("\nTAIL:%d\n", *(int*)p);

    for (p = LIST_HEAD(L)->next; p != NULL; p = LIST_NEXT(p)) {
        L->Display(p->data);
    }

    return;
}

// main.c
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include "list.h"

void Destroy(void* data)
{
    if (data) {
        free((int*)data);
    }
}

int Compar(const void* key1, const void* key2)
{
    return *(int*)key1 - *(int*)key2;
}

void Display(void* data)
{
    printf("%d\t", *(int*)data);
}

void MenuList(void)
{
    printf("\n          单链表的操作");
    printf("\n==================================");
    printf("\n|   1--第一个结点之前插入");
    printf("\n|   2--第一个结点之后插入");
    printf("\n|   3--最后一个结点之后插入");
    printf("\n|   4--指定位置插入");
    printf("\n|   5--删除第一个结点");
    printf("\n|   6--指定位置删除");
    printf("\n|   7--查找");
    printf("\n|   8--显示");
    printf("\n|   0--返回");
    printf("\n==================================");
    printf("\n请输入菜单号(0~8):");
}

int ListOperation(void)
{
    List L;
    char ch1, ch2;
    int elem = 12345678, idx = 0;
    int* oldElem, * newElem;
    int ret;

    ListInit(&L, Destroy, Compar, Display);

    ch1 = 'y';
    while (ch1 == 'y' || ch1 == 'Y') {
        MenuList();

        scanf_s("%c", &ch2, 1);
        (void)getchar();
        switch (ch2) {
        case '1':
            printf("\n请输入插入的元素值:");
            scanf_s("%d", &elem);
            (void)getchar();
            newElem = (int*)malloc(sizeof(int));
            if (!newElem) { exit(1); }
            *newElem = elem;
            ret = ListInsNext(&L, NULL, (void*)newElem);
            if (!ret) {
                printf("\n插入成功!");
            }
            else {
                printf("\n插入失败");
                Destroy((void*)newElem);
            }
            break;
        case '2':
            printf("\n请输入插入的元素值:");
            scanf_s("%d", &elem);
            (void)getchar();
            newElem = (int*)malloc(sizeof(int));
            if (!newElem) { exit(1); }
            *newElem = elem;
            ret = ListInsNext(&L, LIST_HEAD(&L), (void*)newElem);
            if (!ret) {
                printf("\n插入成功!");
            }
            else {
                printf("\n插入失败");
            }
            break;
        case '3':
            printf("\n请输入插入的元素值:");
            scanf_s("%d", &elem);
            (void)getchar();
            newElem = (int*)malloc(sizeof(int));
            if (!newElem) { exit(1); }
            *newElem = elem;
            ret = ListInsNext(&L, LIST_TAIL(&L), (void*)newElem);
            if (!ret) {
                printf("\n插入成功!");
            }
            else {
                printf("\n插入失败");
            }
            break;
        case '4':
            printf("\n请输入插入的位置(1~%d)和元素值:", ListSize(&L) + 1);
            scanf_s("%d,%d", &idx, &elem);
            (void)getchar();
            newElem = (int*)malloc(sizeof(int));
            if (!newElem) { exit(1); }
            *newElem = elem;
            ret = ListInsByIdx(&L, idx, (void*)newElem);
            if (!ret) {
                printf("\n插入成功!");
            }
            else {
                printf("\n插入失败");
            }
            break;
        case '5':
            ret = ListRemNext(&L, NULL, (void**)(&oldElem));
            if (!ret) {
                printf("\n删除成功!");
            }
            else {
                printf("\n删除失败!");
            }
            break;
        case '6':
            if (!ListSize(&L)) {
                printf("\n链表序列为空!");
                break;
            }
            printf("\n请输入结点位置(1~%d):", ListSize(&L));
            scanf_s("%d", &idx);
            (void)getchar();
            ret = ListRemByIdx(&L, idx, (void**)(&oldElem));
            if (!ret) {
                printf("\n删除成功!");
            }
            else {
                printf("\n删除失败!");
            }
            break;
        case '7':
            printf("\n请输入要查找的元素值:");
            scanf_s("%d", &elem);
            (void)getchar();
            if (ListSearch(&L, (void*)(&elem))) {
                printf("\n查找成功!");
            }
            else {
                printf("\n查找失败");
            }
            break;
        case '8':
            printf("\n链表序列:");
            ListDisplay(&L);
            break;
        case '0':
            ch1 = 'n';
            break;
        default:
            printf("\n输入有误,请输入0~8进行选择！");
            break;
        }
    }

    return 0;
}

int ListOperation_WH(void)
{
    List L;
    char ch1, ch2;
    int elem, idx;
    int* oldElem, * newElem;
    int ret;

    ListInit_WH(&L, Destroy, Compar, Display);

    ch1 = 'y';
    while (ch1 == 'y' || ch1 == 'Y') {
        MenuList();

        scanf_s("%c", &ch2, 1);
        (void)getchar();
        switch (ch2) {
        case '1':
            printf("\n请输入插入的元素值:");
            scanf_s("%d", &elem);
            (void)getchar();
            newElem = (int*)malloc(sizeof(int));
            if (!newElem) { exit(1); }
            *newElem = elem;
            ret = ListInsNext_WH(&L, LIST_HEAD(&L), (void*)newElem);
            if (!ret) {
                printf("\n插入成功!");
            }
            else {
                printf("\n插入失败");
                Destroy((void*)newElem);
            }
            break;
        case '2':
            printf("\n请输入插入的元素值:");
            scanf_s("%d", &elem);
            (void)getchar();
            newElem = (int*)malloc(sizeof(int));
            if (!newElem) { exit(1); }
            *newElem = elem;
            ret = ListInsNext_WH(&L, LIST_HEAD(&L)->next, (void*)newElem);
            if (!ret) {
                printf("\n插入成功!");
            }
            else {
                printf("\n插入失败");
            }
            break;
        case '3':
            printf("\n请输入插入的元素值:");
            scanf_s("%d", &elem);
            (void)getchar();
            newElem = (int*)malloc(sizeof(int));
            if (!newElem) { exit(1); }
            *newElem = elem;
            ret = ListInsNext_WH(&L, LIST_TAIL(&L), (void*)newElem);
            if (!ret) {
                printf("\n插入成功!");
            }
            else {
                printf("\n插入失败");
            }
            break;
        case '4':
            printf("\n请输入插入的位置(1~%d)和元素值:", ListSize_WH(&L) + 1);
            scanf_s("%d,%d", &idx, &elem);
            (void)getchar();
            newElem = (int*)malloc(sizeof(int));
            if (!newElem) { exit(1); }
            *newElem = elem;
            ret = ListInsByIdx_WH(&L, idx, (void*)newElem);
            if (!ret) {
                printf("\n插入成功!");
            }
            else {
                printf("\n插入失败");
            }
            break;
        case '5':
            ret = ListRemNext_WH(&L, LIST_HEAD(&L), (void**)(&oldElem));
            if (!ret) {
                printf("\n删除成功!");
            }
            else {
                printf("\n删除失败");
            }
            break;
        case '6':
            if (!ListSize_WH(&L)) {
                printf("\n链表序列为空!");
                break;
            }
            printf("\n请输入结点位置(1~%d):", ListSize_WH(&L));
            scanf_s("%d", &idx);
            (void)getchar();
            ret = ListRemByIdx_WH(&L, idx, (void**)(&oldElem));
            if (!ret) {
                printf("\n删除成功!");
            }
            else {
                printf("\n删除失败");
            }
            break;
        case '7':
            printf("\n请输入要查找的元素值:");
            scanf_s("%d", &elem);
            (void)getchar();
            if (ListSearch_WH(&L, (void*)(&elem))) {
                printf("\n查找成功!");
            }
            else {
                printf("\n查找失败");
            }
            break;
        case '8':
            printf("\n链表序列:");
            ListDisplay_WH(&L);
            break;
        case '0':
            ch1 = 'n';
            break;
        default:
            printf("\n输入有误,请输入0~8进行选择！");
            break;
        }
    }

    return 0;
}

int main(int* argc, char** argv)
{
    (void)ListOperation(); /* 不带头结点的单链表操作 */
    //(void)ListOperation_WH(); /* 带头结点的单链表操作 */
    return 0;
}

执行结果：


          单链表的操作
==================================
|   1--第一个结点之前插入
|   2--第一个结点之后插入
|   3--最后一个结点之后插入
|   4--指定位置插入
|   5--删除第一个结点
|   6--指定位置删除
|   7--查找
|   8--显示
|   0--返回
==================================
请输入菜单号(0~8):1

请输入插入的元素值:100

插入成功!
          单链表的操作
==================================
|   1--第一个结点之前插入
|   2--第一个结点之后插入
|   3--最后一个结点之后插入
|   4--指定位置插入
|   5--删除第一个结点
|   6--指定位置删除
|   7--查找
|   8--显示
|   0--返回
==================================
请输入菜单号(0~8):2

请输入插入的元素值:200

插入成功!
          单链表的操作
==================================
|   1--第一个结点之前插入
|   2--第一个结点之后插入
|   3--最后一个结点之后插入
|   4--指定位置插入
|   5--删除第一个结点
|   6--指定位置删除
|   7--查找
|   8--显示
|   0--返回
==================================
请输入菜单号(0~8):3

请输入插入的元素值:300

插入成功!
          单链表的操作
==================================
|   1--第一个结点之前插入
|   2--第一个结点之后插入
|   3--最后一个结点之后插入
|   4--指定位置插入
|   5--删除第一个结点
|   6--指定位置删除
|   7--查找
|   8--显示
|   0--返回
==================================
请输入菜单号(0~8):8

链表序列:
HEAD:100
TAIL:300
100     200     300
          单链表的操作
==================================
|   1--第一个结点之前插入
|   2--第一个结点之后插入
|   3--最后一个结点之后插入
|   4--指定位置插入
|   5--删除第一个结点
|   6--指定位置删除
|   7--查找
|   8--显示
|   0--返回
==================================
请输入菜单号(0~8):4

请输入插入的位置(1~4)和元素值:1,500

插入成功!
          单链表的操作
==================================
|   1--第一个结点之前插入
|   2--第一个结点之后插入
|   3--最后一个结点之后插入
|   4--指定位置插入
|   5--删除第一个结点
|   6--指定位置删除
|   7--查找
|   8--显示
|   0--返回
==================================
请输入菜单号(0~8):8

链表序列:
HEAD:500
TAIL:300
500     100     200     300
          单链表的操作
==================================
|   1--第一个结点之前插入
|   2--第一个结点之后插入
|   3--最后一个结点之后插入
|   4--指定位置插入
|   5--删除第一个结点
|   6--指定位置删除
|   7--查找
|   8--显示
|   0--返回
==================================
请输入菜单号(0~8):4

请输入插入的位置(1~5)和元素值:5,600

插入成功!
          单链表的操作
==================================
|   1--第一个结点之前插入
|   2--第一个结点之后插入
|   3--最后一个结点之后插入
|   4--指定位置插入
|   5--删除第一个结点
|   6--指定位置删除
|   7--查找
|   8--显示
|   0--返回
==================================
请输入菜单号(0~8):8

链表序列:
HEAD:500
TAIL:600
500     100     200     300     600
          单链表的操作
==================================
|   1--第一个结点之前插入
|   2--第一个结点之后插入
|   3--最后一个结点之后插入
|   4--指定位置插入
|   5--删除第一个结点
|   6--指定位置删除
|   7--查找
|   8--显示
|   0--返回
==================================
请输入菜单号(0~8):4

请输入插入的位置(1~6)和元素值:2,700

插入成功!
          单链表的操作
==================================
|   1--第一个结点之前插入
|   2--第一个结点之后插入
|   3--最后一个结点之后插入
|   4--指定位置插入
|   5--删除第一个结点
|   6--指定位置删除
|   7--查找
|   8--显示
|   0--返回
==================================
请输入菜单号(0~8):8

链表序列:
HEAD:500
TAIL:600
500     700     100     200     300     600
          单链表的操作
==================================
|   1--第一个结点之前插入
|   2--第一个结点之后插入
|   3--最后一个结点之后插入
|   4--指定位置插入
|   5--删除第一个结点
|   6--指定位置删除
|   7--查找
|   8--显示
|   0--返回
==================================
请输入菜单号(0~8):5

删除成功!
          单链表的操作
==================================
|   1--第一个结点之前插入
|   2--第一个结点之后插入
|   3--最后一个结点之后插入
|   4--指定位置插入
|   5--删除第一个结点
|   6--指定位置删除
|   7--查找
|   8--显示
|   0--返回
==================================
请输入菜单号(0~8):8

链表序列:
HEAD:700
TAIL:600
700     100     200     300     600
          单链表的操作
==================================
|   1--第一个结点之前插入
|   2--第一个结点之后插入
|   3--最后一个结点之后插入
|   4--指定位置插入
|   5--删除第一个结点
|   6--指定位置删除
|   7--查找
|   8--显示
|   0--返回
==================================
请输入菜单号(0~8):6

请输入结点位置(1~5):3

删除成功!
          单链表的操作
==================================
|   1--第一个结点之前插入
|   2--第一个结点之后插入
|   3--最后一个结点之后插入
|   4--指定位置插入
|   5--删除第一个结点
|   6--指定位置删除
|   7--查找
|   8--显示
|   0--返回
==================================
请输入菜单号(0~8):8

链表序列:
HEAD:700
TAIL:600
700     100     300     600
          单链表的操作
==================================
|   1--第一个结点之前插入
|   2--第一个结点之后插入
|   3--最后一个结点之后插入
|   4--指定位置插入
|   5--删除第一个结点
|   6--指定位置删除
|   7--查找
|   8--显示
|   0--返回
==================================
请输入菜单号(0~8):7

请输入要查找的元素值:34

查找失败
          单链表的操作
==================================
|   1--第一个结点之前插入
|   2--第一个结点之后插入
|   3--最后一个结点之后插入
|   4--指定位置插入
|   5--删除第一个结点
|   6--指定位置删除
|   7--查找
|   8--显示
|   0--返回
==================================
请输入菜单号(0~8):7

请输入要查找的元素值:700

查找成功!
          单链表的操作
==================================
|   1--第一个结点之前插入
|   2--第一个结点之后插入
|   3--最后一个结点之后插入
|   4--指定位置插入
|   5--删除第一个结点
|   6--指定位置删除
|   7--查找
|   8--显示
|   0--返回
==================================
请输入菜单号(0~8):8

链表序列:
HEAD:700
TAIL:600
700     100     300     600
          单链表的操作
==================================
|   1--第一个结点之前插入
|   2--第一个结点之后插入
|   3--最后一个结点之后插入
|   4--指定位置插入
|   5--删除第一个结点
|   6--指定位置删除
|   7--查找
|   8--显示
|   0--返回
==================================
请输入菜单号(0~8):
 

 

__Pluto
关注
专栏目录
数据结构：不带头结点单链表的实现及其一些基本操作.cpp
08-03
实现单链表及其一些基本操作函数（不带头结点） 1.头文件包含 2.宏定义及节点类型描述 3.初始化、判断是否为空 4.指定位置插入操作 5.在p节点后插入元素e 6.在p节点前插入元素e 7.删除操作：删除第i个节点，...
#数据结构：编写不带头结点单链表的建立、插入和删除算法
weixin_56561876的博客
05-16 6755
编写不带头结点单链表的建立、插入和删除操作算法。 一、问题描述 编写一个不带头节点的单链表 二、基本要求 1) 建立 2) 插入 3) 删除 三、算法思想 选用不带头结点的单链表，在第一个元素节点前插入节点时头指针的值将改变为指针s的值，在非第一个元素结点的其他结点前插入结点时，改变的是指针->next的值。 删除不带头结点的单链表的第一个元素结点时头指针的值将改变为头指针->next；删除其他节点是，头指针的值不会改变，改变的是指针->next的值。 四、数据结构
数据结构2--不带头结点的单链表
weixin_43807876的博客
03-26 1141
不带头结点的单链表 按值删除注意考虑第一个节点，按值插入注意考虑没有元素时 排序时用四个指针： tmp是在排序好的列表里寻找要插入的位置、prev标记tmp的前一个节点、p标记要插入的节点、q标记要插入的节点的下一个节点，每次插入完成之后，都需要将tmp置到第一个结点的位置，prev置空 //Common.h #ifndef _COMMON_H_ #define _COMMON_H_ #include <stdio.h> #include <stdlib.h> #in.
不带头结点的单链表删除任意一个节点
yp18792574062的博客
07-22 8836
#include #include //删除单链表中的任意一个节点，可能是传节点删除，也可能是传节点的值删除 typedef struct _Node { int val; struct _Node* next; }Node,*LinkList; //不带头结点的单链表 void Init(LinkList* list) { (*list) = NULL; } void Creat(Link
不带头节点的单链表操作 增删改查
weixin_45951224的博客
02-23 1355
单链表增删改查
没有头结点的单链表如何删除结点
Bruce Lee的专栏
09-09 4485
题目：假设有一个没有头结点的单链表。一个指针指向此单链表中间的一个节点（非第一个节点， 也非最后一个节点）。请将该节点从单链表中删除。 典型的“狸猫换太子”， 若要删除该节点，正常情况下，应该要知道该节点的前面节点的指针，但是由于单链表中没有头结点，所以无法追溯到该节点前面的那个节点，因此，这里采用了“移花接木”的方法。设该节点为B，下一个节点为C。那么，首先将B节点的内容替换为C节点的内容，然
数据结构 不带头结点的单链表代码
12-16
总之，不带头结点的单链表是一种简洁的数据结构实现，尽管在某些操作上可能不如带头结点的链表方便，但在特定情况下，它可以提供有效的解决方案。理解其工作原理和如何用C++进行操作对于提升编程技能和优化算法性能...
链表-使用C语言实现带头结点的单链表.zip
最新发布
03-13
带头结点的链表会在链表的开头添加一个特殊的节点，它的数据部分通常不存储实际数据，但用于方便链表操作，如初始化和遍历。 接下来，我们将探讨如何在C语言中定义链表节点。我们可以定义一个结构体类型来表示链表...
数据结构作业带或不带头结点链表
06-24
2. **不带头结点的链表**：相比之下，不带头结点的链表没有单独的头结点，第一个节点就是链表的起始。这种实现方式节省了内存，但操作起来稍显复杂。比如，如果链表为空，需要特别处理，因为没有明显的空链表标识。...
c++实现 不带头结点单链表基本操作
11-24
下面将详细解释如何用C++实现不带头结点单链表的基本操作，包括逆序建立链表、插入元素以及删除元素。 首先，我们需要定义链表节点的结构体，如下： ```cpp struct ListNode { int data; ListNode* next; }; ```...
[考研数据结构]第2章之单链表的基本知识与操作
人生处处是围城，一切都是最好的安排！
03-19 2242
线性表之单链表的基础知识与基本操作，头插法与尾插法建表的比较，带头结点与不带结点的比较，头指针与头结点的区别，插入元素、删除元素、查找元素
C语言实现单链表（不带头节点）的删除插入完整代码
qq_54628272的博客
02-10 3079
注意：不带头节点的单链表删除插入操作第一个节点的时候都要特殊讨论 以下代码是用C语言实现的完整代码可上机运行 #include<stdio.h> #include<malloc.h> struct linknode { int data; struct linknode* next; }; void init(struct linknode** L) { (*L) = NULL; } void insect(struct linknode** L, int i, ..
【数据结构】单链表按位序删除结点（带头结点的和不带头结点的）和指定结点的删除
bbt953的博客
10-12 1565
单链表按位序删除结点（带头结点的和不带头结点的）和指定结点的删除
数据结构实验6无头节点删除第一个数x
linjiajun12123的博客
10-21 1750
编写函数slnklist delx(linklist head, datatype x)，删除不带头结点单链表head中第一个值为x 的结点。 并构造测试用例进行测试。 linklist delx(linklist head,datatype x) {     linklist p=head,q=NULL;     while(head!=NULL&&p->info!=x){q=p;p=
从无头单链表中删除节点
Zidane_2014的专栏
05-11 832
本题来自《编程之美》。 假设有一个没有头指针的单链表。 一个指针指向此单链表中间的一个节点（不是第一个，也不是最后一个），请将该节点从单链表中删除。 假设给定的指针为pCurrent,    Node* pNext = pCurrent->Next(pNext指向pCurrent所指节点的下一个)。 A ----> B ----> C ---->D 若此时，pCu
数据结构笔记 五：单链表
OnlyLove_的博客
10-13 591
说明：本笔记依照《王道论坛-数据结构》视频内容整理。 一、定义 顺序表特点： 优点：可随机存储，存储密度高。 缺点：要求大片连续空间，改变容量不方便。 单链表特点： 优点：不要求大片连续空间，改变容量方便。 缺点：不可随机存取，要耗费一定空间存放指针。 二、单链表节点 typedef int ElemType; // 根据实际情况定义 typedef struct lNode{ // 定义单列表结点类型 ElemType data;
数据结构：不带头结点的单链表
qq_40657299的博客
11-04 7583
不带头结点的单链表： 1.不带头结点的单链表操作中，除了初始化，头插，尾插，删除，操作与带头结点的单链表有差别外，其它的操作基本上一样。 2.链表指针直接指向了首元节点，因此在首元节点前插入数据元素或者删除首元节点元素都会改变头指针的值。所以这里要引入二级指针。 typedef struct NNode {  int data;  struct NNode *next; }N
(转)问题：假设一个没有头指针的单链表。一个指针指向此单链表中间的一个节点（既不是第一个，也不是最后一个节点），请将该节点从单链表中删除。
zhaozhanyong的专栏
02-14 6503
问题：假设一个没有头指针的单链表。一个指针指向此单链表中间的一个节点（既不是第一个，也不是最后一个节点），请将该节点从单链表中删除。链表结点定义如下： struct ListNode {          int       m_nKey;          ListNode* m_pNext; }; 解答：假设给定的指针为pCurrent，ListNode* pNext = pCurrent->m_pNext； 由题意知，pCurrent指向链表的某一个中间节点，因此pCurr
2.6-15对于不带头结点的单链表 L，设计一个递归算法删除第一个值为 x 的结点
qq_43192537的博客
10-10 7196
对于不带头结点的单链表 L，设计一个递归算法删除第一个值为 x 的结点 #include "LinkList.cpp" #include <bits/stdc++.h> void Delfirstx(LinkNode *&L,int x) { // 删除第一个值为 x 的结点 if (L==NULL) return; if (L->data==x) { Li...
带头结点的单链表和不带头结点的单链表
10-20
带头结点的单链表和不带头结点的单链表的区别在于是否在链表的开头设置一个头结点。 带头结点的单链表在链表的开头设置一个头结点，头结点的数据域可以为空，头结点的指针域指向链表的第一个节点，这样可以使得所有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值