关于单链表各种方法的实现

        最近一个人在做一个项目，对模块化有了新的感觉，另外再次感觉到基础的重要性，所以在今后长期一段时间内就会将基础知识作为学习的重心，所以刚把项目功能实现将链表实现一下，希望亡羊补牢，为时不晚。我觉得所有的事情都是因果循环，有因才有果，必须现在学习链表，就应该了解我们为什么要使用链表，也可以说使用链表有什么好处，只有了解了事物的本质，我们才能更好的使用它。这算是我给在校生了一个建议。

         在我看来，单链表是链接相同事物的一种机制，即链接的事物必须具有相同的属性，为什么链接他们是因为把他们组合起来成为一个集合，便于分类管理，这是使用它的原因，另外有正比有反，创建链表集群管理是好处，那么它就肯定有副作用，它的副作用是什么？负作用就是我们需要使用其中的某一事物时，不能立即得到它，而必须先在链表中来找它。，需要时间。

         然后我读了百度百科上的介绍，关键字：空间占用大，时间复杂度高，数组，不需要预先知道事物属性需要的空间大小。
         分析有两个缺点：1.没有和所有的数据结构联系起来思考。2.在集群的时候需要链接指针我却没有考虑到，这就是我目前思维的缺陷，希望以后能改正。

先考虑单链表应该有些什么样的操作：
        1.创建链表，2.销毁链表，3.插入元素，4.删除元素，5.遍历链表，6.链表逆置借助外界，7.链表逆置不借助外界
        8.显示所有链表
其次考虑各种操作的接口参数：
链表标识：字符串
1.创建链表
        目的：创建一个链表，这意味着我们可以创建多个链表，所以应该有不同的标识，同时我们需要为链表创建多少一个元素（此单链表数据类型必须一致）。
int creat_linklist(const char *,unsigned int)

2.销毁链表
        目的：删除一个链表。
int del_linklist(const char *,int)

3.插入元素
        目的：在某个链表中插入某个元素，每个元素的小属性不同（这是链表的重要特性：不需要预先知道事物的属性大小，必须实现）这里存在一个问题，每个元素的属性不同，我们怎么知道在使用它的时候，它是个什么东西，需要知道它是什么，我们必须要有另外的标识，这样不好，我们这里只实现不同长度的字符串（基本属性相同）。
int insert_linklist(const char *, int, const char*, int)

4.删除元素
        目的：删除某个链表中的某个元素。
int del_linkelement(const char*,int)

5.遍历链表
        目的：通过遍历来查找具有某一个属性的事物。
int traverse_linklist(const char*,const char*)

6.链表逆置
        目的：将某一个链表中的所有元素全部反转
int inverse(const char*)

下面是具体实现：

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

#define NAME_LENGTH 20

typedef struct node {
    int value;
    char name[NAME_LENGTH];
    struct node *next;
}node;

node *link;
char linklist_name[NAME_LENGTH];

node* create_linklist(void);
int print_linklist(node*);
int insert_linklist(node*);
int _insert_linklist(node*,node*);
int del_linklist(node*);
int inverse_linklist(node*);
int get_input(void);
int set_elementvalue(node*,const char*,int);
/*
 *get the input
 */
int get_input(void)
{
    int value,char_get;

    while (1) {
        char_get = scanf("%d",&value);

        if (0 == char_get) {
            while (((char_get=getchar())!='\n') && (char_get!=EOF));
            printf("wrong input,input again!");
        } else {
            break;
        }
    }

    /*
     *flush stdin
     */
    while (((char_get=getchar())!='\n') && (char_get!=EOF));
    return value;
}

/*
 *set the node value
 */
int set_elementvalue(node *current_node,const char *linklist_name,int element_value)
{
    if (NULL == current_node)
    {
        //...
        return 1;
    }
    if (NULL == linklist_name)
    {
        //...
        return 1;
    }

    /*set*/
    strcpy(current_node->name,linklist_name);
    current_node->value = element_value;

    return 0;
}

/*
 *insert
 */
int _insert_linklist(node *ahead_node,node *current_node)
{
    if (NULL==ahead_node || NULL==current_node)
        return 1;

    current_node->next = ahead_node->next;
    ahead_node->next = current_node;
    return 0;
}

/*
 *create
 */
node* create_linklist(void)
{
    int i,elements_count,element_value;
    node *first_node,*current_node,*ahead_node;

    elements_count = -1;
    first_node = current_node = NULL;

    /*get value*/
    printf("count:");
    elements_count = get_input();
    printf("linklist name:");
    fgets(linklist_name,NAME_LENGTH,stdin);

    for (i=0; i<elements_count; i++)
    {
        current_node = (node*)malloc(sizeof(node));
        if (NULL == current_node)
        {
            //...
            return NULL;
        }

        printf("value:");
        element_value = get_input();

        /*set value*/
        set_elementvalue(current_node,linklist_name,element_value);

        if (0 == i)
        {
            //...
            current_node->next = NULL;
            first_node = current_node;
            ahead_node = first_node;
        }
        else
        {
            /*insert*/
            _insert_linklist(ahead_node,current_node);
            ahead_node = ahead_node->next;
        }


    }

    return first_node;
}

/*
 *print
 */
int print_linklist(node *current_node)
{
    int i = 1;

    if (NULL == current_node)
    {
        //...
        return 1;
    }
    while (current_node != NULL)
    {
        printf("the %d element ",i);
        printf("name:%s " ,current_node->name);
        printf("value:%d\n" ,current_node->value);

        i++;
        current_node = current_node->next;
    }

    return 0;
}

/*
 *insert function
 */

int insert_linklist(node *first_node)
{
    node *ahead_node,*current_node;
    int place,i,element_value;

    ahead_node = current_node = NULL;
    place = -1;
    element_value = 0xffffffff;

    printf("which place you want to insert:");
    place = get_input();

    if (place <=0)
    {
        //...
        return 1;
    }

    printf("value:");
    element_value = get_input();

    current_node = (node*)malloc(sizeof(node));
    if (NULL == current_node)
    {
        //...
        return 1;
    }

    set_elementvalue(current_node,linklist_name,element_value);

    /*first place*/
    if (1 == place)
    {
        current_node->next = first_node;
        first_node = current_node;
        /*watch it*/
        link = first_node;
        return 0;
    }

    /*other place*/
    ahead_node = first_node;
    for (i=0; (i<place-2) && (ahead_node->next!=NULL); i++)
    {
        ahead_node = ahead_node->next;
    }

    _insert_linklist(ahead_node,current_node);

    return 0;
}

/*
 *delete element
 */
int del_linklist(node *first_node)
{
    int place,i;
    node *del_node,*ahead_node;

    del_node = ahead_node = NULL;
    place = -1;

    printf("which element you want to delete:");
    place = get_input();

    if (place <= 0)
    {
        //...
        return 1;
    }

    if (1 == place)
    {
        del_node = first_node;
        /*watch it*/
        first_node = first_node->next;
        link = first_node;
        free(del_node);
        return 0;
    }

    ahead_node = first_node;
    /*find the ahead node*/
    for (i=0; (i<place-2) && (ahead_node->next!=NULL); i++)
    {
            ahead_node = ahead_node->next;
    }

    if (NULL == ahead_node->next)
    {
        //...
        return 1;
    }
    /*delete it*/
    del_node = ahead_node->next;
    ahead_node->next = del_node->next;
    free(del_node);

    return 0;
}


/*
 *inverse
 */
int inverse_linklist(node *first_node)
{
    node *ahead_node,*current_node,*next_node;

    ahead_node = current_node = next_node = NULL;

    ahead_node = first_node;
    if (NULL == ahead_node->next)
        return 1;

    current_node = ahead_node->next;
    ahead_node->next = NULL;
    while ((next_node=current_node->next) != NULL)
    {
        /*inverse*/
        current_node->next = ahead_node;

        /*move next*/
        ahead_node = current_node;
        current_node = next_node;
    }

    /*the last two node*/
    current_node->next = ahead_node;
    link = current_node;

    return 0;
}
/*
 *
 */
int main(void)
{
    link = create_linklist();
    print_linklist(link);

    insert_linklist(link);
    print_linklist(link);

    del_linklist(link);
    print_linklist(link);

    inverse_linklist(link);
    print_linklist(link);

    return 0;
}

    尽管写之前就进行了接口设计，编写过程中仍然有许多变动，另外首先应该进行系统设计，然后是数据结构分析，最后才是具体的模块设计。