代码随想录算法训练营第三天| 反转链表，设计链表，移除链表元素

206. 反转链表 - 力扣（LeetCode）

struct ListNode* reverseList(struct ListNode* head) {
    typedef struct ListNode ListNode;
    ListNode*tmp;
    ListNode*cur=head;
    ListNode*pre=NULL;
    
    while(cur){
        tmp=cur->next;
        cur->next=pre;
        pre=cur;
        cur=tmp;
    }
    return pre;
}

203. 移除链表元素 - 力扣（LeetCode）

struct ListNode* removeElements(struct ListNode* head, int val) {
    if(head==NULL){
        return 0;
    }
    struct ListNode* p=(struct ListNode*)malloc(sizeof(struct ListNode));
    p->next=head;//防止头结点被删除
    struct ListNode*pre;
    struct ListNode*cur;
    pre=p;
    cur=head; 
    while(cur!=NULL){
        if(cur->val==val){
            pre->next=cur->next;
            free(cur);
            cur=pre->next;
        }
        else{
            pre=cur;
            cur=cur->next;
        }
    }
    struct ListNode*newhead;
    newhead=p->next;
    return newhead;
}

707. 设计链表 - 力扣（LeetCode）

typedef struct MyLinkedList {
    int val;
    struct MyLinkedList* next;
} MyLinkedList;

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

int myLinkedListGet(MyLinkedList* obj, int index) {
    if(obj==NULL||index<0){
        return -1;
    }
    struct MyLinkedList* p=obj->next;
    int i=0;
    while(inext;
        i++;
    }
    if(p!=NULL){
        return p->val;
    }
    return -1;
}


void myLinkedListAddAtHead(MyLinkedList* obj, int val) {
    MyLinkedList* p=(MyLinkedList*)malloc(sizeof(MyLinkedList));
    p->val=val;
    p->next=obj->next;//
    obj->next=p;
}

void myLinkedListAddAtTail(MyLinkedList* obj, int val) {
    MyLinkedList* p=(MyLinkedList*)malloc(sizeof(MyLinkedList));
    p->val=val;
    p->next=NULL;
    MyLinkedList*pre=obj;//当链表为空时，pre = obj->next 会使 pre 为 NULL，后续对 pre->next 的访问会出错，需要特殊处理。
    while(pre->next!=NULL){
        pre=pre->next;
    }
    pre->next=p;
}

void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {
    if(obj==NULL||index<0){
        return ;
    }
    MyLinkedList* pre;
    MyLinkedList* cur;
    pre=obj;
    cur=obj->next;
    int i=0;
    while(inext;
        i++;
    }
    if (i == index) {
        MyLinkedList* newNode = (MyLinkedList*)malloc(sizeof(MyLinkedList));
        newNode->val = val;
        newNode->next = cur;
        pre->next = newNode;
    }
}

void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) {
    if(obj==NULL||index<0){
        return ;
    }
    MyLinkedList* pre;
    MyLinkedList* cur;
    pre=obj;
    cur=obj->next;
    int i=0;
    while(inext;//删除的是这个
        i++;
    }
    // 检查 cur 是否为 NULL，如果不为 NULL 则进行删除操作
    if (cur != NULL) {
        pre->next = cur->next;
        free(cur);
    }
}

void myLinkedListFree(MyLinkedList* obj) {
    if (obj == NULL) {
        return;
    }
    MyLinkedList* current = obj->next;
    while (current != NULL) {
        MyLinkedList* temp = current;
        current = current->next;
        free(temp);
    }
    free(obj);
}

/**
 * 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);
*/