C语言实现单链表，并完成链表常用API函数

C语言实现单链表，并完成链表常用API函数：

　　1.链表增、删、改、查。

　　2.打印链表、反转打印、打印环形链表。

　　3.链表排序、链表冒泡排序、链表快速排序。

　　4.求链表节点个数（普通方法、递归方法）。

　　5.链表反转（普通方法、递归方法）。

　　6.链表合并。

　　7.获取链表中间节点。

　　8.判断链表是否有环。

LinkList.h :

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

struct LinkNode
{
    int data;
    struct LinkNode *pNext;
};

typedef struct LinkNode Node;    //简化类型

void init(Node *phead);                            //初始化
Node *addBack(Node *phead, int data);            //尾插法：尾部添加节点
void addHead(Node *phead, int data);            //头插法：头部添加节点

void ShowAll(Node *phead);                        //显示链表
void revShowAll(Node *phead);                    //反转显示链表                                
void ShowCircleLink(Node *phead);                //显示环形链表

Node *searchFirst(Node *phead, int findData);    //查找

Node *changeFirst(Node *phead, int findData, int newData);    //修改

Node *delFirst(Node *phead, int delData);        //删除

Node *insertFirst(Node *phead, int insertData,int newData);        //插入

void bubbleSort(Node *phead);                    //冒泡排序

void quickSort(Node *pbegin, Node *pback);        //快速排序法：（双冒泡）
Node *fen(Node *pbegin, Node *pback);            //分段

int getNum1(Node *phead);                        //求链表节点个数
int getNum2(Node *phead);                        //求链表节点个数(递归)

Node *revList1(Node *phead);                    //链表反转(普通方法)
Node *revList2(Node *phead);                    //链表反转(递归方法)

//将链表phead1和phead2合并到phead3，并返回链表phead3
Node *mergeList(Node *phead3, Node *phead1, Node *phead2);        //链表合并

Node *getMid(Node *phead);                        //获取链表的中间节点

int judgeCircle(Node *phead);                    //判断链表是否有环

LinkList.c :

#include "LinkList.h"

//初始化
void init(Node *phead)
{
    phead->pNext = NULL;
    phead->data = 0;
}

//显示链表
void ShowAll(Node *phead)
{
    if (phead == NULL)
        return;
    else
    {
        printf("%4d", phead->data);
        //printf("%d,%p,%p
", phead->data, phead, phead->pNext);
        ShowAll(phead->pNext);                                    //跳到下一个节点

    }
}

//反转显示链表
void revShowAll(Node *phead)
{
    if (phead == NULL)
        return;
    else
    {
        printf("%d,%p,%p
", phead->data, phead, phead->pNext);
        ShowAll(phead->pNext);                                    //跳到下一个节点

    }
}

//显示环形链表
void ShowCircleLink(Node *phead)
{
    if (phead == NULL)
        return;
    else
    {
        Node *p = phead;
        for (; p->pNext != phead; p = p->pNext)
            printf("%4d", p->data);

        printf("%4d", p->data);    //还需要再打印最后一个元素

    }
}

//尾插法：尾部添加节点  (改变了头指针，改变一个指针，要么二级指针，要么用返回值给指针赋值，这里采用返回值)
Node *addBack(Node *phead, int data)
{
    Node *pnew = malloc(sizeof(Node));    //构建新的节点
    pnew->data = data;                    //新节点赋值
    pnew->pNext = NULL;

    if (phead == NULL)                    //phead为空，直接连接
        phead = pnew;
    else
    {
        Node *ptemp = phead;            //备份一下头指针
        while (ptemp->pNext != NULL)
        {
            ptemp = ptemp -> pNext;        //循环前进
        }
        ptemp->pNext = pnew;            //链接
    }

    return phead;
}

//头插法：头部添加节点 (采用二级指针的方法)
void addHead(Node **pphead, int data)
{
    Node *pnew = malloc(sizeof(Node));    //构建新的节点
    pnew->data = data;                    //新节点赋值
    pnew->pNext = NULL;

    if(*pphead==NULL)
        pphead = pnew;
    else
    {
        pnew->pNext = *pphead;
        *pphead = pnew;
    }
}

//查找
Node *searchFirst(Node *phead, int findData)
{
    for (Node *p = phead; p != NULL; p = p->pNext)
    {
        if (p->data == findData)
        {
            return p;        //返回找到的指针位置
        }
    }

    return NULL;
}

//修改
Node *changeFirst(Node *phead, int findData, int newData)
{
    for (Node *p = phead; p != NULL; p = p->pNext)
    {
        if (p->data == findData)
        {
            p->data = newData;
            return p;        //返回找到的指针位置
        }
    }

    return NULL;
}

//删除
Node *delFirst(Node *phead, int delData)
{
    Node *p1=NULL, *p2=NULL;        //此时需要双指针
    p1 = phead;            //保存头结点

    while (p1 != NULL)
    {
        if (p1->data != delData)
        {
            p2 = p1;        //p2保存的是p1的上一个位置
            p1 = p1->pNext;
        }
        else
            break;
    }

    if (p1 != phead)
    {
        p2->pNext = p1->pNext;    //跳过p1
        free(p1);                //删除p1
    }
    else
    {
        phead = phead->pNext;
        free(p1);                //头部删除
    }

    return phead;
}

//插入
Node *insertFirst(Node *phead, int insertData, int newData)
{
    Node *p1 = NULL, *p2 = NULL;        //此时需要双指针
    p1 = phead;            //保存头结点

    while (p1 != NULL)
    {
        if (p1->data != insertData)
        {
            p2 = p1;        //p2保存的是p1的上一个位置
            p1 = p1->pNext;    //向前移动
        }
        else
            break;
    }

    Node *pnew = malloc(sizeof(Node));    //构建新的节点
    pnew->data = newData;                //新节点赋值
    pnew->pNext = NULL;

    if (phead == p1)
    {
        pnew->pNext = phead;    //保存头结点
        phead = pnew;            //头部插入
    }
    else
    {
        pnew->pNext = p1;
        p2->pNext = pnew;        //插入
    }

    return phead;
}

//冒泡排序
void bubbleSort(Node *phead)
{
    //数组可以随机访问任何一个元素，可以规避一些比较
    //链表找到N个元素，必须先遍历N-1个元素
    for (Node *p1 = phead; p1 != NULL; p1 = p1->pNext)
    {
        for (Node *p2 = phead; p2 != NULL; p2 = p2->pNext)
        {
            if (p1->data < p2->data)
            {
                int temp;
                temp = p1->data;
                p1->data = p2->data;
                p2->data = temp;
            }
        }
    }
}

Node *fen(Node *pbegin, Node *pback)
{
    int key = pbegin->data;        //以第一个数据为分段

    Node *p = pbegin;            //第一个节点
    Node *q = pbegin->pNext;    //第二个节点

    while (q != pback)
    {
        if (q->data < key)
        {
            p = p->pNext;        //循环下一个节点

            int temp = p->data;    //交换
            p->data = q->data;
            q->data = temp;
        }
        q = q->pNext;            //循环第二个指针

        printf("
枢轴为：(%d)", key);
        printf("
此时数：");
        ShowAll(pbegin);

    }

    int temp = p->data;    //交换
    p->data = pbegin->data;
    pbegin->data = temp;

    printf("

交换值：");
    ShowAll(pbegin);
    printf("
-----------------------------------------------");

    return p;
}

//快速排序法：（双冒泡）
void quickSort(Node *pbegin,Node *pback)
{
    if (pbegin != pback)
    {
        Node *pfen = fen(pbegin, pback);    //取中间点，分成两段分别再进行快排

        quickSort(pbegin, pfen);            //前半段快排
        quickSort(pfen->pNext, pback);        //后半段快排
    }
}

//求链表节点个数(普通方法)
int getNum1(Node *phead)
{
    int i = 0;
    for (; phead != NULL; phead = phead->pNext)
    {
        i++;
    }
    return i;
}

//求链表节点个数(递归)
int getNum2(Node *phead)
{
    if (phead == NULL)
        return 0;
    else
        return 1 + getNum2(phead->pNext);
}

//链表反转(普通方法)
Node *revList1(Node *phead)
{
    if (phead == NULL || phead->pNext == NULL)
        return phead;
    else
    {
        Node *pre = NULL;
        Node *pcur = NULL;
        Node *pnext = NULL;

        pre = phead;
        pcur = phead->pNext;
        while (pcur != NULL)
        {
            pnext = pcur->pNext;    //备份下一个节点
            pcur->pNext = pre;        //第一个节点指向NULL,此时pre指向NULL(指针反转)
            
            pre = pcur;                //前进
            pcur = pnext;            //轮替前进
        }

        phead->pNext = NULL;        //注意尾节点置空
        phead = pre;
    }

    return phead;
}

//链表反转(递归方法)
Node *revList2(Node *phead)
{
    if (phead == NULL || phead->pNext == NULL)
        return phead;
    else
    {
        Node *pnext = phead->pNext;        //顺序

        Node *Head = revList2(pnext);    //轮询所有的节点，递归调用

        pnext->pNext = phead;

        phead->pNext = NULL;            //逆序

        return Head; 
    }
}

//链表合并
Node *mergeList(Node *phead3, Node *phead1, Node *phead2)
{
    Node *pcur1 = phead1;
    Node *pcur2 = phead2;

    while (pcur1 != NULL || pcur2 != NULL)
    {
        if (pcur1 != NULL && pcur2 != NULL)
        {
            if (pcur1->data < pcur2->data)
            {
                phead3 = addBack(phead3, pcur1->data);
                pcur1 = pcur1->pNext;
            }
            else
            {
                phead3 = addBack(phead3, pcur2->data);
                pcur2 = pcur2->pNext;
            }
        }
        else
        {
            while (pcur1 != NULL)
            {
                phead3 = addBack(phead3, pcur1->data);
                pcur1 = pcur1->pNext;
            }
            while (pcur2 != NULL)
            {
                phead3 = addBack(phead3, pcur2->data);
                pcur2 = pcur2->pNext;
            }

            break;
        }
    }

    return phead3;
}

//获取链表的中间节点
Node *getMid(Node *phead)
{
    if (phead == NULL || phead->pNext == NULL)
        return phead;
    else
    {
        Node *p1 = phead;            //一次前进一步
        Node *p2 = phead;            //一次前进两步

        while (p2->pNext != NULL)    //注意循环条件,而不是p2 != NULL
        {
            p1 = p1->pNext;
            p2 = p2->pNext;
            if (p2->pNext != NULL)
                p2 = p2->pNext;
        }

        return p1;
    }
}

//判断链表是否有环
int judgeCircle(Node *phead)
{
    int flag = 0;
    for (Node *p1 = phead, *p2 = phead; p1 != NULL && p2 != NULL; p1 = p1->pNext, p2 = p2->pNext)    //死循环
    {    
        if(p2->pNext!=NULL)    //p2一次前进两步，而p1一次前进一步
            p2 = p2->pNext;

        if (p1 == p2)
        {
            flag == 1;        //p1追上了p2，有环
            break;
        }
            
        
    }

    return flag;
}

main.c :

#include "LinkList.h"

void main()
{
    Node *phead = NULL;
    //init(phead);    //初始化，头结点不分配内存，这里不能初始化头结点

    phead = addBack(phead, 14);        //尾插
    phead = addBack(phead, 15);
    phead = addBack(phead, 16);
    phead = addBack(phead, 8);
    phead = addBack(phead, 12);
    phead = addBack(phead, 13);

    //addHead(&phead, 9);            //头插
    //addHead(&phead, 22);
    //addHead(&phead, 41);
    //addHead(&phead, 18);
    //ShowAll(phead);

    //Node *pfind = searchFirst(phead, 13);
    //pfind->data = 33;
    //ShowAll(phead);

    //Node *pchange = changeFirst(phead, 14,93);
    //ShowAll(phead);

    //ShowAll(phead);
    //printf("

");
    //phead = delFirst(phead, 24);
    //ShowAll(phead);

    //printf("

");
    //insertFirst(phead, 11, 100);
    //ShowAll(phead);

    printf("排序前：");
    ShowAll(phead);
    printf("

");

    //bubbleSort(phead);
    quickSort(phead, NULL);
    
    printf("

");
    printf("排序后：");
    ShowAll(phead);
    printf("
");

    printf("%d
", getNum2(phead));

    phead = revList1(phead);
    ShowAll(phead);
    printf("
");
    phead = revList2(phead);
    ShowAll(phead);
    printf("
");

    Node *phead1 = NULL;
    phead1 = addBack(phead1, 1);
    phead1 = addBack(phead1, 3);
    phead1 = addBack(phead1, 5);
    phead1 = addBack(phead1, 7);
    phead1 = addBack(phead1, 9);

    Node *phead2 = NULL;
    phead2 = addBack(phead2, 2);
    phead2 = addBack(phead2, 4);
    phead2 = addBack(phead2, 6);
    phead2 = addBack(phead2, 8);

    printf("


");
    ShowAll(phead1);
    printf("
");
    ShowAll(phead2);
    printf("
");

    Node *phead3 = NULL;
    phead3 = mergeList(phead3, phead1, phead2);
    ShowAll(phead3);
    printf("
");

    Node *pmid = getMid(phead3);
    printf("%d
", pmid->data);

    Node *phead4 = NULL;
    phead4 = addBack(phead4, 1);
    phead4 = addBack(phead4, 2);
    phead4 = addBack(phead4, 3);
    phead4 = addBack(phead4, 4);
    phead4 = addBack(phead4, 5);
    phead4 = addBack(phead4, 6);
    phead4 = addBack(phead4, 7);

    Node *p = phead4;
    for (; p->pNext != NULL; p = p->pNext)
    {
    }
    p->pNext = phead4;

    ShowCircleLink(phead4);    //打印环形链表
    printf("
");
    printf("%d
", judgeCircle(phead4));

    system("pause");
}