July_One_Week—linked list

#include <stdio.h>
#include <stdlib.h>

typedef struct linklist
{
    unsigned int count;
    struct linklist *next;
}linklist;

linklist* CreatLinklist(int len)
{
    linklist *head = NULL, *pre = NULL;
    head = (linklist*)malloc(sizeof(linklist));//头指针。
    pre = (linklist*)malloc(sizeof(linklist)); //pre-previous, 前一个;相对于head来说是后一个。
    printf("Please input the data:
");
    scanf("%u", &pre->count);
    head->next = pre; //head的后一个是pre。
    pre->next = NULL; //pre的next是NULL。

    for (int i = 1; i < len; i++)
    {
        linklist* tmp = (linklist*)malloc(sizeof(linklist));
        scanf("%u", &tmp->count);
        pre->next = tmp; //新加的节点放在pre后。
        tmp->next = NULL; //新加节点的next是NULL。
        pre = tmp; //新加的节点变成pre，等待下一个tmp。
    }
    return head;
}

int Outputlinklist(linklist *head)
{
    printf("#### Output linklist.
");
    if (head != NULL)
    {
        while (head->next != NULL)
        {
            printf("%u
", head->next->count);
            head = head->next;
        }
    }
}

int Lenlinklist(linklist *head)
{
    int len = 0;
    if (NULL == head->next)
        return len;
    len++;
    linklist *p = NULL;
    p = head->next;
    while(p->next != NULL)
    {
        len++;
        p = p->next;
    }
    return len;
}

int InsertLinklist(linklist *head, int index)
{
    int len = 0;
    len = Lenlinklist(head);
    printf("the length of linklist:%d, the insert index:%d
", len, index);
    if (index < 1 || index > len)
        return -1;
    int cur_index = 1;
    linklist *p = NULL;
    p = head->next;
    while(cur_index < index)
    {
        p = p->next;
        cur_index++;
    }
    linklist *node = (linklist*)malloc(sizeof(linklist));
    printf("Please input the new node data:
");
    scanf("%u", &node->count);
    node->next = p->next;
    p->next = node;
    return 0;
}

int DeleteNode(linklist *head, int index)
{
    int len = 0;
    len = Lenlinklist(head);

    if((index < 1) || (index > len))
        return -1;

    int cur_index = 1;
    linklist *p = NULL;
    linklist *q = NULL;
    p = head->next;
    while(cur_index < index)
    {
        p = p->next;
        cur_index++;
    }
    q = p->next;
    p->next = q->next;
    free(q);
    q = NULL;
}

linklist *Reverselinklist(linklist *head)
{
    linklist *p=NULL, *pre=NULL, *pnext=NULL;

    p = head->next;
    while(p!=NULL)
    {
        pnext = p->next;
        if(pnext == NULL)
            head->next = p;
        p->next = pre;
        pre = p;
        p = pnext;
    }
    return head;
}

int main(void)
{
    linklist *mylist = NULL;

    printf("#### Creat linklist.
");
    mylist = CreatLinklist(5);
    Outputlinklist(mylist);

    printf("#### Insert new node.
");
    InsertLinklist(mylist, 2);
    Outputlinklist(mylist);

    printf("#### Delete exist node.
");
    DeleteNode(mylist, 4);
    Outputlinklist(mylist);

    printf("#### Reverse Linklist.
");
    Reverselinklist(mylist);
    Outputlinklist(mylist);

    printf("Handle complete!");
}

1.线性表的链式存储和顺序存储的比较。

常见的数组就是线性表的顺序存储，各个结点之间被分配连续的物理内存，因此在查找上直接可以使用下标，速度很快，但是对于插入和删除操作需要在操作点之后执行移动操作，较为麻烦，并且数组在之前需要分配内存的大小，也就是需要我们知道结点的数量，这样就有一定的限制。
链表就是线性表的链式存储，各个结点之间在物理内存中是随机分配的，在查找时需要逐个遍历，但是在插入和删除操作时仅仅是局部性的指针切换，并且链表只有创建结点和删除结点时才会对内存进行操作，事先不需要知道结点数量。

2.单向链表属于线性表链式存储中最简单的一类，常见的操作包括：创建、删除、查找、插入、反序等。