707.设计链表

题目：

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

思路：

类似于设计题其实没有很多的思路可言，根据题目要求来设计考察的就是程序员对于基本知识的运用，具体讲解在代码中一并说明

代码段：
 

//首先对于链表类的题目，在C语言中我们必须通过结构体的形式来打造链表。在链表的的基本
知识中 一个节点是包括值域和指针域的。所以在填充结构体内容中我们需要加入节点值val和一个
指向下个节点的指针next。
这里有一个小小的坑，在写指针域的时候我们不能写成Mylinkedlist *next，这样报错的原因是
由于在构造结构体的时候代码的读写依旧是从上到下，结构体的定义的别名MyLinkedList是在最后
出现的，所以在此之前写成MyLinkedList都是无法识别的。
typedef struct MyLinkedList_t{
    int val;
    struct MyLinkedList_t *next;
} MyLinkedList;

//在上一部分我们基本的形成了一个可以形成链表节点的结构体，所以第二步我们要进行链表的创造
我们在没对链表进行任何增删的操作前，我们也不知道这个链表里面有几个节点，毕竟这是设计链表的
题目，所以我们就最简单的只设置一个头结点，并且设置一个虚无但又有用的头结点，使这个头结点固定，
它后面挂的节点才是真正意义上的第一个节点。
MyLinkedList* myLinkedListCreate() {
//定义一个指针，其类型是我们已经设计好的结构体。再把这个指针malloc，动态的分配内存
    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){
        return -1;
    }
//然后就是通过一个变量now来标记节点，遍历一个节点，就自加1。
    int now=0;
    MyLinkedList *ListNow=obj->next;
//接下来就是考略循环的判定条件，其实条件有两个，一个就是now比index小就继续遍历，一个就是等到
遍历到的那个ListNow节点为空的时候就结束，我习惯性先把前提条件放在前面，也就是now<index，然后
在循环里面设定特殊条件 当ListNow==NULL的时候就返回-1
    while(now<index){
        if(ListNow==NULL){
            return -1;
        }
        ListNow=ListNow->next;
        now++;
    }
//注意由于我们上面设置的循环条件在循环到一个节点的时候并没有对节点的内容进行鉴定，所以我们这里要进行判空，如果不为空就返回这个节点的值
    if(ListNow!=NULL){
        return ListNow->val;
    }
    return -1;
}

//第二个需要的功能就是在链表的头结点的后面增加节点。
void myLinkedListAddAtHead(MyLinkedList* obj, int val) {
//同样先初始化一个节点，把这个要添加的节点值赋值进去，把节点指向null
    MyLinkedList *Node=(MyLinkedList *)malloc(sizeof(MyLinkedList));
    Node->val=val;
    Node->next=NULL;
//插入节点分为两种情况，一种是链表里面有节点，一种是没节点
    if(obj->next=NULL){
        obj->next=Node;
        return;
    }
    else{
        Node->next=obj->next;
        obj->next=Node;
    }
}

//第三个要求在链表的尾节点的后面添加一个节点
void myLinkedListAddAtTail(MyLinkedList* obj, int val) {
    MyLinkedList *Node=(MyLinkedList *)malloc(sizeof(MyLinkedList));
    Node->val=val;
    Node->next=NULL;
    MyLinkedList *ListNow=obj;
    while(ListNow->next!=NULL){
        ListNow=ListNow->next;
    }
    ListNow->next=Node;
}

//第四个也是添加节点里面最复杂的一个，给出一个值，要在这个节点的位置的前面添加一个节点
和之前找节点的思路应该说是很相似的的
void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {
//先判定特殊条件
    if(index<=0){
        myLinkedListAddAtHead(obj, val);
    }
//然后设置一个now来标记节点位置
    int now=0;
    MyLinkedList *ListNow=obj->next;
//进入循环之前我们就要想好有哪些判定条件，第一个最容易想到的就是当now==index-1的时候就停止遍历，然后在index-1处节点的后面添加一个节点，第二个就是Listnow->next！=null。所以我们让第二个条件成为遍历的前提条件
    while(ListNow->next!=NULL){
//设置now==index-1为break条件，把插入的操作放到循环的外面
        if(now==index-1){
            break;
        }
        ListNow=ListNow->next;
        now++;
    }
//还有一种特殊的情况就是遍历了所有的节点now值增加到最大了仍然达不到index-1的值，此时我们已经跳出循环了就进行判定如果不等于就不进行操作
    if(index-1!=now){
        return;
    }
    MyLinkedList *Node=(MyLinkedList)malloc(sizeof(MyLinkedList));
    Node->val=val;
    Node->next=ListNow->next;
    ListNow->next=Node;
}

//删除的操作和增加的操作基本一致，先遍历，找到后就进行删除操作，删除的操作无非就是把要删除的节点的前一个节点挂到要删除的节点的下一个节点上去。
void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) {
    if(index<0||obj->next==NULL){
        return;
    }
    if(index==0){
        obj->next=obj->next->next;
        return;
    }
    MyLinkedList *ListNow=obj->next;
    int now=0;
    while(ListNow->next!=NULL){
        if(now==index-1){
            break;
        }
    }
        ListNow=ListNow->next;
        now++;
        if(now==index-1&&ListNow->next!=NULL){
            ListNow->next=ListNow->next->next;
        }
}

//最后的最后就是进行释放由于malloc形成的多余的空间。我们可以写一个释放的函数，然后在free操作直接调用函数。所以最后的问题就是如何写这个函数。先思考，如果按照最开始的遍历方式从头遍历到尾巴，从第一个节点开始释放的话，是不是就是导致第一个节点和第二个节点断链的情况，所以我们需要做的就是从最后的节点开始释放，从最后开始释放到最开头我们很容易想到的就是递归的方式，这也是为什么链表天然带着递归的性质。
void myLinkedListFree(MyLinkedList* Node){
    if(Node->next!=NULL){
        myLinkedListFree(Node->next);
        Node->next=NULL;
    }
    free(Node);

}

void myLinkedListFree(MyLinkedList* obj) {
    myLinkedListFree(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);
*/