C链表一——链表增删改查以及初始化的头插法与尾插法

线性表的链式存储又称为链表（物理实现方式）；

链式存储是最常用的存储方式之一。它不仅可以用来表示线性表，而且可以用来表示各种非线性的数据结构；

链表又可分为单链表、双链表、循环链表等。

一：单链表

所谓单链表是指数据结点是单向排列的。它包括两个域，一个信息域用于存放数据，一个指针域用于存放下个结点的地址；

单链表中结点类型的描述如下:

struct Node
{
    ElemType data_;  
    Node *next_;  
};

利用单链表可以解决顺序表需要大量的连续的存储空间的缺点，但是单链表附加了指针域，也带来了浪费存储空间的缺点。
注意：本文所有程序都是用“头指针”来表示一个单链表，而没有用带头结点的单链表。

头指针：是指向单链表第一个结点的指针；

头结点：单链表第一个结点之前附加的一个结点，此时，头指针指向头结点，头结点的指针域指向单链表的第一个结点；

结点的定义以及打印函数：

//结点声明
typedef struct tag
{
    int Nnum_;
    struct tag *Nnext_;
}Node, *pNode;

//打印函数
void link_print(pNode phead)
{
    while(phead != NULL)
    {
        printf("Node_value:%4d
", phead->Nnum_);
        phead = phead->Nnext_;
    }
}

一：利用尾插法初始化单链表

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

typedef struct tag
{
    int Nnum_;
    struct tag *Nnext_;
}Node, *pNode;


void link_print(pNode phead)
{
    while(phead != NULL)
    {
        printf("Node_value:%4d
", phead->Nnum_);
        phead = phead->Nnext_;
    }
}

void link_init_tail(pNode *phead, int size) //传的是地址
{
    pNode pNew = NULL;
    pNode pTail = NULL;

    while( size > 0)
    {
        //申请内存
        pNew = (pNode)malloc(sizeof(Node)); //注意这里为何不用pNode而用Node，因为sizeof(pNode) = 4
        //赋值
        pNew->Nnum_ = rand()%1000;
        //插入链表
        if(*phead == NULL) //链表为空时
        {
            *phead = pNew;//连接新的结点
            pTail = pNew;
        }
        else//不为空
        {
            pTail->Nnext_ = pNew ; //连接新的结点
             pTail = pNew; //改名字
        }
        
        size --;
    }
}

int main(int argc, char const *argv[])
{
    srand(time(NULL));
    pNode phead = NULL;
    link_init_tail(&phead, 10);

    link_print(phead);

    return 0;
}

二：利用头插法初始化单链表

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

typedef struct tag
{
    int Nnum_;
    struct tag *Nnext_;
}Node, *pNode;


void link_print(pNode phead)
{
    while(phead != NULL)
    {
        printf("Node_value:%4d
", phead->Nnum_);
        phead = phead->Nnext_;
    }
}

void link_init_head(pNode *phead, int size)
{
    pNode pNew = NULL;

    while( size > 0)
    {
        //申请内存
        pNew = (pNode)malloc(sizeof(Node)); //注意这里为何不用pNode而用Node，因为sizeof(pNode) = 4
        //赋值
        pNew->Nnum_ = rand()%1000;
        //插入链表
        if(*phead == NULL)
        {
            *phead = pNew;//连接新的结点;    
        }
        else
        {
            pNew->Nnext_ = *phead;//将pNew的next域置为phead
            *phead = pNew;
        }
        size --;
    }
}

int main(int argc, char const *argv[])
{
    srand(time(NULL));
    pNode phead = NULL;
    link_init_head(&phead, 10);

    link_print(phead);
    return 0;
}

三：删除结点

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <assert.h>

typedef struct tag
{
    int Nnum_;
    struct tag *Nnext_;
}Node, *pNode;

void link_print(pNode phead)
{
    int i= 0;
    while(phead != NULL)
    {
        printf("%3d", phead->Nnum_);
        phead = phead->Nnext_;
        ++i;
    }
    printf("i:%d
", i);
}

void link_init_tail(pNode *phead, int size) //传的是地址
{
    pNode pNew = NULL;
    pNode pTail = NULL;

    while( size > 0)
    {
        //申请内存
        pNew = (pNode)malloc(sizeof(Node)); //注意这里为何不用pNode而用Node，因为sizeof(pNode) = 4
        //赋值
        pNew->Nnum_ = rand()%50;
        //插入链表
        if(*phead == NULL) //链表为空时
        {
            *phead = pNew;//连接新的结点
            pTail = pNew;
        }
        else//不为空
        {
            pTail->Nnext_ = pNew ; //连接新的结点
             pTail = pNew; //改名字
        }        
        size --;
    }
}

//该函数只能删除一个相同的结点，如果想要删除所有与num相等的结点值，则直接在while循环里执行删除操作即可
void link_delete(pNode *phead, int num)//num表示要删除元素的数值
{
    assert( phead != NULL); //非空
    pNode pPre = NULL; 
    pNode pCur = *phead;

    while( pCur != NULL) //遍历链表找到要删除元素对的位置
    {
        if( pCur->Nnum_ == num) //找到
            break;
        else 
            {
                pPre = pCur;
                pCur = pCur->Nnext_;
            }
    }    

    if( pPre == NULL)//删除的是头结点
    {
        pNode tmp = *phead;
        *phead = (*phead)->Nnext_;
        free(tmp);
        tmp = NULL;
    }
    else if(pCur != NULL)//删除的是其余结点
    {    
        pNode tmp = pCur;
        pPre->Nnext_ = pCur->Nnext_;
        free(tmp);
        tmp = NULL;
    }
    else //没找到
        printf("find no element
");
}

int main(int argc, char const *argv[])
{
    srand(time(NULL));
    pNode phead = NULL;
    link_init_tail(&phead, 20);
    link_print(phead);


    link_delete(&phead, 5);
    link_print(phead);

    return 0;
}

四：按照从小到大的顺序依次插入结点：

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

typedef struct tag
{
    int Nnum_;
    struct tag *Nnext_;
}Node, *pNode;


void link_print(pNode phead)
{
    while(phead != NULL)
    {
        printf("%4d", phead->Nnum_);
        phead = phead->Nnext_;
    }
    printf("
");
}

void link_insert_by_sort(pNode *phead, int size)
{
    pNode pNew = NULL;
    pNode pCur, pPre;

    while( size > 0 )
    {
        pNew = (pNode)malloc(sizeof(Node));
        pNew->Nnum_ = rand()%1000;

        pPre = NULL;
        pCur = *phead;
        while( pCur != NULL)
        {
            if( pNew->Nnum_ > pCur->Nnum_) //按照从小到大排序
            {
                pPre = pCur;
                pCur = pCur->Nnext_;
            }
            else //找到位置
                break;
        }
        //找到的位置在头部
        if( pPre == NULL)
        {
            pNew->Nnext_ = *phead;
            *phead = pNew;
        }else//位置在中间或者尾部
        {
            pPre->Nnext_ = pNew;
            pNew->Nnext_ = pCur;
        }
        size --;
    }
}

int main(int argc, char const *argv[])
{
    srand(time(NULL));
    pNode phead = NULL;
    link_insert_by_sort(&phead, 10);

    link_print(phead);    

    return 0;
}

链表的改查较为简单，在此不再赘述。

链表的其他操作，详见下文：链表操作二——合并，逆转