C语言算法刷题笔记

菜鸡往前冲

已于 2022-08-15 19:57:21 修改

阅读量236

点赞数

文章标签： leetcode 链表算法

于 2022-08-05 10:50:41 首次发布

本文链接：https://blog.csdn.net/m0_48979117/article/details/126160961

版权

leetcode 707题设计链表

单链表、双链表的C语言实现

1.题目要求

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：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 个节点。

2.单链表实现

// 单链表
typedef struct mylist {
    int val;                        // 数据域                     
    struct mylist *next;    // 指针域
} MyLinkedList;

/* 链表生成函数 */
MyLinkedList* myLinkedListCreate() {
    MyLinkedList *obj = (MyLinkedList *)malloc(sizeof(MyLinkedList));
	obj->val = 0;
	obj->next = NULL;
    return obj;
}

/* 获取链表相应节点的数据值 */
int myLinkedListGet(MyLinkedList* obj, int index) {
    if(index<0||obj->next==NULL)     // 列表索引不正确或链表为空 返回-1
        return -1;

    MyLinkedList *node = obj->next;  // 获取头结点后面的链表。头结点是没有数据的
    for(int i = 0;i < index;i++){    // 遍历链表，找到对应的节点
        if(node==NULL) 
            return -1;
        node=node->next;
    }
    if(node!=NULL)
        return node->val;
    return -1;
}

/* 链表头插入节点 */
void myLinkedListAddAtHead(MyLinkedList* obj, int val) {
    MyLinkedList *newnode = (MyLinkedList*)malloc(sizeof(MyLinkedList));
    newnode->val=val;
    newnode->next=NULL;
    if(obj->next==NULL){      // 如果链表为空，只有头结点，直接在头结点后插入节点
        obj->next=newnode;
        return;
    }
    else{
        newnode->next=obj->next;  // 链表不为空，在头结点后面插入，头结点指向新节点
        obj->next=newnode;
    }
}

/* 在尾部插入节点 */
void myLinkedListAddAtTail(MyLinkedList* obj, int val) {
    MyLinkedList *newnode = (MyLinkedList*)malloc(sizeof(MyLinkedList));
    newnode->val = val;
    newnode->next = NULL;
    MyLinkedList *list = obj;
    while(list->next!=NULL){     // 遍历链表
        list = list->next;
    }
    list->next = newnode;
}

/* 在链表中的第index个节点之前添加值为val的节点。
/* 如果 index 等于链表的长度，则该节点将附加到链表的末尾。
/* 如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点*/
void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {
    if(index <= 0){               // index小于0，则在头部插入节点
        myLinkedListAddAtHead(obj,val);
        return;
    }
    MyLinkedList *list = obj;
    for(int i = 0; i < index; i++){  // 遍历链表到index节点之前，在第index个节点之前添加值为val的节点
        if(list->next == NULL)
            return ;
        else
            list = list->next;
    }

    MyLinkedList *newnode = (MyLinkedList*)malloc(sizeof(MyLinkedList));
    newnode->val=val;
    newnode->next=list->next;      // 插入节点，新节点指向index节点 index - 1节点指向新节点
    list->next=newnode;
}
/* 如果索引 index 有效，则删除链表中的第 index 个节点 */
void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) {
   	if (index < 0 || obj->next == NULL) {   // 索引小于 或链表为空返回 -1
		return;
	}
    if (index == 0) {                     
		obj->next = obj->next->next;     // 索引为0 删除头结点后的第一个节点
		return;
	}
    MyLinkedList *list = obj->next;

    for(int i = 0; i < index - 1; i++){   // 遍历链表，找到对应节点
        if(list->next == NULL)
            return;
        else
            list = list->next;
    }
	if (list->next != NULL) {      
		list->next = list->next->next;
	}
}
void myNodeFree(MyLinkedList* Node) {
	if (Node->next != NULL) {
		myNodeFree(Node->next);
		Node->next = NULL;
	}
	free(Node);
}
void myLinkedListFree(MyLinkedList* obj) {
    myNodeFree(obj);
}

3.双链表实现

// 双链表
typedef struct MyLink {
    int val;                      // 数据域
    struct MyLink *pre;           // 前指针
    struct MyLink *next;          // 后指针
} MyLinkedList;

// 创建链表函数
MyLinkedList* myLinkedListCreate() {
    MyLinkedList* node = (MyLinkedList*)malloc(sizeof(MyLinkedList));
    node->pre = NULL;
    node->next = NULL;
    node->val = 0;
    return node;
}

// 获取链表节点值
int myLinkedListGet(MyLinkedList* obj, int index) {
    MyLinkedList *list = obj;
    if(index < 0 || list->next == NULL)      // 索引值无效或链表为空返回-1
        return -1;
    for (int i = 0; i <= index; i++) {       // 遍历找到对应节点
        if (list->next == NULL) 
            return -1;
        else
            list = list->next;
    }
    return list->val;
}

// 在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点
void myLinkedListAddAtHead(MyLinkedList* obj, int val) {
    MyLinkedList* newnode = (MyLinkedList*)malloc(sizeof(MyLinkedList));
    newnode->pre = obj;            // 前指针指向头结点
    newnode->next = obj->next;     // 后指针指向头结点指针所指向的节点
    newnode->val = val;
    if (obj->next != NULL) {       // 如果链表非空,设置头结点后的节点的前指针指向新节点
        obj->next->pre = newnode;  
    }
    obj->next = newnode;           // 链表为空,头结点指针直接指向新节点
}

// 将值为 val 的节点追加到链表的最后一个元素
void myLinkedListAddAtTail(MyLinkedList* obj, int val) {
    MyLinkedList* list = obj;
    while (list->next != NULL) {    // 遍历链表找到尾节点
        if (list->next == NULL) 
            return;
        else
            list = list->next;
    }
    MyLinkedList* newnode = (MyLinkedList*)malloc(sizeof(MyLinkedList));
    newnode->pre = list;
    newnode->next = NULL;
    newnode->val = val;
    list->next = newnode;
}

void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {
    MyLinkedList *list = obj;
    if(index < 0)               // 索引值小于0.在头结点插入
        myLinkedListAddAtHead(obj,val);

    for (int i = 0; i < index; i++) {
        if (list->next == NULL) 
            return;
        else 
            list = list->next;
    }
    MyLinkedList* newnode = (MyLinkedList*)malloc(sizeof(MyLinkedList));
    newnode->pre = list;            // 前指针指向当前节点
    newnode->next = list->next;     // 后指针指向下一节点
    newnode->val = val;
    if (list->next){
        list->next->pre = newnode;  // 不是尾节点,让下一节点的前指针指向新节点
        list->next = newnode;       // 当前节点的后指针指向新节点
    }
    else
        myLinkedListAddAtTail(obj,val);   //如果 index 等于链表的长度，则该节点将附加到链表的末尾
 
}

// 删除链表中的第 index 个节点
void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) {
    MyLinkedList *list = obj;
    if(index < 0)    // 索引 index 无效
        return;
    for (int i = 0; i <= index; i++) {  // 从头结点开始遍历,找到对应节点,节点的索引值从0开始
        if (list->next == NULL) 
            return;
        else
            list = list->next;
    }
    if (list == NULL) 
        return;
    else
        list->pre->next = list->next;  // 让当前节点前一个节点的后指针指向当前节点的后一个节点
    if (list->next)                    
        list->next->pre = list->pre;   // 当前节点的后节点非空,是其前指针指向当前节点的前节点
        free(list);
}

// 释放链表
void myLinkedListFree(MyLinkedList* obj) {
    MyLinkedList *list = obj;
    while (list != NULL) {
        MyLinkedList *temp = list->next;
        free(list);
        list = temp;
    }
}

/**
 * Your MyLinkedList struct will be instantiated and called as such:
 * MyLinkedList* obj = myLinkedListCreate();
 * int param_1 = myLinkedListGet(obj, index);
 
 * myLinkedListAddAtHead(obj, val);
 
 * myLinkedListAddAtTail(obj, val);
 
 * myLinkedListAddAtIndex(obj, index, val);
 
 * myLinkedListDeleteAtIndex(obj, index);
 
 * myLinkedListFree(obj);
*/