链表的实现

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

typedef int datatype;

typedef struct node
{
    datatype data;
    //定义结构体类型指针，指向结构体中的元素
    struct node *next;
}linklist,*linklist_p;//等价为typedef struct node * linklist_p,用linklist_p代替struct node *
//给链表开辟空间,链表的第一个位置的元素指向空指针
linklist_p create_linked();
//头插入
int insert_head(linklist_p L,datatype value);
//输出打印链表
void show_list(linklist_p L);
//头删除
int del_head(linklist_p L);
//判断链表是否为空，空返回1，非空返回0
int empty_list(linklist_p L);
//根据给定的value值，插入元素
int insert_order(linklist_p L,datatype value);
//根据给定的value值删除链表元素
int del_order(linklist_p L,datatype value);
//更改链表元素
void exch_list(linklist_p L, datatype old,datatype new);
//查找链表元素
int find_list(linklist_p L,datatype value);
//对链表元素进行反转。输出1234反转为4321
void reverse_list(linklist_p L);
int main(int argc, const char *argv[])
{
    //给链表开辟空间，首地址为L
    linklist_p L = create_linked();
    //判断函数是否调用成功
    if(NULL == L)
    {
        printf("函数调用失败\n");
        return -1;
    }
    //依据value值插入数据
    insert_order(L,2);
    insert_order(L,3);
    insert_order(L,4);
    insert_order(L,3);
    show_list(L);
    //删除数据
    del_order(L,4);
    show_list(L);
    exch_list(L,3,4);
    show_list(L);
    printf("%d\n",find_list(L,3));
    //链表反转
    reverse_list(L);
    show_list(L);
    return 0;
}

linklist_p create_linked()
{
    linklist_p L =(linklist_p) malloc(sizeof(linklist));
    if(NULL == L)
    {
        printf("内存开辟失败\n");
        return NULL;
    }
//链表的第一个位置指向空指针
    L->next = NULL;
    return L;
}
//头插入，新开辟一块内存空间，地址为p，其中p->next指向L->next（第一次为空），L->next地址为p，指向新开辟的内存空间
int insert_head(linklist_p L,datatype value)
{
    linklist_p p = (linklist_p)malloc(sizeof(linklist));
    if(p == NULL)
    {
        printf("内存开辟失败\n");
        return -1;
    }
    p->next = L->next;
    L->next = p;
    p->data = value;
    return 0;
}
//打印输出链表空间，判断条件是链表的最后一个元素指向空指针NULL
void show_list(linklist_p L)
{
    linklist_p p = L->next;
    while(p->next!=NULL)
    {
        printf("%d",p->data);
        p = p->next;
    }
    printf("%d\n",p->data);
}
//头删除，将L->next赋值给p，即删除第一个有data值的元素，将其下一位的地址即p->next赋值给L->next
int del_head(linklist_p L)
{
    linklist_p p = L->next;
    if(empty_list(L))
    {
        printf("链表为空，无法删除\n");
        return -1;
    }
    L->next = p->next;
    free(p);
    p = NULL;//记得将删除的元素地址指向空指针
    return 0;
}

int empty_list(linklist_p L)
{
    return L->next == NULL?1:0;
}

//依据value值大小对链表进行插入
int insert_order(linklist_p L,datatype value)
{
    //定义两个结构体指针：q用来遍历链表，p作为开辟的内存空间的地址，开辟空间之前首先指向空指针进行初始化
    linklist_p p =NULL, q = L;
    //遍历链表，比较q的下一个元素与value的大小，当其值不大于value值时，继续遍历数组，并且遍历之后发现value最大，满足q->next为NULL
    while(q->next != NULL && q->next->data <= value)
    {
        q = q->next;
    }
    //当q的下一个元素大于value时，需将存储在新开辟的内存空间的地址为p的元素插入到q之后
    if((p=(linklist_p)malloc(sizeof(linklist))) == NULL)
    {
        printf("分配地址失败\n");
        return -1;
    }
//给p这个元素赋值value
    p->data = value;
    //先将p指向q的下一个元素
    p->next = q->next;
    //q指向p，完成插入
    q->next = p;
    return 0;

}

//删除指定元素（按照指定alue值进行）只删除第一个元素
int del_order(linklist_p L,datatype value)
{
    linklist_p p = L,q = NULL;
    while(p->next != NULL&&p->next->data != value)
    {
        p = p->next;
    }
    if(p->next != NULL)
    {
        q = p->next;
        p->next = q->next;
        free(q);
        q = NULL;
    }
    return 0;
}

//替换
void exch_list(linklist_p L, datatype old,datatype new)
{
    linklist_p p = L;
    while(p->next != NULL && p->next->data != old)
    {
        p = p->next;
    }
    p->next->data = new;
}

//查找
int find_list(linklist_p L,datatype value)
{
    while(L->next != NULL)
    {
        if(L->next->data == value)
            return 1;
        L = L->next;
    }
    return 0;
}

//倒转链表,假设链表为123，倒转之后为321
void reverse_list(linklist_p L)
{
    //定义两个结构体指针，p指向头元素之后的一个元素，q指向空指针
    linklist_p p = L->next,q = NULL;
    //将头元素拿出并指向空指针
    L->next = NULL;
//对剩余的元素进行遍历，从头元素之后的一个元素开始
    while(p != NULL)
    {
        //将头元素之后的第一个元素拿出，将其地址赋值给q
        q = p;
        //此时p指向头元素之后的第二个元素
        p = p->next;
        //此时q（即拿出的头元素之后的第一个元素）指向空指针（原头元素所指向位置）
        q ->next = L->next;
        //头元素指向q（拿出的头元素之后的第一个元素）
        L->next = q;
        //此后继续遍历，头元素之后的第二个元素放在头元素和第一个元素之间
    }
}