线性表的链式存储实现（不带头结点）

建议使用带头结点的版本，因为不带头结点的版本有一些缺陷：

在插入或删除操作中，如果返回类型不是链表，那么形参类型一定是指向头结点的指针（也就是二级指针），因为传递指针实参时，形参实际上是实参的副本，所以实参的指向是一直不变的，如果在插入过程中插在了头指针的下一个位置（也就是第一个结点的位置），如果返回类型不是链表或形参不是二级指针，那么插入操作对原链表时无效的，而如果删除释放了第一个结点，那么由于实参的指向始终是第一个结点的那块内存，那么实参指针就是指向一块不知名的内存，成为野指针。总的来说，不带头结点的版本，在删除或插入操作中，如果返回类型不是链表或形参不是二级指针，那么该操作不能作用在第一个结点上

关于指针作为形参的问题可以参考：https://www.cnblogs.com/hi3254014978/p/9478307.html

LinkList.h

#ifndef LINKLIST_H_INCLUDE
#define LINKLIST_H_INCLUDE

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

#define ERROR -1

typedef int ElementType;

typedef struct LNode* PtrToNode;
struct LNode{
    ElementType Data;
    PtrToNode Next;
};

typedef PtrToNode Position;        //这里的位置某个结点的结点指针
typedef PtrToNode List;

List L;

//链表长度
int Length(List L);

//根据位序查找元素
ElementType FindKth(List L, int K);

//根据元素查找相应的结点
Position Find(List L, ElementType X);

//在指定位置之后插入元素
List Insert(List L, ElementType X, int i);

bool Delete(List *L, int i);

void printList(List L);




#endif

LinkList.c

#include "LinkList.h"

int Length(List L)
{
    int cnt = 0;
    List p = L;        //当前p指向第一个结点
    while (p)
    {
        cnt++;
        p = p->Next;
    
    }
    return cnt;

}

ElementType FindKth(List L, int K)
{
    Position p = L;
    int cnt = 1;
    while (p && cnt < K)
    {
        p = p->Next;
        cnt++;
    }
    if ((cnt == K) && p)
        return p->Data;
    else
        return ERROR;
}

Position Find(List L, ElementType X)
{
    Position p = L;
    while (p && p->Data != X)
        p = p->Next;
    if (p)
        return p;
    else
        return NULL;
}

List Insert(List L, ElementType X, int i)
{
    Position tmp, pre;
    tmp = (Position)malloc(sizeof(struct LNode));
    if (i == 1)
    {
        tmp->Data = X;
        tmp->Next = L;
        return tmp;
    }

    else
    {
        int cnt = 1;
        pre = L;
        while (pre && cnt < i - 1)
        {
            pre = pre->Next;
            cnt++;
        }
        if (pre == NULL || cnt != i - 1)        //如果所招结点不再L中
        {
            printf("Insert position parameter error!
");
            free(tmp);
            return L;
        }
        else
        {
            tmp->Data = X;
            tmp->Next = pre->Next;
            pre->Next = tmp;
            return L;
        }
    }
}

bool Delete(List *L, int i)
{
    Position tmp, pre;
    int cnt = 1;
    pre = *L;
    if (i == 1 && pre)
    {
        *L = (*L)->Next;        //如果这里没有传*L,而是L,那么这里的L只是实参的副本，
                                //所以如果删除并释放第一个结点后，因为实参的L还是指向第一个结点的，所以第一个结点被释放后，
                                //实参L会只想一块不知名的内存，成为野指针，所以建议使用带头结点的链表
        free(pre);
        return true;
    }
    else
    {
        while (pre && cnt < i - 1)
        {
            pre = pre->Next;
            cnt++;
        }
        if (pre == NULL || cnt != i - 1 || pre->Next == NULL)        //i出错或链表为空
        {
            printf("Delete position parameter error!
");
            return false;
        }
        else
        {
            tmp = pre->Next;
            pre->Next = tmp->Next;
            free(tmp);
            return true;
        }
    }
    
}

void printList(List L)
{
    Position p;
    p = L;
    while (p)
    {
        printf("%d ", p->Data);
        p = p->Next;
    }
    printf("
");
    return ;
}