补充编写插入功能函数和删除功能函数。并在主函数中补充代码验证算法的正确性。

#include 
#include 
#include 

#define OK   1
#define ERROR  0
#define TRUE 1
#define FALSE 0

typedef char ElemType;
typedef struct Node    /*结点类型定义*/ 
{ 
    ElemType data;
    struct Node  * next;
}Node, *LinkList;  /* LinkList为结构指针类型*/

void init_linklist(LinkList *l)/*对单链表进行初始化*/
{
    *l=(LinkList)malloc(sizeof(Node)); 
    (*l)->next=NULL;
}

void CreateFromTail( LinkList  L)
{ 
    Node *r, *s;
    char c;
    int   flag =1; /*设置一个标志，初值为1，当输入"$"时，flag为0，建表结束*/
    r=L;      /*r指针动态指向链表的当前表尾，以便于做尾插入，其初值指向头结点*/
    while(flag)         /*循环输入表中元素值，将建立新结点s插入表尾*/
    {
        c=getchar();
        if(c!='$')
        {
            s=(Node*)malloc(sizeof(Node));
            s->data=c;
            r->next=s;
            r=s;
        }
        else
        {
            flag=0;
            r->next=NULL;   /*将最后一个结点的next链域置为空，表示链表的结束*/
        }
    }   
} 

Node *Get(LinkList  L, int i)
/*在带头结点的单链表L中查找第i个结点，若找到(1≤i≤n)，则返回该结点的存储位置; 否则返回NULL*/
{  
    int j;
    Node  *p;
    p=L;
    j=0;   /*从头结点开始扫描*/ 
    while ((p->next!=NULL)&&(jnext;    /* 扫描下一结点*/
        j++;   /* 已扫描结点计数器 */
    }
    if(i == j)        
        return p;   /* 找到了第i个结点 */
    else 
        return NULL;   /* 找不到，i≤0或i>n */
}   

int main()
{
    LinkList l;
    Node *p;
    int j;
    init_linklist(&l);
    printf("请输入链表数据,以$结束!\n");
    CreateFromTail(l);
    p = l->next;
    while(p!=NULL)
    {
        printf("%c\n",p->data);
        p=p->next;
    }
    
    fflush(stdin);    
    printf("请输入要查找的结点序号:\n");
    scanf("%d",&j);
    p = Get(l,j);
    if(p!=NULL)
        printf("该结点的值为:%c\n",p->data);
    else
        printf("未找到此结点!\n");
    return 0;
}

网上现成的一大筐哦

int insert_link(Link *pHead,int pos,data_type item)
{
    //入参判断
    if(NULL == pHead)
    {
        return LINKNULL;
    }
    //创建新节点
    Link *pNew = (Link *)malloc(sizeof(Link));
    if(NULL == pNew)
    {
        perror("malloc error");
        return MALLOCERROR;
    }
    memset(pNew,0,sizeof(Link));
    //将新值赋值给新节点的数据域
    pNew->data = item;
    //根据位置向链表中插入元素
    Link *pTail = NULL;
    Link *pPre1 = NULL;
    Link *pPre2 = NULL;
    int i = 0;
    switch(pos)
    {
        //头插法
        case HEAD:
            //先保护好要插入节点后的所有节点
            if(pHead->pNext != NULL)
            {
                pNew->pNext = pHead->pNext;
            }
            //将新节点插入进去
            pHead->pNext = pNew;
            break;
        //尾删法
        case TAIL:
            //定义一个指针变量，初始化为头节点
            pTail = pHead;
            //当pTail->pNext不为空的时候
            while(pTail->pNext != NULL)
            {
                pTail = pTail->pNext;
            }
            //将新节点插入进去
            pTail->pNext = pNew;
            break;
        //中间插入
        default:
            //定义两个结构体指针变量一个指向头节点一个指向首节点
            pPre1=pHead;
            pPre2=pHead->pNext;
            while(pPre2 != NULL && i<pos-1)
            {
                pPre1=pPre2;
                pPre2=pPre2->pNext;
                i++;
            }
            //当pPre2不等于空时，移动pos-1个位置
            if(NULL == pPre2)
            {
                return EMPTY;
            }
            //保护要插入元素后的所有节点
            pNew->pNext=pPre2;
            //插入元素
            pPre1->pNext=pNew;
    }
    return OK;    
}

int delete_link(Link *pHead,int pos,data_type *pData)
{
    //入参判断
    if(NULL == pHead)
    {
        return LINKNULL;
    }
    //定义一个结构体指针变量，保存要删除的节点的首地址
    Link *pDel = NULL;
    Link *pPre = NULL;
    int i = 0;
    switch(pos)
    {
        case HEAD:
            //找到要删除的节点
            pDel = pHead->pNext;
            //头删法
            // 保存要删除的数据 
            *pData = pDel->data;
            // 保存要删除节点后的所有节点
            pHead->pNext = pDel->pNext;
            //释放pDel
            free(pDel);
            pDel = NULL;
            break;
        //尾删法
        case TAIL:
            //定义两个指针变量，一个初始化为头节点，一个初始化为首节点
            pPre = pHead;
            pDel = pHead->pNext;
            if(NULL == pDel)
            {
                return EMPTY;
            }
            //判断pDel的指针域是否为空
            while(pDel->pNext != NULL)
            {
                //两个指针同时向后移动
                pPre = pDel;
                pDel = pDel->pNext;
            }
            //保存要删除的数据
            *pData = pDel->data;
            //4.将pPre的指针域赋值为NULL
            pPre->pNext = NULL;
            //5.释放pDel
            free(pDel);
            pDel = NULL;
            break;
        //中间删除
        default:
            //定义两个指针变量，一个初始化为头节点，一个初始化为首节点
            pPre = pHead;
            pDel = pHead->pNext;            
            //当pDel不为空的情况下，移动pos-1次
            while(pDel != NULL && i < pos-1)
            {
                pPre = pDel;
                pDel = pDel->pNext;
                i++;
            }
            if(NULL == pDel)
            {
                return EMPTY;
            }
            //保存好要删除的数据
            *pData = pDel->data;
            //保护好要删除节点后的所有节点
            pPre->pNext = pDel->pNext;
            //释放pDel
            free(pDel);
            pDel = NULL;
    }
    return OK;
    
}

https://blog.csdn.net/yyyy11665/article/details/126334657

贝祖等式：

       设a，b是任意两个正整数，则存在整数s，t使得 s*a+t*b=(a,b)

编程实现（Java）：      

public class BezoutsIdentity {
              static long s;
              static long t;
              public static void main(String[] args) {
                     get_s_t(7,12);
                     System.out.println(Main.s+" "+Main.t);
              }
              public static long get_s_t(long a,long b){
                     long d=get_gcd(a,b);
                     long n=1;
                     s=s*n;
                     t=t*n;
                     return d;
              }
              public static long get_gcd(long a,long b){         //greatest Common Divisor求最大公因数
                     if (b==0) {
                            s=1;
                            t=0;
                            return a;
                     }
                     long gcd=get_gcd(b,a%b);
                     long s1=s;
                     s=t;
                     t=s1-(a/b)*t;
                     return gcd;
              }
}