单向链表基本操作（C实现）

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


typedef struct sNode
{
    int data;
    struct sNode *next;
}sNode;


//================创建节点=================//
sNode *NodeCreate()
{
    sNode *head = NULL;
    head = (sNode *)malloc(sizeof(struct sNode));
    if(head == NULL)
    {
        return NULL;
    }
    head->data = -1;
    head->next = NULL;

    sNode *pCur = head;

    int data;

    while(1)
    {
        printf("请输入新建节点数据：");
        scanf("%d", &data);
        if(-1 == data)
        {
            break;
        }
        sNode *pNew = (sNode *)malloc(sizeof(struct sNode));
        if(pNew == NULL)
        {
            return NULL;
        }
        pNew->data = data;
        pNew->next = NULL;

        pCur->next = pNew;
        pCur = pNew;

    }


    return head;
}

//================遍历节点=================//
int NodePrint(sNode * head)
{
    if(head == NULL)
    {
        return -1;
    }

    sNode * pCur = head->next;

    printf("head->");
    while(pCur != NULL)
    {
        printf("%d ->", pCur->data);
        pCur = pCur->next;
    }
    printf("NULL \n");
    return 0;
}

//=======节点值x前插入值为y节点,如没有下，插在最后====//

int NodeInsert(sNode * head, int x, int y)
{
    if(head == NULL)
    {
        return -1;
    }

    sNode * pPre = head;
    sNode * pCur = head->next;
    while(pCur != NULL)
    {
        if(pCur->data == x)
        {
            break;
        }
        else{
            pPre = pCur;
            pCur = pCur->next;
        }
    }

    sNode * pNew = (sNode *)malloc(sizeof(struct sNode));
    if(pNew == NULL)
    {
        return -2;
    }
    pNew->data = y;
    pNew->next = NULL;

    pNew->next = pCur;
    pPre->next = pNew;

}


//============删除第一个值为x节点============//

int NodeDel(sNode * head, int x)
{
    if(head == NULL)
    {
        return -1;
    }

    sNode * pCur = NULL;
    sNode * pPre = head;
    pCur = head->next;
    while(pCur != NULL)
    {
        if(pCur->data == x)
        {
            break;
        }
        else{
            pPre = pCur;
            pCur = pCur->next;
        }
    }
    if(pCur != NULL)
    {
        pPre->next = pCur->next;
        free(pCur);
        pCur = NULL;
    }
    else{
        printf("没有值为%d 节点 \n" ,x);
    }

    return 0;
}


//============删除所以值为x节点============//

int NodeDel2(sNode * head, int x)
{
    if(head == NULL)
    {
        return -1;
    }

    sNode * pCur = NULL;
    sNode * pPre = head;
    sNode * tmp = NULL;
    pCur = head->next;
    while(pCur != NULL)
    {
        if(pCur->data == x)
        {
            tmp = pCur;
            pCur = pCur->next;
            pPre->next = pCur;
            free(tmp);
            tmp =NULL;

        }
        else{
            pPre = pCur;
            pCur = pCur->next;
        }
    }


    return 0;
}


//============删除所有节点============//

int NodeDestory(sNode * head)
{

    if(head == NULL)
    {
        return -1;
    }

    sNode * pPre = head;
    sNode * tmp = NULL;

    while(pPre->next != NULL)
    {
        tmp = pPre;
        pPre = pPre->next;
        free(tmp);
    }

    return 0;
}



//============翻转单向链表============//

int NodeReverse(sNode * head)
{
    if(head == NULL || head->next == NULL)
    {
        return -1;
    }

    sNode * p = head->next;
    sNode * q = head->next->next;
    sNode * tmp = NULL;

    if(p == NULL || q == NULL)
    {
        return -2;
    }

    while(q != NULL)
    {
        tmp = q->next;
        q->next = p;
        p = q;
        q = tmp;
    }

    head->next->next = NULL;
    head->next = p;

    return 0;

}

//================单链表排序(冒泡)=================//
int NodeSort(sNode * head)
{
    if(head == NULL)
    {
        return -1;
    }

    sNode * pPre = head->next;
    sNode * PCur = pPre->next;
    sNode tmp;

    if(pPre == NULL || PCur == NULL)
    {
        return -2;
    }

    for(pPre = head->next; pPre->next != NULL; pPre = pPre->next)
        for(PCur = pPre->next; PCur != NULL; PCur = PCur->next)
    {
        if(pPre->data > PCur->data)
        {
//            tmp.data = pPre->data;
//            pPre->data = PCur->data;
//            PCur->data = tmp.data;

            tmp = *pPre;
            *pPre = *PCur;
            *PCur = tmp;

            tmp.next = pPre->next;
            pPre->next = PCur->next;
            PCur->next = tmp.next;

        }
    }

    return 0;
}

int main()
{
    int ret = 0;
    sNode *head = NULL;

    head = NodeCreate();

    NodePrint(head);

//    NodeInsert(head, 6, 4);
//    NodePrint(head);

//    NodeDel(head, 4);
//    NodePrint(head);

//    NodeDel2(head, 4);
//    NodePrint(head);

//    NodeDestory(head);
//    ret = NodePrint(head);
//    printf("ret = %d", ret);
//    NodeReverse(head);
//    NodePrint(head);


    NodeSort(head);
    NodePrint(head);


    return 0;
}