1）    用C语言编写程序LinkList.cpp实现单链表的各种基本运算。
2）    初始化单链表L，依次从表尾插入100个整数，并按插入顺序输出这100个整数；
3）    删除单链表L中能被3整除的元素，并把剩余元素依次输出；
4）    简单修改程序，实现双向循环链表存储结构

写多少了

写了一些了。

这是我自己写的：还没有写完。我觉得应该有个show
#includestdio.h
#includestdlib.h
#includemalloc.h
typedef struct node
{
    int data;结点中的成员
    struct node next;指针
}lnode,linklist;
单链表的初始化
linklist chushilist()
{
    node l;
    l=(node )malloc(sizeof(node));
    if(l=NULL)
        printf(申请内存空间失败n);
    l-next=NULL;
    return l;
}
单链表的建立（头插法）
linklist toulist()
{
    int i;
    node l;
    l=(node )malloc(sizeof(node));分配空间
    l-next=NULL;
    int x;
    while(scanf(%d,&x)!=EOF)
    {
        for(i=100;i0;i--)
        {
        node p;
        p=(node )malloc(sizeof(node));
        p-data=x;
        p-next=l-next;
        l-next=p;
        }
    }
    return l;
}
单链表的插入（尾插法）
linklist weilist()
{
    node l;
    l=(node )malloc(sizeof(node));
    l-next=NULL;初始化一个空表
    node r;
    r=l;r始终指向终端的结点，开始时指向头结点
    int x;
    while(scanf(%d,&x)!=EOF)
    {
        for(int i=100;i0;i--)
        {
        node p;
        p=(node )malloc(sizeof(node));
        p-data=x;结点的数值域赋值
        r-next=p;
        r=p;
        }
    }
    r-next=NULL;
    return l;
}
单链表的删除，在链表中删除能被三整除的元素
linklist deletelist(linklist l,int x)
{
    node p,pre;
    p=l-next;
    while(p-data!=(x%3==0))
    {
        pre=p;
        p=p-next;
    }
    pre-next=p-next;
    free(p);
    return l;
}
 int main()
 {
     linklist list,start;
     printf(请输入单链表的数据：);
     list=toulist();
     for(start=list-next;start!=NULL;start=start-next)
         printf(%d,start-data);
     printf(n);
     printf(删除的单链表：);

 }


下面这个是查的，但是改不对。
#include<stdio.h>
#include<malloc.h>
typedef char ElemType;
typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LinkNode;
//w尾插法建立单链表
void CreateListR(LinkNode *&L, ElemType a[], int n)
{
    LinkNode *s,*r;
    L=(LinkNode *)malloc(sizeof(LinkNode));//创立头节点
    L->next=NULL;
    r=L;
    for(int i=0;i<n;i++)
    {
        s=(LinkNode *)malloc(sizeof(LinkNode));//创立新的结点
        s->data=a[i];
        r->next=s;//将节点s插入r结点之后
        r=s;
    }
    r->next=NULL;//尾结点next置空
}
//初始化线性表
void InitList(LinkNode *&L)
{
    L=(LinkNode *)malloc(sizeof(LinkNode));//创建头节点
    L->next=NULL;//将单链表置空
}
//插入
bool ListInsert(LinkNode *&L, int i, ElemType e)
{
    int j = 0;
    LinkNode *p = L, *s;                        //p指向头节点，j置为0（即头节点序号为0）
    if(i <= 0)                                    //i错误返回假
        return false;
    while(j < i - 1 && p != NULL){                //查找第i-1个节点p
        j++;
        p = p->next;
    }
    if(p == NULL)
        return false;
    else{
        //将节点s插入
        s = (LinkNode *)malloc(sizeof(LinkNode));
        s->data = e;
        s->next = p->next;
        p->next = s;
        return true;

    }

}
//输出线性表
void DispList(LinkNode *L)
{
    LinkNode *p=L->next;
    while(p!=NULL)
    {
        printf("%c",p->data);
        p=p->next;
    }
    printf("\n");
}
//删除能被3整除的元素
bool ListDelete(LinkNode *&L,int i,ElemType &e)
{
    int j=0;
    LinkNode *p=L,*q;
    if(i<=0)
        return false;
    while(j%3==0&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return false;
    else{
        q=p->next;
        if(p==NULL)
            return false;
        e=q->data;
        p->next=q->next;
        free(q);
        return true;
        }
}
//销毁线性表
void DestroyList(LinkNode *&L)
{
    LinkNode *pre = L, *p = pre->next;
    while(p != NULL)
    {
        free(pre);
        pre = p;    //pre、p同步后移一个节点
        p = pre->next;
    }
    free(pre);    //此时p为NULL、pre指向尾节点，释放它
}
int main()
{
    LinkNode *h;
    ElemType e;
    printf("初始化单链表");
    InitList(h);
    printf("依次采用尾插法插入元素");
    ListInsert(h,1,'a');
    printf("  (3)输出单链表h：");
    DispList(h);
    printf("  (10)删除h的第3个元素\n");
    ListDelete(h,3,e);
    printf("  (11)输出单链表h：");   
    DispList(h);
    printf("  (12)释放单链表h\n");
    DestroyList(h);
    return 1;
}

嗯，我看下

#include <stdio.h>
#include <malloc.h>
#include <time.h>
#include <stdlib.h>
// 单链表
struct node{
    int data;
    struct node *next;
};
// 双向链表
struct node2{
    int data;
    struct node2 *prev;
    struct node2 *next;
};
// 初始化单链表
struct node* initLink(int arr[], int len){
    if(len<1)return NULL;
    struct node *h = (struct node*)malloc(sizeof(struct node));
    h->data=arr[0];
    h->next=NULL;
    struct node *p=h;
    for(int i=1;i<len;i++){
        struct node *newNode = (struct node*)malloc(sizeof(struct node));
        newNode->data=arr[i];
        newNode->next=NULL;
        p->next=newNode;//尾插
        p=p->next;
    }
    return h;
}
// 遍历单链表
void display(struct node *h){
    printf("遍历单链表:\n");
    int cols=0;
    while(h!=NULL){
        printf("%d\t", h->data);
        h=h->next;
        printf(++cols%10==0?"\n":"");
    }
    printf("\n");
}
struct node* deleteNum(struct node*h,int mark_num){
    struct node *p=h->next;
    while(h!=NULL&&h->data%mark_num==0){// 开头被整除
        struct node *q=h->next;
        free(h);//删除节点
        h=q;
    }
    while(p!=NULL){
        if(p==NULL)break;
        if(p->next!=NULL){
            if(p->next->data%mark_num==0){//中间被整除
                struct node *q=p->next->next;
                free(p->next);//删除节点
                p->next=q;
            }
        }
        p=p->next;
    }
    return h;
}
// 单向转双向
struct node2* trans(struct node* h){
    struct node2 *h2 = (struct node2*)malloc(sizeof(struct node2));
    h2->prev=NULL;
    h2->next=NULL;
    struct node2 *p=h2;
    if(h==NULL){
        return h2;
    }
    if(h!=NULL){
        struct node2 *newNode = (struct node2*)malloc(sizeof(struct node2));
        p->data=h->data;
        h=h->next;
    }
    while(h!=NULL){
        struct node2 *newNode = (struct node2*)malloc(sizeof(struct node2));
        newNode->data=h->data;
        newNode->next=NULL;
        newNode->prev=NULL;
        p->next=newNode;
        p=p->next;
        h=h->next;
    }
    p=h2;
    while(p->next!=NULL){
        p->next->prev=p;
        p=p->next;
    }
    return h2;
}
// 遍历单链表
void display2(struct node2 *h){
    printf("遍历单链表:\n");
    int cols=10;
    
    while(h->next!=NULL){
        printf("%d\t", h->data);
        h=h->next;
        printf(++cols%10==0?"\n":"");
    }
    printf("%d\t", h->data);
    printf("\nback---\n");
    cols=0;
    while(h!=NULL){
        printf("%d\t", h->data);
        h=h->prev;
        printf(++cols%10==0?"\n":"");
    }
    printf("\n");
}
int main() {
    int len=100;
    int arr[len];
    printf("生产%d个随机数:\n",len);
    srand((unsigned)time(NULL));
    for(int i=0;i<len;i++){
        arr[i] = rand() % 100;
        printf("%d\t", arr[i]);
    }
    printf("\n");
    struct node *h = initLink(arr,len);
    display(h);
    int mark_num=3;
    h=deleteNum(h,mark_num);
    printf("删除被%d整除的数后:",mark_num);
    display(h);
    // 双向链表创建
    struct node2*h2 = trans(h);
    printf("双向链表遍历");
    display2(h2);
    printf("释放");
    while(h!=NULL){
        struct node*p=h;
        h=h->next;
        free(p);
    }
    while(h2!=NULL){
        struct node2*p=h2;
        h2=h2->next;
        free(p);
    }
    return 0;
}

生产100个随机数:
1    11    11    31    22    50    67    47    70    74    11    34    95    41    41    63    81    23    93    86    61    90    67    74    58    60    84    94    74    23    48    27    34    59    11    9    61    78    8    31    4    19    18    99    60    59    62    93    34    7    31    95    97    99    70    7    59    6    1    85    30    1    64    16    60    75    77    74    5    85    57    9    56    75    60    68    87    74    61    21    81    93    17    30    92    39    37    3    45    90    88    27    91    52    44    52    80    73    78    37   
遍历单链表:
1    11    11    31    22    50    67    47    70    74   
11    34    95    41    41    63    81    23    93    86   
61    90    67    74    58    60    84    94    74    23   
48    27    34    59    11    9    61    78    8    31   
4    19    18    99    60    59    62    93    34    7   
31    95    97    99    70    7    59    6    1    85   
30    1    64    16    60    75    77    74    5    85   
57    9    56    75    60    68    87    74    61    21   
81    93    17    30    92    39    37    3    45    90   
88    27    91    52    44    52    80    73    78    37   

删除被3整除的数后:遍历单链表:
1    11    11    31    22    50    67    47    70    74   
11    34    95    41    41    81    23    86    61    67   
74    58    84    94    74    23    27    34    59    11   
61    8    31    4    19    99    59    62    34    7   
31    95    97    70    7    59    1    85    1    64   
16    75    77    74    5    85    9    56    60    68   
74    61    81    17    92    37    45    88    91    52   
44    52    80    73    37   
双向链表遍历遍历单链表:
1    11    11    31    22    50    67    47    70    74   
11    34    95    41    41    81    23    86    61    67   
74    58    84    94    74    23    27    34    59    11   
61    8    31    4    19    99    59    62    34    7   
31    95    97    70    7    59    1    85    1    64   
16    75    77    74    5    85    9    56    60    68   
74    61    81    17    92    37    45    88    91    52   
44    52    80    73    37   
back---
37    73    80    52    44    52    91    88    45    37   
92    17    81    61    74    68    60    56    9    85   
5    74    77    75    16    64    1    85    1    59   
7    70    97    95    31    7    34    62    59    99   
19    4    31    8    61    11    59    34    27    23   
74    94    84    58    74    67    61    86    23    81   
41    41    95    34    11    74    70    47    67    50   
22    31    11    11    1   
释放

注释比较少，看不懂的可以画出来讨论

int main() {
    int len=100;
    int arr[len];//这里中括号里面的应该时常量


void display(struct node *h){
    printf("遍历单链表:\n");
    int cols=0;                //这里的cols是什么意思呢
    while(h!=NULL){
        printf("%d\t", h->data);
        h=h->next;
        printf(++cols%10==0?"\n":"");    //这句我也不太懂
    }
    printf("\n");
}

第一处你看着改吧，第二处是换行的变量，第三处三元运算符不知道你学过没
后面两处是为了控制一行打印的个数
这个看不懂也没关系，可以改成你看得懂的
主要的还是要看看链表的处理细节