带头结点的单链表（管理结构体作为头结点）

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

typedef int ElemType_t;

//保存数据的结构体
typedef struct node 
{
    ElemType_t data;
    struct node *pNext;
}Node_t;

//链表的头结点结构体
typedef struct list
{
    Node_t * head;
    Node_t * tail;
    int nodeNumber;
}listHead_t;

/**
 * 函数名：create_node
 * 函数作用：创建一个新结点
 * 函数参数：listHead->在哪个链表中创建一个新结点
 *          data->新结点的数据
 * 函数返回值：成功返回新结点的首地址，失败返回NULL 
 **/
Node_t *create_node(listHead_t* listHead,ElemType_t data)
{
    Node_t *newNode = (Node_t *)malloc(sizeof(Node_t));
    if(newNode == NULL)
    {
        printf("newNode error.\n");
        return NULL;
    }

    newNode->data = data;
    newNode->pNext = NULL;
    listHead->nodeNumber++;//链表结点数加一

    return newNode;
}

/**
 * 函数名：create_node
 * 函数作用：创建一个新结点
 * 函数参数：listHead->在哪个链表中创建一个新结点
 *          data->新结点的数据
 * 函数返回值：成功返回新结点的首地址，失败返回NULL 
 **/
listHead_t *create_list(void)
{
    listHead_t *listHead = (listHead_t *)malloc(sizeof(listHead_t));
    if(listHead == NULL)
    {
        printf("create_list error.\n");
        return NULL;
    }

    listHead->head = NULL;
    listHead->tail = NULL;
    listHead->nodeNumber = 0;

    return listHead;
}

void insertNodeTail(listHead_t* listHead,ElemType_t data)
{
    Node_t* newNode = create_node(listHead,data);
    if(newNode == NULL)
    {
        printf("newNode error.\n");
        return ;
    }

    if(listHead->head == NULL)//链表为空，只有头结点
    {
        listHead->head = newNode;
        listHead->tail = newNode;
    }
    else
    {
        listHead->tail->pNext = newNode;
        listHead->tail = newNode;
    }
}

void insertNodeHead(listHead_t* listHead,ElemType_t data)
{
    Node_t* newNode = create_node(listHead,data);
    if(newNode == NULL)
    {
        printf("newNode error.\n");
        return ;
    }

    if(listHead->head == NULL)//链表为空，只有头结点
    {
        listHead->head = newNode;
        listHead->tail = newNode;
    }
    else
    {
        newNode->pNext = listHead->head;
        listHead->head = newNode;
    }

}

void insertNodeFromKeyboard(listHead_t *listHead)
{
    printf("请输入结点的数据，多个数据空格隔开，以字母结束\n");

    while(1)
    {
        int inputdata;

        int ret = scanf("%d",&inputdata);
        if(ret != 1)
            break;

        Node_t* newNode = create_node(listHead,inputdata);
        if(newNode == NULL)
        {
            printf("newNode error.\n");
            return ;
        }
        if(listHead->head == NULL)//链表为空，只有头结点
        {
            listHead->head = newNode;
            listHead->tail = newNode;
        }
        else
        {
            listHead->tail->pNext = newNode;
            listHead->tail = newNode;
        }
    }

}

void traverse_list(listHead_t* listHead)
{
    Node_t* p = listHead->head;

    if(p == NULL) return;
    printf("结点数:%d,首结点:%d,尾结点:%d\n",listHead->nodeNumber,listHead->head->data,listHead->tail->data);

    while(p)
    {
        printf("%d ",p->data);
        p = p->pNext;
    }
    printf("\n");
}

void reverseList(listHead_t* listHead)
{
    Node_t *p = listHead->head;
    Node_t *pPre = NULL;

    while(p)
    {
        pPre = p->pNext;
        if(p == listHead->head)//是第一个结点，逆序后为尾结点
        {
            p->pNext = NULL;
            listHead->tail = p;
        }
        else//不是第一个结点
        {
            p->pNext = listHead->head;
        }
        listHead->head = p;
        p = pPre;
    }
}

void deleteNode(listHead_t* listHead,ElemType_t data)
{
    Node_t* p = listHead->head;
    Node_t* pPre = NULL;

    while(p)
    {
        if(p->data == data)
            break;
        pPre = p;
        p = p->pNext;
    }
    if(p == NULL)
    {
        printf("can't find deledata,dele error.\n");
        return ;
    }

    if(p == listHead->head) //第一个结点
    {
        listHead->head = p->pNext;
    }
    else
    {
        pPre->pNext = p->pNext;
    }
    free(p);
    listHead->nodeNumber--;

}

void sort_allToList(listHead_t* listHead)
{
    Node_t* p = listHead->head;//依次选择原来链表中的每个数据
    Node_t* pPre = NULL;

    while(p)
    {
        pPre = p->pNext;

        if(p == listHead->head)
        {
            p->pNext = NULL;
            listHead->tail = p;
        }
        else
        {
            Node_t* q = listHead->head; //每次都从第一个结点开始比较大小
            Node_t* qPrev = NULL;
            while(q)
            {
                if(p->data < q->data)
                    break;
                qPrev = q;
                q = q->pNext;
            }
            //现有排序最大(成为尾结点)
            if(q == NULL)
            {
                // qPrev->pNext = p;
                // p->pNext = NULL;
                listHead->tail->pNext = p;
                listHead->tail = p;
            }
            //现有排序中最小(插入头结点后面成为第一个结点)
            else if(q == listHead->head)
            {
                p->pNext = listHead->head;
                listHead->head = p;
            }
            //现有排序中间
            else
            {
                qPrev->pNext = p;
                p->pNext = q;
            }
        }
        p = pPre;
    }

}

void bubbleList(listHead_t* listHead)
{
    Node_t* p = listHead->head;

    for(int i = 0; i < listHead->nodeNumber-1;i++) 
    {
        p = listHead->head;
        for(int j = 0; j < listHead->nodeNumber-i-1;j++)
        {
            if(p->data > p->pNext->data)
            {
                ElemType_t temp = p->data;
                p->data = p->pNext->data;
                p->pNext->data = temp;
            }
            p = p->pNext;
        }
    }

}


int main(int argc, char **argv)
{

    listHead_t *listHead = create_list();
    //insertNodeFromKeyboard(listHead);
    insertNodeHead(listHead,5);
    insertNodeHead(listHead,8);
    insertNodeHead(listHead,3);
    insertNodeHead(listHead,56);
    insertNodeHead(listHead,11);

    traverse_list(listHead);

    //deleteNode(listHead,56);
    //reverseList(listHead);
    //sort_allToList(listHead);
    bubbleList(listHead);
    traverse_list(listHead);

    return 0;
}