[代码随想录] day3—链表

链表

203：移除链表元素

思路一：递归法

ListNode* removeElements(ListNode* *head*, *int* *val*) {
		if(head==null){
				return head;
		}
		head=removeElements(head.next,val);
		return head.val==val?head.next:head;

}

若测试用例为[1,2,3,4,5]

head=removeElements(head.next,val);将数组递归到最后一个，也就是5，

而5.next==null 出栈后判断值是否为val，若是则返回head.next也就是null，数据删除。若不是则返回head也就是5，数据未删除。继续出栈并判断，下一个head为4,以此类推。

思路二：迭代法

由于链表头节点可能会被删除，所以设置哑节点。

temp.next=temp.next.next

ListNode* removeElements(ListNode* head, int val) {
        struct ListNode* dummyHead = new ListNode(0, head);
        struct ListNode* temp = dummyHead;
        while (temp->next != NULL) {
            if (temp->next->val == val) {
                temp->next = temp->next->next;
            } else {
                temp = temp->next;
            }
        }
        return dummyHead->next;
    }

707：设计链表

typedef struct MyLinkedList {
    int val;
    struct MyLinkedList* next;
}MyLinkedList;
MyLinkedList* myLinkedListCreate() {
    MyLinkedList* head = (MyLinkedList *)malloc(sizeof (MyLinkedList));
    head->next = NULL;
    return head;
}
int myLinkedListGet(MyLinkedList* obj, int index) {
    MyLinkedList *cur = obj->next;
    for (int i = 0; cur != NULL; i++){
        if (i == index){
            return cur->val;
        }
        else{
            cur = cur->next;
        }
    }
    return -1;
}

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

}
void myLinkedListAddAtTail(MyLinkedList* obj, int val) {
    MyLinkedList *cur = obj;
    while(cur->next != NULL){
        cur = cur->next;
    }
    MyLinkedList *ntail = (MyLinkedList *)malloc(sizeof (MyLinkedList));
    ntail->val = val;
    ntail->next = NULL;
    cur->next = ntail;
}
void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {
    if (index == 0){
        myLinkedListAddAtHead(obj, val);
        return;
    }
    MyLinkedList *cur = obj->next;
    for (int i = 1 ;cur != NULL; i++){
        if (i == index){
            MyLinkedList* newnode = (MyLinkedList *)malloc(sizeof (MyLinkedList));
            newnode->val = val;
            newnode->next = cur->next;
            cur->next = newnode;
            return;
        }
        else{
            cur = cur->next;
        }
    }
}
void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) {
    if (index == 0){
        MyLinkedList *tmp = obj->next;
        if (tmp != NULL){
            obj->next = tmp->next;
            free(tmp);     
        }
        return;
    }
    MyLinkedList *cur = obj->next;
    for (int i = 1 ;cur != NULL && cur->next != NULL; i++){
        if (i == index){
            MyLinkedList *tmp = cur->next;
            if (tmp != NULL) {
                cur->next = tmp->next;
                free(tmp);
            }
            return;
        }
        else{
            cur = cur->next;
        }
    }
    
}
void myLinkedListFree(MyLinkedList* obj) {
    while(obj != NULL){
        MyLinkedList *tmp = obj;
        obj = obj->next;
        free(tmp);
    }
}

206：反转链表

思路一：递归法

若测试用例为[1,2,3,4,5]

利用递归达到最后一个节点，第一轮出栈，head为5，head.next为NULL，返回5；第二轮出栈，head为4，4.next=5, head.next.next=>5.next=>4, 4.next=null,返回4；第三轮出栈，head为3，3.next=4, head.next.next=>4.next=>3, 3.next=null, 返回3；第四轮出栈，head为2，2.next=3, head.next.next=>3.next=>2, 2.next=null, 返回2；第五轮出栈，head为1，1.next=2， head.next.next=>2.next=>1, 1.next=null, 返回1；结果返回newhead。

public *ListNode* reverseList(*ListNode* *head*) {
	if(head==NULL||head.next==NULL){
		return head;
    }
    newhead=reverseList(head.next);
    head.next.next=head;
    head.next=null;
    return newhead;
  }

思路二：迭代法

public *ListNode* reverseList(*ListNode* *head*) {
    *ListNode* prev=null;
    *ListNode* curr=head;
	  while(curr!=null){
		   *ListNode* next=curr.next;
			curr.next=prev;
			prev=curr;
			curr=next;
		}
		return prev;
  }