链表基础操作

链表定义：链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

操作：

1. 头插法

2. 尾插法

3. 链表指定插入

4. 查找

5. 删除

6. 销毁

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

#define Type int  //数据域类型为int


//链表节点定义
typedef struct ListNode
{
    Type value;//数据域
    struct ListNode* next;//指针域
}ListNode;

//节点创建
ListNode* CreateNode(int data)
{
    ListNode* node = (ListNode*)malloc(sizeof(ListNode));//创建一个位于堆区的节点；
    node->next = NULL;//指针域置空
    node->value = data;//赋值
    return node;
}
//尾插法
ListNode* ListBack_Push(ListNode* head, int i)
{
    if (head == NULL)//空链表判断
    {
        head = CreateNode(i);
        return head;
    }
    //链表非空
    ListNode* newNode = CreateNode(i);//创建新节点
    //进行尾插
    ListNode* tmp = head;
    while (tmp->next != NULL)//找到尾部
    {
        tmp = tmp->next;
    }
    tmp->next = newNode;
    return head;
}
//头插法
ListNode* ListFront_Push(ListNode*head,int i)
{
    if (head == NULL)//空链表判断
    {
        head = CreateNode(i);
        return head;
    }
    //链表非空
    ListNode* newNode = CreateNode(i);//创建新节点
    //进行头插
    newNode->next = head;
    head = newNode;
    return head;
}
//链表插入
ListNode* ListInsert(ListNode* head, int val, int pos)
{
    if (head == NULL && pos == 0)//链表为空且插入点为0；
{
    return CreateNode(val);
}
    else if(head==NULL&&pos!=0)//这些由自己想法实现
        return NULL;
    if (pos == 0)//头插
    {
        return ListFront_Push(head,val);
    }
    ListNode* now = head;//
    ListNode* pre = NULL;//now的前一个节点
    int step = 0;
    while (now && (pos!=step))//寻找位置
    {
        pre = now;
        now = now->next;
        step++;
    }
    if (step < pos)//pos大于链表长度
    {
        return head;
    }
    else if(now==NULL&&step==pos)//尾插
    {
        return ListBack_Push(head, val);
    }
    else//中间插
    {
        ListNode* node = CreateNode(val);
        node->next = now;
        pre->next = node;
    }
    return head;
}
//查找元素
void ListFind(ListNode*head,int val)
{
    ListNode* tmp = head;
    while (tmp != NULL)
    {
        if (tmp->value = val)
        {
            printf("找到了\n");
            return;
        }
        tmp = tmp->next;
    }
    printf("找不到\n");
}

//删除元素
ListNode*  ListDelete(ListNode* head, int val)//此处实现为 删除第一个出现符合的元素；val为元素值
{
    ListNode* now = head;
    ListNode* pre = NULL;
    while (now != NULL&&(now->value!=val))
    {
        pre = now;
        now = now->next;
    }
    if (now == NULL)//删除元素不存在
        return head;
    //存在
    pre->next = now->next;
    free(now);
    return head;
}

//链表打印
void ListPrint(ListNode*head)
{
    ListNode* tmp = head;
    while (tmp!=NULL)
    {
        printf("%d  ", tmp->value);
        tmp = tmp->next;//指针后移
    }
}
//链表释放
void ListFree(ListNode* head)
{
   if(head==NULL)
     return;
    ListNode* now = head;
    ListNode* after = now->next;
    while (after != NULL)
    {
        free(now);
        now = after;
        after = now->next;
    }
    free(now);//删除最后一个节点
}

int main()
{

    //实现一个数值为1-5的链表

    ListNode* head =(ListNode*) malloc(sizeof(ListNode));//创建一个头节点；也可以置空，让其在插入时创建；
    head->next = NULL;//指针域置空；
    head->value = 1;

    //ListNode* head = NULL;置空

    for (int i = 2; i < 6; i++)
    {
        //采用尾插法
        head=ListBack_Push(head, i);//1 2 3 4 5
        
        //采用头插法
        //head = ListFront_Push(head,i);//5 4 3 2 1
    }

    //链表插入
    head=ListInsert(head,3,1);//3为要插入的值，1为插入位置
    
    //删除元素
    head=ListDelete(head, 3);//此处实现为 删除第一个出现符合的元素；
    
    //链表打印
    ListPrint(head);

    //查找元素
    ListFind(head,4);

    //链表释放
    ListFree(head);
    
    return 0;
}

有错误欢迎大家指正哦！！！(●'◡'●)