基本数据结构——单向链表

    链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。属于线性结构。线性表的链式存储表示的特点是用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的）。因此，为了表示每个数据元素 与其直接后继数据元素 之间的逻辑关系，对数据元素 来说，除了存储其本身的信息之外，还需存储一个指示其直接后继的信息（即直接后继的存储位置）。如下图：
    ![单向链表的基本结构](https://img-blog.csdn.net/20170320155251261?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvd2VpeGluXzM3OTU4Mjg0/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)

    下面为linux下C语言的链表的基本操作：

/*===========================================================================
====                                                                     
====    File name           :  linklist_basic_opreation.c
====    Project name        :  
====    Project number      :  
====    Creation date       :  2017/03
====    Author(s)           :  Simba                             
====                                                                     
=============================================================================
===========================================================================*/
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef int data_t;
typedef struct node{
    data_t data;
    struct node *next;
}linknode_t , linklist_t;

//创建一个链表
linklist_t *Create_linklist()
{
    linklist_t *ll = (linklist_t*)malloc(sizeof(linklist_t));
    ll->next = NULL;

    return ll;
}
//获取链表有几个节点
int length_linklist(linklist_t *ll)
{
    int count = 0;
    while(ll->next != NULL)
    {
        ll=ll->next;
        count++;
    }
    return count;
}
//使用头插法插入一个节点
int insert_linklist_pre(linklist_t *ll, linknode_t *node)
{
    node->next=ll->next;
    ll->next=node;
    return 0;
}
//使用尾插法插入一个节点
int insert_linklist_end(linklist_t *ll, linknode_t *node)
{
    while(ll->next != NULL)
    {
        ll = ll->next;
    }

    ll->next = node;
    node->next=NULL;

    return 0;
}
//按照配置位置随机插入一个节点
int insert_linklist_random(linklist_t *ll, linknode_t *node , int index)
{
    if(length_linklist(ll) < index)
    {
        printf("insert index error");
        return -1;
    }

    while(index>0)
    {
        ll = ll->next;
        index --;
    }
    node->next = ll->next;
    ll->next = node;

    return 0;
}
//遍历链表
int traverse_linklist(linklist_t *ll)
{
    while(ll->next!=NULL)
    {
        printf("node.data:%d\n",ll->next->data);
        ll=ll->next;
    }

    return 0;
}
//根据位置获取该位置链表数据
int get_index_linklist(linklist_t *ll , int index)
{
    if(index > length_linklist(ll))
    {
        printf("get_index_linklist fail:index over range\n");
        return -1;
    }
    while(ll->next!=NULL && index >0)
    {
        index --;
        ll=ll->next;
    }

    return ll->next->data;
}
//删除某个位置的节点
int delete_node_linklist(linklist_t *ll , int index)
{
    if(length_linklist(ll) < index)
    {
        printf("insert index error");
        return -1;
    }

    while(index-1>0)
    {
        ll = ll->next;
        index --;
    }
    linknode_t *temp_node;
    temp_node = ll->next;
    ll->next = temp_node->next;
    free(temp_node)

    return 0;
}
//头删法删除链表节点
int delete_node_linklist_pre(linklist_t *ll)
{
    linknode_t *temp_node = NULL;
    if(ll->next == NULL)
    {
        printf("clear_linklist_pre fail : linklist is NULL\n");
        return -1;
    }
    else
    {
        temp_node = ll->next;
        ll->next = temp_node->next;
        free(temp_node);
        return 0;
    }
}
//尾删法删除链表节点
int delete_node_linklist_end(linklist_t *ll)
{
    if(ll->next == NULL)
    {
        printf("clear_linklist_pre fail : linklist is NULL\n");
        return -1;
    }

    int length = length_linklist(ll);
    linknode_t *temp_node = NULL;
    while(length-1 > 0)
    {
        ll=ll->next;
        length--;
    }
    temp_node = ll->next;
    ll->next = NULL;
    free(temp_node);

    return 0;
}
//清空链表
int clear_linklist(linklist_t *ll)
{
    while( length_linklist(ll) > 0)
    {
        delete_node_linklist_pre(ll);
    }

    return 0;
}
//销毁链表
int destory_linklist(linklist_t *ll)
{
    clear_linklist(ll);
    free(ll);

    return 0;
}
//迭代法链表逆序
linklist_t *iteration_reversed_linklist(linklist_t *ll)
{
    linklist_t *temp_ll = NULL;//       //get raw head
    linklist_t *new_ll = Create_linklist();     //new head
    linklist_t *old_ll = ll;        //old head

    /*获取原始链表的头节点，用头插法加入新的链表*/
    while(old_ll->next != NULL)//约束条件
    {
        /*还原变量*/
        temp_ll = old_ll->next;
        old_ll->next = temp_ll->next;
        /**********************/
        /*变换公式*/
        temp_ll->next = new_ll->next;
        new_ll->next = temp_ll;
        /**********************/
    }
    destory_linklist(ll);

    return new_ll;
}
//递归法链表逆序
void *recursion_reversed_linklist(linklist_t *ll,linklist_t *new_ll)
{
    if(ll->next == NULL)
    {
        ll = new_ll;
        return NULL;
    }

    linknode_t *temp_node = ll->next;
    temp_node->next = new_ll;
    puts("aaa");
    traverse_linklist(new_ll);
    recursion_reversed_linklist(temp_node , ll);
    return NULL;
}
int main()
{
    linklist_t *ll;
    ll = Create_linklist();

    linknode_t *node = (linknode_t *)malloc(sizeof(linknode_t));
    {
    node->data = 500;
    node->next = NULL;
    insert_linklist_pre(ll,node);

    node = (linknode_t *)malloc(sizeof(linknode_t));
    node->data = 600;
    node->next = NULL;
    insert_linklist_pre(ll,node);

    node = (linknode_t *)malloc(sizeof(linknode_t));
    node->data = 700;
    node->next = NULL;
    insert_linklist_pre(ll,node);
    //printf("linklist node sum :%d\n" , length_linklist(ll));
    //traverse_linklist(ll);
    }
    {
    node = (linknode_t *)malloc(sizeof(linknode_t));
    node->data = 1000;
    node->next = NULL;
    insert_linklist_end(ll,node);

    node = (linknode_t *)malloc(sizeof(linknode_t));
    node->data = 2000;
    node->next = NULL;
    insert_linklist_end(ll,node);

    node = (linknode_t *)malloc(sizeof(linknode_t));
    node->data = 3000;
    node->next = NULL;
    insert_linklist_end(ll,node);
    //printf("linklist node sum :%d\n" , length_linklist(ll));
    //traverse_linklist(ll);
    }
    {
    node = (linknode_t *)malloc(sizeof(linknode_t));
    node->data = 100000;
    node->next = NULL;
    insert_linklist_random(ll , node , 4);

    node = (linknode_t *)malloc(sizeof(linknode_t));
    node->data = 200000;
    node->next = NULL;
    insert_linklist_random(ll , node , 2);

    node = (linknode_t *)malloc(sizeof(linknode_t));
    node->data = 600000;
    node->next = NULL;
    insert_linklist_random(ll , node , 8);
    //printf("linklist node sum :%d\n" , length_linklist(ll));
    //traverse_linklist(ll);
    }

    ll = iteration_reversed_linklist(ll);
    printf("linklist node sum :%d\n" , length_linklist(ll));
    traverse_linklist(ll);

    linklist_t *new_ll = Create_linklist();
    recursion_reversed_linklist(ll,new_ll);
    printf("linklist node sum :%d\n" , length_linklist(new_ll));
    traverse_linklist(new_ll);

    printf("get index linklist :%d\n" ,get_index_linklist(ll , 5));
    printf("index data:%d\n",get_data_linklist(ll,4));
    printf("index data:%d\n",get_data_linklist(ll,8));

    {
    delete_node_linklist(ll,3);
    delete_node_linklist_pre(ll);
    delete_node_linklist_end(ll);
    printf("linklist node sum :%d\n" , length_linklist(ll));
    traverse_linklist(ll);
    }

    clear_linklist(ll);
    printf("linklist node sum :%d\n" , length_linklist(ll));
    traverse_linklist(ll);


    destory_linklist(ll);
    printf("linklist node sum :%d\n" , length_linklist(ll));
    traverse_linklist(ll);
    return 0;
}

以上代码为链表的基本操作，如有不对，敬请指正！！！