C语言--单链表

看《程序员面试宝典》记的单链表的代码

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

// 单链表节点结构体
typedef struct student
{
    int data;
    struct student *next;
}node;

// 创建单链表
node *create()
{
    node *head,*p,*s;
    int x,cycle = 1;
    head = (node*)malloc(sizeof(node));
    p = head;
    while(cycle)
    {
        printf("\nPlease input the data:");
        scanf("%d",&x);  // 输入0表示输入结束
        if(x != 0)
        {
           s = (node *)malloc(sizeof(node));
           s->data = x;
           printf("%d",s->data);
           p->next = s;
           p = s;
        }
        else
            cycle = 0;
    }
    p->next = NULL;
    p = head;          // 第一个节点没有存数据，现在没用了，将head指向下一节点，释放掉第一个节点
    head = head->next;
    free(p);
    printf("\nHead data:  %d\n",head->data);
    return head;
}


// 求单链表长度
int length(node *head)
{
    int n = 0;
    node *p;
    p = head;
    while(p != NULL)
    {
        p = p->next;
        n++;
    }
    return n;
}


// 输出单链表
void print(node *head)
{
    node *p;
    int n;
    n = length(head);
    printf("\nNow,These %d records are:\n",n);
    p = head;
    while(p != NULL)
    {
        printf("%d -> ",p->data);
        p = p->next;
    }
    printf("NULL\n");
}

// 根据节点数据删除一个单链表节点
//删除位置有：链表头 其他地方
node *del(node *head,int num)
{
    node *p1,*p2;
    p1 = head;
    while(num != p1->data && p1->next != NULL)
    {
        p2 = p1;
        p1 = p1->next;
    }

    if(num == p1->data)
    {
        if(p1 == head)  // 链表头
            head = p1->next;
        else            // 中间或尾
            p2->next = p1->next;
        free(p1);
    }
    else      // 没找到
        printf("\n%d could not been found!\n",num);

    return head;
}

// 单链表节点插入，按节点数据大小确定插入位置
// 插入位置有:链表头，链表中间，链表尾
node *insert(node *head,int num)
{
    node *p0,*p1,*p2;
    p1 = head;
    p0 = (node *)malloc(sizeof(node));
    p0->data = num;
    while(p0->data > p1->data && p1->next != NULL)
    {  // 找插入的位置
        p2 = p1;
        p1 = p1->next;
    }
    if(p1->next != NULL)
    {
        if(head == p1)  // 链表头
        {
            p0->next = p1;
            head = p0;
        }
        else            //链表中间
        {
            p2->next = p0;
            p0->next = p1;
        }
    }
    else                // 链表尾
    {
        p1->next = p0;
        p0->next = NULL;
    }

    return head;
}

// 对单链表排序，从小到大
node *sort(node *head)
{
    node *p,*p2,*p3;
    int n,temp;
    n = length(head);
    if(head == NULL || head->next == NULL)
        return head;

    for(int j = 1; j < n; j++)  // 一次循环可以确定最后一个元素
    {
        p = head;
        for(int i = 0; i < n-j; i++)
        {
            if(p->data > p->next->data) // 节点数据量较小，可以直接交换数据
            {
                temp = p->data;
                p->data = p->next->data;
                p->next->data = temp;
            }
            p = p->next;
        }
    }

    return head;
}

// 单链表的逆置
node *reverse(node *head)
{
    node *p1,*p2,*p3;
    // 没有元素或者只有一个元素的情况，直接返回
    if(head == NULL || head->next == NULL)
        return head;
    p1 = head;
    p2 = p1->next;
    while(p2)  // 就是把指向后面节点的指针指向前面节点
    {
        p3 = p2->next;
        p2->next = p1;
        p1 = p2;
        p2 = p3;
    }

    head->next = NULL; // 处理原链表头为链表尾
    head = p1;
    return head;
}

// main函数，测试上面功能
int main()
{
    int num;

    node *stulink = create(); // 创建单链表
    printf("\nLength:%d",length(stulink)); // 输出单链表长度
    print(stulink); // 输出单链表

    printf("\nPlease input a del num:");
    scanf("%d",&num);
    stulink = del(stulink,num); //删除一个节点
    print(stulink); // 输出单链表

    printf("\nPlease input an insert num:");
    scanf("%d",&num);
    stulink = insert(stulink,num); //插入一个节点
    print(stulink); // 输出单链表

    printf("\nSorting...\n");
    stulink = sort(stulink); //对单链表排序
    print(stulink); // 输出单链表

    printf("\nReversing...\n");
    stulink = reverse(stulink); // 对单链表逆置
    print(stulink);

    return 0;
}

除了链表节点的交换没有交换节点本身，别的地方还是符合规范的
另外还需要注意的就是在创建链表的时候第一个节点没有存数据，单纯做一个引导的作用，最后需要把它释放掉，
在 p->next=NULL; 之后，p在这儿已经没用了，所以可以指向head，head指向head->next,释放p指向的节点就可以了