实现线性表中的单链表，有无头结点情况

已于 2023-07-03 15:48:16 修改
阅读量107 收藏
点赞数 1
分类专栏： C语言 文章标签： 算法 图论
于 2023-06-29 08:16:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62740668/article/details/131448677
版权

C语言分头结点和没有头结点实现单链表的基本操作，包括初始化 （虽然没用上），头插法建立单链表，尾插法建立单链表，按值查询，按位置查询，按值前插，按位前插，按值后插，按位后插，删除某特定值，删除某位置上的值

有头结点

#include <stdio.h>
#include <malloc.h>

//定义单链表
typedef struct LNode
{
    int data;//存储数据
    struct LNode* next;//指向下一个节点的指针
}Node,*ChainList;
//头插法建立单链表
ChainList HeadInsert ()
{
    ChainList s;//存储读入数据后创建的节点的位置
    int x = 0;
    //创建头指针
    ChainList head = (Node*)malloc(sizeof(struct LNode));
    int length = 0;
    printf("请输入想创建的链表长度\n");
    scanf("%d",&length);
    head->data = length;
    for(int i = 0;i < length;i++)
    {
        printf("请输入第%d个位置的值\n",length-i);
        scanf("%d",&x);
        s = (Node*)malloc(sizeof(struct LNode));
        s->data = x;
        s->next = head;
        head = s;
    }
    return head;
}
//尾插法创建单链表
ChainList TailCreate()
{
    ChainList s;
    int x = 0;
    ChainList head = (Node*)malloc(sizeof(struct LNode));
    int length;
    ChainList tail = NULL;
    printf("请输入想创建的链表长度\n");
    scanf("%d",&length);
    if(length < 1)
    {
        head = NULL;
    } else{
    head->data = length;
    head->next = NULL;
    tail = head;
    for(int i = 0;i < length;i++)
    {
        printf("请输入第%d个位置上的值\n",i+1);
        scanf("%d",&x);
        s = (Node*)malloc(sizeof(struct LNode));
        s->data = x;
        tail->next = s;
        s->next = NULL;
        tail = s;
    }
    }
    return head;
}
//打印单链表
void Printf(ChainList p)
{
    Node* q = p->next;//不打印头结点，因为头结点中存储了链表长度
    if(q == NULL)
        printf("这是空的单链表\n");
    else{
        int i = 0;
        while(q != NULL)
        {
            i++;
            printf("链表第%d个位置上的值为%d\n",i,q->data);
            q = q->next;
        }
    }
}

//按位置查找元素
void LocatSearch(ChainList s)
{
    Node *q = s->next;
    int loc = 0;
    printf("请输入想查询的位置\n");
    scanf("%d",&loc);
    if(loc < 1)
    {
        printf("输入错误\n");
    }else if(loc <= s->data){
        Node* p = q;
        int i = 1;
        while(p != NULL)
        {
            if(i < loc)
            {
                p = p->next;
                i++;
            }if(i == loc)
            {
                printf("找到了，第%d个位置上的值为%d\n",i,p->data);
                break;
            }
        }
    } else if (loc > s->data){
        printf("位置输入过大\n");
    }
}

//按值查找元素
void ValueSearch(ChainList s)
{
    Node *q = s->next;
    int x = 0;
    printf("请输入想查找的元素值\n");
    scanf("%d",&x);
    Node* p = q;
    int loc = 1;
    while(p != NULL)
    {
        if(p->data == x)
        {
            printf("找到了，元素值%d在第%d个位置\n",x,loc);
            break;
        }else
        {
            p = p->next;
            loc++;
        }
    }
    if (p == NULL)
        printf("这个值不在链表中\n");
}
//按指定位置前插入
ChainList HeadLocate(ChainList s)
{
    Node *q = s->next;
    int loc = 0;
    printf("请输入想插在哪个位置之前\n");
    scanf("%d",&loc);
    int length = s->data;
    if(loc < 1 || loc > length + 1)
    {
        printf("输入错误\n");
        return NULL;
    }
    else {
        if (loc == length + 1) {
            Node *tail = (Node *) malloc(sizeof(struct LNode));
            int t = 0;
            printf("请输入想插入的值\n");
            scanf("%d", &t);
            while (q) {
                if (q->next == NULL) {
                    q->next = tail;
                    tail->next = NULL;
                    tail->data = t;
                    break;
                }
                q = q->next;
            }
            return s;
        } else {
            Node *p = (Node *) malloc(sizeof(struct LNode));
            int v = 0;
            printf("请输入想插入的值\n");
            scanf("%d", &v);
            int i = 1;
            while (q) {
                if (i < loc) {
                    q = q->next;
                    i++;
                } else if (i == loc) {
                    p->next = q->next;
                    p->data = q->data;
                    q->data = v;
                    q->next = p;
                    break;
                }
            }
            return s;
        }
    }
    }
//按指定位置后插入
ChainList TailLocate(ChainList s)
{
    Node *q = s->next;
    int loc = 0;
    printf("请输入想插在哪个位置之后\n");
    scanf("%d",&loc);
    int length = s->data;
    if(loc < 1 || loc > length)
    {
        printf("输入错误\n");
        return NULL;
    }
    else{
            Node* p = (Node*)malloc(sizeof(struct LNode));
            int v = 0;
            printf("请输入想插入的值\n");
            scanf("%d",&v);
            int i = 1;
            while(q)
            {
                if(i < loc)
                {
                    q = q->next;
                    i++;
                }else if (i == loc)
                {
                    p->next = q->next;
                    p->data = v;
                    q->next = p;
                    break;
                }
            }
            return s;
        }
    }

//在指定的值前插入
ChainList HeadValue(ChainList s)
{
    Node *q = s->next;
    int x = 0;
    printf("请输入想插在哪个值之前\n");
    scanf("%d",&x);
    int length = s->data;
    int loc = 1;
    Node* a = q;
    while(a)
    {
        if(a->data == x)
        {
            break;
        }else{
            a = a->next;
            loc++;
        }
    }
    if(a == NULL)
    {
        printf("该值不在链表中\n");
        return NULL;
    }else{
        if (loc == length + 1) {
            Node *tail = (Node *) malloc(sizeof(struct LNode));
            int t = 0;
            printf("请输入想插入的值\n");
            scanf("%d", &t);
            while (q) {
                if (q->next == NULL) {
                    q->next = tail;
                    tail->next = NULL;
                    tail->data = t;
                    break;
                }
                q = q->next;
            }
            return s;
        } else {
            Node *p = (Node *) malloc(sizeof(struct LNode));
            int v = 0;
            printf("请输入想插入的值\n");
            scanf("%d", &v);
            int i = 1;
            while (q) {
                if (i < loc) {
                    q = q->next;
                    i++;

                } else if (i == loc) {
                    p->next = q->next;
                    p->data = q->data;
                    q->data = v;
                    q->next = p;
                    break;
                }
            }
            return s;
        }
        }
    }

//在指定的值后插入
ChainList TailValue(ChainList s)
{
    Node *q = s->next;
    int x = 0;
    printf("请输入想插在哪个值之后\n");
    scanf("%d",&x);
    int length = s->data;
    int loc = 1;
    Node* a = q;
    while(a)
    {
        if(a->data == x)
        {
            break;
        }else{
            a = a->next;
            loc++;
        }
    }
    if(a == NULL)
    {
        printf("该值不在链表中\n");
        return NULL;
    }
    else{
            Node* p = (Node*)malloc(sizeof(struct LNode));
            int v = 0;
            printf("请输入想插入的值\n");
            scanf("%d",&v);
            int i = 1;
            while(q)
            {
                if(i < loc)
                {
                    q = q->next;
                    i++;
                }else if (i == loc)
                {
                    p->next = q->next;
                    p->data = v;
                    q->next = p;
                    break;
                }
            }
            return s;
        }
    }

//删除指定位置的值．
ChainList LocateDelete(ChainList q)
{
    int loce = 0;
    printf("请输入想删除的位置\n");
    scanf("%d",&loce);
    int length = q->data;
    Node* d = q;
    if(loce < 1 || loce > length)
    {
        printf("输入有误\n");
        return NULL;
    }
    else{
        int i = 0;
        int loc = loce + 1;
        for(i = 1; i < loc - 1;i++)
        {
            q = q->next;
        }
        Node* g = q->next;
        q->next = g->next;
        return d;
    }
}


//删除指定值
ChainList ValueDelete(ChainList q)
{
    int x = 0;
    printf("请输入想删除的值\n");
    scanf("%d",&x);
    int loc = 1;
    Node* w = q;
        while(q != NULL)
        {
            Node* e = q->next;
            if(e->data == x)
            {
                q->next = e->next;
                break;
            }
            else{
                q = q->next;
                loc++;
            }
        }
        if(q == NULL)
        {
            printf("单链表中不存在这个值\n");
            return NULL;
        }else{
            return w;
    }
}
int main() {
    ChainList head = TailCreate();
    Printf(head);
    //LocatSearch(head);
    //ValueSearch(head);
    //ChainList  a = HeadLocate(head);
    //Printf(a);
    //ChainList  b = TailLocate(head);
    //Printf(b);
    //ChainList  c = HeadValue(head);
    //Printf(c);
    //ChainList  d = TailValue(head);
    //Printf(d);
    //ChainList e = LocateDelete(head);
    //Printf(e);
    ChainList f = ValueDelete(head);
    Printf(f);
    return 0;
}

无头结点

#include <stdio.h>
#include <stdlib.h>
//定义链表结构体
typedef struct LNode
{
        int data;//定义链表中存储数据的地方
        struct LNode* next;      //定义存储下一个节点位置的地方
}Node,*ChainList;


//初始化（若存在头节点则可在这个地方创建头节点）
void InitialNode(ChainList q)
{
        q = NULL;
        printf("初始化成功\n");
}
//头插法建立单链表
ChainList HeadInsert ()
{
        ChainList s;//存储读入数据后创建的节点的位置
        int x = 0;
        //创建头指针
        ChainList head = NULL;
        int length = 0;
        printf("请输入想创建的链表长度\n");
        scanf("%d",&length);
        for(int i = 0;i < length;i++)
        {
                printf("请输入第%d个位置的值\n",length-i);
                scanf("%d",&x);
                s = (Node*)malloc(sizeof(struct LNode));
                s->data = x;
                s->next = head;
                head = s;
        }
        return head;
}


//打印单链表
void Printf(Node* q)
{
        if(q == NULL)
                printf("这是空的单链表\n");
        else{
        int i = 0;
        while(q != NULL)
        {
                i++;
                printf("链表第%d个位置上的值为%d\n",i,q->data);
                q = q->next;
        }
        }
}
//尾插法建立单链表
ChainList ListInsert()
{
        ChainList s;
        int x = 0;
        ChainList head = (Node*)malloc(sizeof(struct LNode));
        int length;
        ChainList tail = NULL;
        printf("请输入想创建的链表长度\n");
        scanf("%d",&length);
        if(length < 1)
                head = NULL;
        for(int i = 0;i < length;)
        {
                printf("请输入第%d个位置上的值\n",i+1);
                scanf("%d",&x);
                if(i == 0)
                {
                        head->data = x;
                        head->next = NULL;
                        tail = head;
                        i++;
                }else{
                        s = (Node*)malloc(sizeof(struct LNode));
                        s->data = x;
                        tail->next = s;
                        s->next = NULL;
                        tail = s;
                        i++;
                }
        }
        return head;
}

//按位置查找元素
void LocatSearch(ChainList q)
{
        int loc = 0;
        printf("请输入想查询的位置\n");
        scanf("%d",&loc);
        if(loc < 1)
        {
                printf("输入错误\n");


        }
        else{
        Node* p = q;
        int i = 1;
        while(p != NULL)
        {
                if(i < loc)
                {
                        p = p->next;
                        i++;
                }if(i == loc)
                {
                        printf("找到了，第%d个位置上的值为%d\n",i,p->data);
                        break;
                }
        }
        if(p == NULL )
                printf("位置输入过大\n");


        }
}
//按值查找元素
void ValueSearch(ChainList q)
{
        int x = 0;
        printf("请输入想查找的元素值\n");
        scanf("%d",&x);
        Node* p = q;
        int loc = 1;
        while(p != NULL)
        {
                if(p->data == x)
                {
                        printf("找到了，元素值%d在第%d个位置\n",x,loc);
                        break;
                }else
                {
                        p = p->next;
                        loc++;
                }
        }
        if (p == NULL)
                printf("这个值不在链表中\n");


}
//求链表长度
int Length(ChainList q)
{
        int length = 0;
        Node* head = q;
        if(head->next == NULL)
       {
           return 1;
       }else{
               while(head)
               {
                       head = head->next;
                        length++;                                                                                                                       }
               return length;                                                                                                                                                                                                                  }
}

//按指定位置前插入
ChainList HeadLocate(ChainList q)
{
        int loc = 0;
        printf("请输入想插在哪个位置之前\n");
        scanf("%d",&loc);
        int length = Length(q);
        if(loc < 1 || loc > length + 1)
        {
                printf("输入错误\n");
                return NULL;
        }
        else{
                if (loc == 1){
                Node* head = (Node*)malloc(sizeof(struct LNode));
                int x = 0;
                printf("请输入想插入的值\n");
                scanf("%d",&x);
                head-> data = x;
               head-> next = q;
                return head;
        }else if(loc == length + 1)
        {
                Node* tail = (Node*)malloc(sizeof(struct LNode));
                int t = 0;
                printf("请输入想插入的值\n");
                scanf("%d",&t);
                Node* n = q;
                while(q)
                {
                if(q->next == NULL)
                {
                q->next = tail;
                tail->next = NULL;
                tail->data = t;
                break;
                }
                q = q->next;
                }
                return n;
        }
        else{
                Node* p = (Node*)malloc(sizeof(struct LNode));
                int v = 0;
                printf("请输入想插入的值\n");
                scanf("%d",&v);
                int i = 1;
                Node* h = q;
                while(q)
                {
                        if(i < loc)
                        {
                                q = q->next;
                                i++;
                        }else if (i == loc)
                        {
                                p->next = q->next;
                                p->data = q->data;
                                q->data = v;
                                q->next = p;
                                break;
                        }
                }
                return h;
        }
}
}
/按指定位置后插入
ChainList TailLocate(ChainList q)
{
        int loc = 0;
        printf("请输入想插在哪个位置之后\n");
        scanf("%d",&loc);
        int length = Length(q);
        if(loc < 1 || loc > length)
        {
                printf("输入错误\n");
                return NULL;
        }
        else{
                if (loc == 1){
                        Node* p = (Node*)malloc(sizeof(struct LNode));
                        int x = 0;
                        printf("请输入想插入的值\n");
                        scanf("%d",&x);
                        p-> data = x;
                        p-> next = q->next;
                        q-> next = p;
                        return q;
                }else if(loc == length)
                {
                        Node* tail = (Node*)malloc(sizeof(struct LNode));
                        int t = 0;
                        printf("请输入想插入的值\n");
                        scanf("%d",&t);
                        Node* n = q;
                        while(q)
                        {
                                if(q->next == NULL)
                                {
                                        q->next = tail;
                                        tail->next = NULL;
                                        tail->data = t;
                                        break;
                                }
                                q = q->next;
                        }
                        return n;
                }
                        else{
                                Node* p = (Node*)malloc(sizeof(struct LNode));
                                int v = 0;
                                printf("请输入想插入的值\n");
                                scanf("%d",&v);
                                int i = 1;
                                Node* h = q;
                                while(q)
                                {
                                        if(i < loc)
                                        {
                                                q = q->next;
                                                i++;
                                        }else if (i == loc)
                                        {
                                               p->next = q->next;
                                                p->data = v;
                                                q->next = p;
                                                break;
                                        }
                                }
                                return h;
                        }
        }
}
//在指定的值前插入


ChainList HeadValue(ChainList q)
{
        int x = 0;
        printf("请输入想插在哪个值之前\n");
        scanf("%d",&x);
        int length = Length(q);
        int loc = 1;
        Node* a = q;
        while(a)
        {
                if(a->data == x)
                {
                        break;
                }else{
                        a = a->next;
                        loc++;
                }
        }
        if(a == NULL)
        {
                printf("该值不在链表中\n");
                return NULL;
        }else{
                if (loc == 1){
                        Node* head = (Node*)malloc(sizeof(struct LNode));
                        int d = 0;
                        printf("请输入想插入的值\n");
                        scanf("%d",&d);
                        head-> data = d;
                        head-> next = q;
                        return head;
                }else if(loc == length + 1)
                {
                        Node* tail = (Node*)malloc(sizeof(struct LNode));
                        Node* n = q;
                        int f = 0;
                        printf("请输入想插入的值\n");
                        scanf("%d",&f);
                        while(q)
                        {
                                if(q->next == NULL)
                                {
                                        q->next = tail;
                                        tail->next = NULL;
                                        tail->data = f;
                                        break;
                                }
                                q = q->next;
                        }
                        return n;
                }
                else{
                        Node *p = (Node*)malloc(sizeof(struct LNode));
                        int i = 1;
                        int j = 0;
                        printf("请输入想插入的值\n");
                        scanf("%d",&j);
                        Node* h = q;
                        while(q)
                        {
                                if(i < loc)
                                {
                                        q = q->next;
                                        i++;
                                }else if (i == loc)
                                {
                                        p->next = q->next;
                                        p->data = q->data;
                                        q->data = j;
                                        q->next = p;
                                        break;
                                }
                        }
                        return h;
                }
        }
}

//在指定的值后插入
ChainList TailValue(ChainList q)
{
        int x = 0;
        printf("请输入想插在哪个值之后\n");
        scanf("%d",&x);
        int length = Length(q);
        int loc = 1;
        Node* a = q;
        while(a)
        {
                if(a->data == x)
                {
                        break;
                }else{
                        a = a->next;
                        loc++;
                }
        }
        if(a == NULL)
        {
                printf("该值不在链表中\n");
                return NULL;
        }
        else{
                if (loc == 1){
                        Node* p = (Node*)malloc(sizeof(struct LNode));
                        int x = 0;
                        printf("请输入想插入的值\n");
                        scanf("%d",&x);
                        p-> data = x;
                        p-> next = q->next;
                        q-> next = p;
                        return q;
                }else if(loc == length)
                {
                        Node* tail = (Node*)malloc(sizeof(struct LNode));
                        int t = 0;
                        printf("请输入想插入的值\n");
                        scanf("%d",&t);
                        Node* n = q;
                        while(q)
                        {
                                if(q->next == NULL)
                                {
                                        q->next = tail;
                                        tail->next = NULL;
                                        tail->data = t;
                                       break;
                                }
                                q = q->next;
                        }
                        return n;
                }
                else{
                        Node* p = (Node*)malloc(sizeof(struct LNode));
                        int v = 0;
                        printf("请输入想插入的值\n");
                        scanf("%d",&v);
                        int i = 1;
                        Node* h = q;
                        while(q)
                        {
                                if(i < loc)
                                {
                                        q = q->next;
                                        i++;
                                }else if (i == loc)
                                {
                                        p->next = q->next;
                                        p->data = v;
                                        q->next = p;
                                        break;
                                }
                        }
                        return h;
                }
        }
}

/删除指定位置的值．
ChainList LocateDelete(ChainList q)
{
        int loc = 0;
        printf("请输入想删除的位置\n");
        scanf("%d",&loc);
        int length = Length(q);
        Node* d = q;
        if(loc < 1 || loc > length)
        {
                printf("输入有误\n");
                return NULL;
        }else if(loc == 1)
        {
                Node* h = q->next;
                return h;
        }
        else{
                int i = 0;
                for(i = 1; i < loc - 1;i++)
                {
                        q = q->next;
                }
                Node* s = q->next;
                q->next = s->next;
                return d;
        }
}


//删除指定值
ChainList ValueDelete(ChainList q)
{
        int x = 0;
        printf("请输入想删除的值\n");
        scanf("%d",&x);
        int loc = 1;
        Node* w = q;
        if(q->data == x)
        {
                Node* o = q->next;
                return o;
        }
        else{
        while(q != NULL)
        {
                Node* e = q->next;
                if(e->data == x)
                {
                        q->next = e->next;
                        break;
                        }
                else{
                        q = q->next;
                        loc++;
                }
        }
        if(q == NULL)
        {
                printf("单链表中不存在这个值\n");
                return NULL;
        }else{
                return w;
        }
}
}




int main()
{
        //ChainList q = HeadInsert();
        ChainList q = ListInsert();
        Printf(q);
        LocatSearch(q);
        ValueSearch(q);
        int length = Length(q);
        printf("链表长度为%d\n",length);
        ChainList p = HeadLocate(q);
        Printf(p);
        ChainList t = TailLocate(q);
        Printf(t);
        ChainList v = HeadValue(q);
        Printf(v);
        ChainList a = TailValue(q);
        Printf(a);
        ChainList b = LocateDelete(q);
        Printf(b);
        ChainList c = ValueDelete(q);
        Printf(c);
        return 0;
}

摩尔曼斯克的海
关注
专栏目录
单链表实现（C语言版，无头结点）
05-02 6462
前言：单链表：它是一种链式储存的线性表，用一组地址任意的储存单元存放线性表的数据元素；称储存单元为一个结点；结点：值域+指针域 链表：二、代码实现（1）结点定义：typedef int DataType; typedef struct ListNode { struct ListNode* next; DataType data; }Node,*PNode;typedef stru
无头结点单链表的逆置_无头结点的单链表（C语言）
weixin_33281940的博客
02-12 932
1.单链表：在顺序表中，用一组地址连续的存储单元来一次存放线性表的结点，因此结点的逻辑顺序与物理顺序是一致的。但链表却不同，链表是用一组任意的存储单元来存放 线性表的结点，这组存储单元可以是连续的，也可以是非连续的，甚至是零散分布在内存的任何位置上。因此，链表中结点的逻辑顺序与物理顺序不一定相同。为了正确表示节点间的逻辑关系，必须在存储线性表的每个数据元素的同时，存储指示其后继结点的地址信息，这两...
有头结点和无头结点创建单链表
m0_75220252的博客
03-28 841
有无头结点创建单链表，包括创建链表，查找结点，删除结点，插入结点，还有插入和删除的拓展，改变时间复杂度了，计算链表的长度
链表基础1——无头结点单向非循环链表的基本操作（c语言实现）
2301_80224556的博客
04-14 1080
二，尾部插入一个元素。
无头节点单链表和有头节点单链表
CrazyQiQi的博客
09-15 2408
无头结点和有头节点 无头结点：第一个节点既有数据域又有指针域。 但是通过一个 pHead 指针指向和标记第一个节点 有头节点：在第一个节点之前加入一个头节点，头节点的 data 域可以设置表长等相关信息，但也可以不设置。头节点的指针域指向第一个节点。 引入头节点的优势 对第一个位置元素的操作（添加、删除）更加方便 若使用头结点，则第1个位置的插入和删除都是对p—>next进行操作，...
【2 线性表】循环单链表，无头结点，p指向中间位置结点，删除前驱结点。
irel1a_3的博客
12-05 829
删除前驱
[C语言、C++]数据结构作业：线性表-单链表(无头节点)的基本操作
Yhisken的博客
09-30 695
[C语言、C++]数据结构作业：线性表-单链表(无头节点)的基本操作
【数据结构】【王道】【线性表】无头结点单链表的实现及基本操作（可直接运行）
treesorshining的博客
07-11 3030
1.2 初始化 1.3 判空 1.4 按位序插入 1.5 指定结点后插操作 1.6 指定结点前插操作_1 1.7 指定结点前插操作_2 1.8 按位序删除 1.9 按位查找 1.10 按值查找 1.11 表的长度 1.12 单链表建立（尾插法） 1.13 单链表建立（头插法） 1.14 输出所有链表元素 2.完整代码 3.运行截图.........
数据结构三：线性表之单链表(带头结点单链表设计)的设计
weixin_47040031的博客
01-23 1453
线性表的链式存储结构正是所谓的单链表，何谓单链表？通过地址将每一个数据元素串起来，进行使用，这可以弥补顺序表在进行任意位置的插入和删除需要进行大量的数据元素移动的缺点，只需要修改指针的指向即可；单链表的种类又可划分为很多种，本篇博客详细介绍带头结点单链表的设计与实现，掌握单链表的关键是要进行画图分析；单链表同时也是笔试和面试的必考点，因此，掌握好该章节非常重要！
在无头结点的动态单链表上实现线性表操作 INSERT(L, i, B)，并和在带头结点的动态单链表上实现相同操作的算法进行比较。
qq_41109668的博客
02-28 2884
题目： 在无头结点的动态单链表上实现线性表操作 INSERT(L, i, B)，并和在带头结点的动态单链表上实现相同操作的算法进行比较。 分析： 首先我们要先初始化一个单链表，接下来要给这个单链表中添加数据元素，最后再在某一位置前插入某一数据元素 代码： 链表初始化： #include<stdio.h> #include<stdlib.h> #define ...
在无头结点的动态单链表上实现线性表操作Insert(L,i,b)
积极奋斗的蜗牛
04-09 9009
在无头结点的动态单链表上实现线性表操作Insert(L,i,b) 单链表类型定义如下：
在无头结点的动态单链表上实现线性表操作DELETE(L, i)，并和在带头结点的动态单链表上实现相同操作的算法进行比较
qq_41109668的博客
02-28 950
题目： 在无头结点的动态单链表上实现线性表操作DELETE(L, i)，并和在带头结点的动态单链表上实现相同操作的算法进行比较 分析： 删除节点的操作一般步骤为：找到该节点的直接前驱，然后使其直接前驱的 next 指向该节点的直接后继 代码： 初始化： #include<stdio.h> #include<stdlib.h> #define OK 1 ty...
数据结构（C语言版）-线性表（单链表）
czh2637750821的博客
01-08 949
学习视频链接 单链表一、单链表1、单链表的定义2、单链表的类型定义3、单链表的基本操作实现二、配套实验 一、单链表 1、单链表的定义 线性表的链式存储结构是指用一组任意的存储单元存储线性表中的数据元素。为了反映数据元素之间的逻辑关系，对于每个数据元素不仅要表示它的具体内容，还要附加一个表示它的直接后继元素存储位置的信息这样构成的链表为单链表。其结点分为数据域与指针域 ，单链表分为带头结点和不带头结点两种类型。 数据域 指针域 data next 结点：数据元素的存储映像 链表：n个结
在无头结点的动态单链表上实现线性表操作Delete(L,i)
积极奋斗的蜗牛
04-09 3994
在无头结点的动态单链表上实现线性表操作DELETE(L,i)
二叉树系列 10/11
2301_78191305的博客
10-11 422
在这些路径中，只有红色和绿色的路径是伪回文路径，因为红色路径 [2,3,3] 存在回文排列 [3,2,3] ，绿色路径 [2,1,1] 存在回文排列 [1,2,1]。总共有 3 条从根到叶子的路径：红色路径 [2,3,3] ，绿色路径 [2,1,1] 和路径 [2,3,1]。（如果 A 的任何子节点之一为 B，或者 A 的任何子节点是 B 的祖先，那么我们认为 A 是 B 的祖先）（一个节点的祖父节点是指该节点的父节点的父节点。」的，当它满足：路径经过的所有节点值的排列中，存在一个回文序列。
在顺序结构和链式结构的线性表上实现顺序检索算法
m0_56332819的博客
10-13 239
在顺序结构和链式结构的线性表上实现顺序检索算法，C语言
【从零开始的LeetCode-算法】3099. 哈沙德数
最新发布
qq_40878316的博客
10-15 189
如果一个整数能够被其各个数位上的数字之和整除，则称之为。各个数位上的数字之和，否则，返回。各个数位上的数字之和为。各个数位上的数字之和为。不是哈沙德数，答案是。
力扣10.13
qq_40052678的博客
10-13 375
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
c语言练习题2(字符串和函数的使用)
m0_74859128的博客
10-10 367
回文函数用于判断一个给定的字符串是否为回文。输入是一个字符数组（字符串），输出是一个布尔值，表示该字符串是否为回文。编写一个 C 语言程序，计算两个整数在二进制表示中有多少位不同。2. 比较这两个整数在二进制表示中的每一位（共32位）是否不同。1. 提示用户输入两个整数。3. 统计不同的位的数量。4. 输出不同的位数。
试写一算法，在无头结点的动态单链表上实现线性表操作INSERT(L,i, b)，并和在带头结点的动态单链表上实现相同操作的算法进行比较
09-22
在无头结点的动态单链表上实现 INSERT(L, i, b) 这个操作，我们需要找到第 `i` 个元素的位置，然后将新节点 `b` 插入到该位置。以下是步骤： 1. 遍历链表，从第一个节点开始计数，直到找到第 `i-1` 个节点，或者...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

摩尔曼斯克的海

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

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

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

打赏作者

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

抵扣说明：

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

余额充值