707设计链表

最新推荐文章于 2026-01-27 10:17:12 发布
原创 最新推荐文章于 2026-01-27 10:17:12 发布 · 249 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#leetcode #数据结构

设计链表

题目描述：设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。
在链表类中实现这些功能：
  • get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
  • addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
  • addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
  • addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节- 点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
  • deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。
题解思路：链表的基础操作，熟悉指针即可，手动模拟各种操作，然后再写代码。
注意点：malloc函数的写法:(structure_name*)malloc(sizeof(structure_name));
typedef struct node{
    int val;
    struct node* next;
} MyLinkedList;

/** Initialize your data structure here. */

MyLinkedList* myLinkedListCreate() {
    MyLinkedList* H;
    H=(MyLinkedList*)malloc(sizeof(MyLinkedList));
    H->next=NULL;
    return H;
}

/** Get the value of the index-th node in the linked list. If the index is invalid, return -1. */
int myLinkedListGet(MyLinkedList* obj, int index) {
    int flag,count,res;
    flag=count=0;
    MyLinkedList* p=obj;
    while(p->next!=NULL){
        p=p->next;
        if(count==index){
            res=p->val;
            flag=1;
        }
        count++;
    }
    if(!flag){
        res=-1;
    }
    return res;
}

/** Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list. */
void myLinkedListAddAtHead(MyLinkedList* obj, int val) {
    MyLinkedList* p;
    p=(MyLinkedList*)malloc(sizeof(MyLinkedList));
    p->val=val;
    p->next=obj->next;
    obj->next=p;
}

/** Append a node of value val to the last element of the linked list. */
void myLinkedListAddAtTail(MyLinkedList* obj, int val) {
    MyLinkedList* p,*q;
    q=(MyLinkedList*)malloc(sizeof(MyLinkedList));
    p=obj;
    while(p->next!=NULL){
        p=p->next;
    }
    p->next=q;
    q->val=val;
    q->next=NULL;
}

/** Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted. */
void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {
    MyLinkedList* p,*q;
    q=(MyLinkedList*)malloc(sizeof(MyLinkedList));
    p=obj;
    int count,length;
    count=length=0;
    while(p->next){
        length++;
        p=p->next;
    }
    p=obj;
    if(index<0){
        myLinkedListAddAtHead(obj,val);
    }
    else if(length==index){
        myLinkedListAddAtTail(obj,val);
    }
    else{
        while(p->next!=NULL){
            if(count==index){
                q->next=p->next;
                q->val=val;
                p->next=q;
                break;
            }
            p=p->next;
            count++;
        }
    }
}

/** Delete the index-th node in the linked list, if the index is valid. */
void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) {
    MyLinkedList* p,*q;
    p=obj;
    int count=0;
    while(p->next!=NULL){
        if(count==index){
            q=p->next;
            p->next=q->next;
            free(q);
            break;
        }
        p=p->next;
        count++;
    }
}

void myLinkedListFree(MyLinkedList* obj) {
    MyLinkedList* p,*q;
    p=obj;
    q=p->next;
    while(q){
        free(p);
        p=q;
        q=q->next;
    }
    free(p);
}
采用双链表形式，设计一个链表：
typedef struct node{
    int val;
    struct node* next;
    struct node* pre;
} MyLinkedList;

/** Initialize your data structure here. */

MyLinkedList* myLinkedListCreate() {
    MyLinkedList* H;
    H=(MyLinkedList*)malloc(sizeof(MyLinkedList));
    H->next=NULL;
    return H;
}

/** Get the value of the index-th node in the linked list. If the index is invalid, return -1. */
int myLinkedListGet(MyLinkedList* obj, int index) {
    int flag,count,res;
    flag=count=0;
    MyLinkedList* p=obj;
    while(p->next!=NULL){
        p=p->next;
        if(count==index){
            res=p->val;
            flag=1;
        }
        count++;
    }
    if(!flag){
        res=-1;
    }
    return res;
}

/** Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list. */
void myLinkedListAddAtHead(MyLinkedList* obj, int val) {
    MyLinkedList* p;
    p=(MyLinkedList*)malloc(sizeof(MyLinkedList));
    p->val=val;
    p->next=obj->next;
    p->pre=obj;
    if(obj->next)
    {
        obj->next->pre=p;
    }
    obj->next=p;
}

/** Append a node of value val to the last element of the linked list. */
void myLinkedListAddAtTail(MyLinkedList* obj, int val) {
    MyLinkedList* p,*q;
    q=(MyLinkedList*)malloc(sizeof(MyLinkedList));
    p=obj;
    while(p->next!=NULL){
        p=p->next;
    }
    p->next=q;
    q->val=val;
    q->next=NULL;
    q->pre=p;
}

/** Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted. */
void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {
    MyLinkedList* p,*q;
    q=(MyLinkedList*)malloc(sizeof(MyLinkedList));
    p=obj;
    int count,length;
    count=length=0;
    while(p->next){
        length++;
        p=p->next;
    }
    p=obj;
    if(index<0){
        myLinkedListAddAtHead(obj,val);
    }
    else if(length==index){
        myLinkedListAddAtTail(obj,val);
    }
    else{
        while(p->next!=NULL){
            if(count==index){
                q->next=p->next;
                q->pre=p;
                q->val=val;
                p->next->pre=q;
                p->next=q;
                break;
            }
            p=p->next;
            count++;
        }
    }
}

/** Delete the index-th node in the linked list, if the index is valid. */
void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) {
    MyLinkedList* p,*q;
    p=obj;
    int count=0;
    while(p->next!=NULL){
        if(count==index){
            q=p->next;
            p->next=q->next;
            if(q->next)
            {
                q->next->pre=p;
            }
            free(q);
            break;
        }
        p=p->next;
        count++;
    }
}

void myLinkedListFree(MyLinkedList* obj) {
    MyLinkedList* p,*q;
    p=obj;
    q=p->next;
    while(q){
        free(p);
        p=q;
        q=q->next;
    }
    free(p);
}
  • 注意点：在确定插入结点或删除结点的pre指针时，一定要先考虑，当前的指针是否为空，空指针的错误，在链表中是非常容易犯，导致运行出错，要注意。
LeetCode707设计链表
m0_49844997的博客
12-26 1054
算法特点及适用场景特点基于自定义的链表节点结构体实现了一个功能较为完整的链表类，通过虚拟头节点的设计巧妙地简化了链表各种操作时的边界情况处理，使得代码逻辑相对清晰、易于理解和维护。各个操作方法的实现符合链表数据结构的基本操作逻辑，并且提供了方便的接口来获取、插入、删除节点以及查看链表内容等。
Java实现 LeetCode 707 设计链表（环形链表）
热门推荐
南 墙
04-07 1万+
707. 设计链表 设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。 在链表类中实现这些功能： get(index)：获取链表中第 index 个节点的值。如果索引...
Leetcode的AC指南 —— 链表：707. 设计链表
Huacyu的博客
12-14 173
**Leetcode的AC指南 —— 链表：707. 设计链表**。题目介绍：你可以选择使用单链表或者双链表，设计并实现自己的链表。单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。
LeetCode刷题笔记——707. 设计链表
weixin_43915885的博客
06-03 591
707. 设计链表题目描述解法（JAVA）Github分享 题目描述 题目地址：https://leetcode-cn.com/problems/design-linked-list 设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。 在链表类中实现这些功能： get(inde
707. 设计链表
Umbrella Corporation
06-05 7435
设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val和next。val是当前节点的值，next是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性prev以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。 在链表类中实现这些功能： get(index)：获取链表中第index个节点的值。如果索引无效，则返回-1...
Leetcode-每日一题【707. 设计链表】
lucky_1314520的博客
06-25 248
你可以选择使用单链表或者双链表，设计并实现自己的链表。单链表中的节点应该具备两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。输入输出// 链表变为 1->2->3// 返回 2// 现在，链表变为 1->3// 返回 3请不要使用内置的 LinkedList 库。
【LeetCode】707. 设计链表
Leonardo_t的博客
11-29 988
你可以选择使用单链表或者双链表，设计并实现自己的链表。val和next。val是当前节点的值，next是指向下一个节点的指针/引用。如果是双向链表，则还需要属性prev以指示链表中的上一个节点。假设链表中的所有节点下标从0开始。实现初始化对象。获取链表中下标为index的节点的值。如果下标无效，则返回-1。将一个值为val的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。将一个值为val的节点追加到链表中作为链表的最后一个元素。将一个值为val。
Leetcode707设计链表
peony的博客
05-07 198
Leetcode707设计链表 设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。 在链表类中实现这些功能： get(index)：获取链表中第 index 个节点的...
leetcode 707. 设计链表
最新发布
2503_93888304的博客
01-27 1055
有单链表版代码，c++版
leetcode_707. 设计链表_java
weixin_46211609的博客
04-09 829
707. 设计链表。你可以选择使用单链表或者双链表，设计并实现自己的链表。 单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。 如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。
LeetCode练习——707.设计链表（C++）
m0_73239022的博客
10-14 2208
链表是一种重要的数据结构，在计算机科学中有着广泛的应用。了解链表的基本概念和操作对于深入理解数据结构和算法具有重要意义。
707.设计链表（力扣LeetCode）
m0_73841621的博客
01-28 971
单链表中的节点应该具备两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。// 链表变为 1->2->3。// 现在，链表变为 1->3。你可以选择使用单链表或者双链表，设计并实现自己的链表。
【LeetCode】707.设计链表
yn_zi的博客
03-31 299
首先，我们需要定义一个结构体 LinkedNode，表示链表的节点。该结构体包含两个成员变量：val 表示节点的值，next 表示指向下一个节点的指针。然后，我们在类中定义一个私有变量 _dummyHead，表示链表的虚拟头结点，并初始化为 nullptr。同时，我们还定义一个私有变量 _size，表示链表中节点的数量，并初始化为 0。在各个操作函数中，我们需要事先做一些判断，本题中各个函数也给出了相应的提示；addAtIndex()：在链表第index个节点前面插入一个节点。本题考察了链表的常用操作。
【Leetcode】707. 设计链表
Hunter_Kevin的博客
01-07 586
【代码】【Leetcode】707. 设计链表。
力扣刷题--设计链表707
weixin_45332508的博客
01-11 1740
先找到最后一个节点：也就是cur的遍历次数：for(int i = 0;i < size;i++)再进行插入。i < size;
LeetCode刷题---707. 设计链表（双向链表-带头尾双结点）
JMFive的博客
11-07 1465
大家好，又见面了，我是夜阑的狗，本文是专栏【LeetCode题解】专栏的第11篇文章，主要讲解是LeetCode707. 设计链表（双向链表-带头尾双结点）。【LeetCode题解（持续更新中）】， 此专栏是我是夜阑的狗对LeetCode问题的讲解，希望能够加深自己的印象，以及帮助到其他的小伙伴😉😉。如果文章有什么需要改进的地方还请大佬不吝赐教👏👏。
707 设计链表
weixin_44832243的博客
04-28 192
【代码】707 设计链表。
707. 设计链表 python
weixin_42396719的博客
01-27 208
1
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值