单链表综合操作

链表是C语言面试中常见的问题，那么我们今天就实现一个作为练习。之前看过一些关于这方面的资料和 文章，写的都不尽人意，这次写一个具有启发性的历程，由于时间关系，有些东西还是不能一一罗列实现，因为必须要跳过进行下面的学习了，而且我留下的也都是主干之后的细枝末叶，需要花点时间优化。

eg：---考虑周全的代码---

/*   main.c   */


#include <stdio.h>
#include<malloc.h>
#include<stdlib.h>
#include"Mylist.h"
int main(void)
{
    Mylist *list1=(Mylist*)malloc(sizeof(Mylist));
    list1->value = 16;
    list1->next = NULL;
    Mylist* root = list1;//创建根节点root和第一个节点


    insert(&root, 15);//有序插入
    insert(&root, 13);
    insert(&root, 13);
    insert(&root, 20);
    //print(root);//打印节点数据

    insert1(&root, 13);//无序插入
    insert1(&root, 13);
    insert1(&root, 19);
    insert1(&root, 13);
    print(root);//打印节点数据

    //Del_data1(root, 13);err,将出现错误，具体转到定义查看
    //Del_data(&root, 13);//删除节点
    //print(root);
    
    search(root, 13);
    Del_data(&root, 13);
    print(root);
    search(root, 13);

    DestroyList(root);//销毁链表
    return 0;
}

从main函数可以看出，我的创建链表头的方式就需要优化，但是这只是一个模拟，我只需要创建一个链表头，后续用插入或者删除对其进行操作，但是，我们应该优化成一个函数，在这个函数，一般命名creat函数中，实现链表的多个节点创建，这不是本文所关心的，而且实现也是容易的，所以先用一个头节点模拟，但是要注意，请用malloc开辟内存，否则后面free会出错，这个bug把我弄地挺恼火了。

/*   Mylist.h   */


#ifndef _MYLIST_H_
#define _MYLIST_H_
typedef int listtyp;
typedef struct _SigList {
    listtyp value;
    //Mylist *link; err，至于为什么，好好回看c和指针，这里Mylist类型还没有创建
    struct _SigList *next;
}Mylist;

int insert(register Mylist **linkp, listtyp new_value);
int insert1(register Mylist **linkp, listtyp new_value);

void print(Mylist*root);
int DestroyList(Mylist* list);
int ClearList(Mylist* L);
void Del_data1(Mylist* list, listtyp del_value);
void Del_data(Mylist** list, listtyp del_value);
int search(Mylist* list, listtyp element);
#endif

重点在于源文件的实现：

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#include"Mylist.h"

#define FALSE 0
#define TRUE  1


/*插入到一个单链表，插入可以有序插入，也可以无序插入，
以有序为例，毕竟这样的场景更实用，
从小到大的顺序。
下面的代码有不好的地方，此时需要二级指针登场
如果忘了有什么不好的地方，P240， c和指针
*/
/*
int insert(Mylist * current, listtyp new_value)
{
    Mylist *previous;
    Mylist *new;
    //找到正确的插入位置，从小到大插入
    while (current!=NULL && current->value < new_value)
//在这个表达式中，->优先级最高，<优先级大于 !=,&&优先级最低，在不确定优先级的时候应该加括号
    {
        previous = current;
        current = current->next;
    }
    
    new = (Mylist*)malloc(sizeof(Mylist));//
    if (new == NULL)
    {
        return FALSE;
    }
    new->value = new_value;
    new->next = current;
    previous->next = new;
    return TRUE;
}*/
/*
还是存在特殊情况的讨论，还需要优化
int insert(Mylist **rootp, listtyp new_value)
{
    Mylist *current;
    Mylist *previous;
    Mylist *new;
    //得到指向第一个节点的指针
    current = *rootp;
    previous = NULL;

    //寻找正确的插入位置
    while (current!=NULL && current->value<new_value)
    {
        previous = current;
        current = current->next;
    }

    //为新节点分配内存
    new = (Mylist*)malloc(sizeof(Mylist));
    if (new = NULL)
        return FALSE;
    new->value = new_value;
    new->next = current;
    if (previous == NULL)
        *rootp = new;
    else
        previous->next = new;
    return TRUE;
}
*/
//最终版本之插入 ---有序
int insert(register Mylist **linkp, listtyp new_value)
{
    register Mylist *current, *new;
    
    while ((current = *linkp) != NULL && current->value < new_value)
    {
        linkp = &current->next;//我们只关心节点next字段
    }

    new = (Mylist*)malloc(sizeof(Mylist));
    if (new == NULL)
        return FALSE;
    new->value = new_value;
    new->next = current;
    *linkp = new;
    return TRUE;
}
//---无序插入
int insert1(register Mylist **linkp, listtyp new_value)
{
    register Mylist *current, *new;

    while ((current = *linkp) != NULL )
    {
        linkp = &current->next;//我们只关心节点next字段
    }

    new = (Mylist*)malloc(sizeof(Mylist));
    if (new == NULL)
        return FALSE;
    new->value = new_value;
    new->next = current;
    *linkp = new;
    return TRUE;
}
/*打印函数*/
void print(Mylist*root)
{
    while (root != NULL)
    {
        printf("%d 
", root->value);
        root = root->next;
    }
}
//销毁链表
int DestroyList(Mylist* list)
{ /* 初始条件：线性表L已存在。操作结果：销毁线性表L */
  //销毁之后就不要再去访问该链表 ！！！
    Mylist* q;
    while (list != NULL)
    {
        q = list->next;
        free(list);
        list = q;
    }
    return 1;
}
//清空链表
int ClearList(Mylist* L) 
{ /* 初始条件：线性表L已存在。操作结果：将L重置为空表 */
  //清空之后 还保留链表头，还可以访问该链表
    Mylist *p,*q;
    p = L->next; /* p指向第一个结点 */
    while (p) /* 没到表尾 */
    {
        q = p->next;
        free(p);
        p = q;
    }
    L->next = NULL; /* 头结点指针域为空 */
    return 1;
}
/* BUG代码，其他地方都没问题，删除第一个节点将出错，不过在写这个之前我已经
想到了，所以用了二级指针的实现方式，还是有进步O(∩_∩)O哈哈~

void Del_data1(Mylist* list, listtyp del_value)
{
    Mylist *pre = NULL;
    Mylist *sav_pre = list;
    while (sav_pre != NULL && sav_pre->value != del_value)
    {
        pre = sav_pre;//保存前一个节点
        sav_pre = sav_pre->next;
    }
    if (sav_pre->value == del_value)
    {
        if (sav_pre == (list))//while没有进入，首元素就要删除
        {
            //(*list) =sav_pre->next;//和下面一个道理
            (list) = (list)->next;
        }
        else
        {
            pre->next = sav_pre->next;
            printf("delete:%d
", del_value);
        }
        free(sav_pre);//sav_pre被删除，故释放其内存，但之后不能再访问，否则内存出错、
    }
}

*/
/*因为上面的代码删除第一个节点时，root会被释放，而后面的打印函数需要root指向第一个节点
  所以用二级指针，这样可以在函数中改变root的指向，并且释放删除节点的内存
*/
void Del_data(Mylist** list, listtyp del_value)
{
    Mylist *pre = NULL;
    Mylist *sav_pre = *list;
    while (sav_pre != NULL && sav_pre->value != del_value)
    {
        pre = sav_pre;//保存前一个节点
        sav_pre = sav_pre->next;
    }
    if (sav_pre == NULL)
    {
        printf("链表中没有你想删除的数据。
");
    }
    else
    {
        if (sav_pre->value == del_value)
        {
            if (sav_pre == (*list))//while没有进入，首元素就要删除
            {
                //(*list) =sav_pre->next;//和下面一个道理
                (*list) = (*list)->next;
            }
            else
            {
                pre->next = sav_pre->next;
            }
            printf("delete:%d
", del_value);
            free(sav_pre);//sav_pre被删除，故释放其内存，但之后不能再访问，否则内存出错、
        }
    }
}

int search(Mylist* list, listtyp element)
{
    int toll = 0;
    int no_or_have = 0;
    Mylist *s = list;
    while (s->next!=NULL)//记录一共有多少数据
    {
        toll++;
        s = s->next;
    }
    Mylist *pos = list;
    int count = 0;
    while (pos != NULL && pos->value != element)//放哨兵
    {
        count++;
        pos = pos->next;
    }
    if (pos == NULL)
    {
        printf("没有找到查询的值
");
    }
    else
    {
        if (pos != list)//不是一开头就找到
        {

            printf("在第%d节点处找到
", count + 1);
            count++;
            //因为上面找到的那个也要占位置，比如上面在2节点处找到了
            //但是我此时位置还是在2节点，要将其跳过因为，如果在2节点找到，count
            //并没有计数，所以这里手动加上1
            while (pos->next != NULL)
            {
                if (pos->next->value == element)
                {
                    //这里的if判断不能写成if(pos->value==element)，
                    //因为此时pos还是在找的节点处，要跳过该节点
                    //故写成    if (pos->next->value == element)
                    printf("在第%d节点处找到
", count + 1);
                }
                count++;
                pos = pos->next;

            }

        }
        else//一开始就找到
        {

            printf("在第%d节点处找到
", count + 1);
            count++;//因为上面找到的那个也要占位置

            while (pos->next != NULL)
            {
                if (pos->next->value == element)
                {
                    printf("在第%d节点处找到
", count + 1);
                }
                count++;
                pos = pos->next;

            }
        }
    }
    return 1;
}

这里面的讲究很多。

简要说明，因为大部分都已经有注释。先说插入算法，参考c和指针，经过两个过程，最终实现了一个相对最好的插入程序，再说删除，因为有了上面插入的提示，如果我在删除头结点的时候，会改变root指针，但是我的打印函数print必须要是root指针，自然想到了也用二级指针去del数据，还有就是插入分为有序插入和无序直接插入，有这两个模板应该可以完成大部分插入的要求，再说查找函数，我们要能够查询到一个多次出现的数据，但是删除我是删除的第一个遇到的数据，这也就是需要我们程序员根据需要更改或者优化的地方了，到底是删除第一次遇到的还是只要是这个数据都删除。

NOTE：

其中困扰我很久的一个问题就是链表内存请用堆空间，否则销毁链表free的时候会抛down，明明快要收工的时候，却发现free就失败，最后发现我main函数中的第一个开头点没有用malloc申请空间，改了之后就好了。

插入可以有序可以无序还可以按照你的算法进行插入。

查询函数，一定要可以查询所有存在的数据。

删除函数，根据以后具体业务需要，进行改进，到底是删除全部还是删除第一次遇到的还是删除第N此遇到的，所以删除函数需要根据业务需要进行更改。

二级指针还是必须熟练掌握的。

插入函数和查找函数需要重点掌握，时间久了可能会忘记，备注是个好习惯。