代码随想录4

前言

今天的题目比较基础，就是一些细节容易出错。

今日题目：
设计链表
反转链表

---

设计链表

题意：

在链表类中实现这些功能：

get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

思路：链表基本操作，需要注意的是对head头结点的处理方式，以及指针遍历到末尾的边界处理。
代码如下：

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


MyLinkedList* myLinkedListCreate() {//头结点不存储元素
    MyLinkedList* head;
    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;
}
/*
int myLinkedListGet(MyLinkedList* obj, int index) {
    int i = 0;

    MyLinkedList* p = obj->next;
    while(p){
        if(i == index){
            return p->val;
        }
        else{
            p=p->next;
        }
        i++;
    }
    return -1;

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

}

void myLinkedListAddAtTail(MyLinkedList* obj, int val) {
    MyLinkedList* p = obj;
    MyLinkedList* s;
    s = (MyLinkedList *)malloc(sizeof(MyLinkedList));
    s->val = val;
    while(p->next != NULL){
        p=p->next;
    }
    p->next = s;
    s->next = NULL;

}

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);
    }   
}

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

反转链表

题目：
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 ：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

思路：
这题较为简单，一次就提交通过了。设立三个指针，pre指向head、p指向head下一个元素、temp保存p->next即p的下一个结点。
第一步将p->next指向pre，实现指针反转；

第二步将pre指向p，移动pre的位置，(注意pre要在p移动之前移动)；

第三步将p指向下一个要反转的元素即temp，最后再将temp往后移动一个位置。

函数返回值需要注意返回的是反转后的头结点，此时的头结点是原链表最后一个元素结点。
代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* reverseList(struct ListNode* head){
    if(head == NULL || head->next == NULL){
        return head;
    }

    struct ListNode * pre = head;
    struct ListNode * p = head->next;
    struct ListNode * temp = p;
    head->next = NULL;
    while(p){
        temp=p->next;
        p->next=pre;
        pre=p;
        p=temp;

    }
    head =pre;
    return head;
}