大二C语言，比较急，各位🙏

Question

大二的C语言的设计，要求就上面这个图，设计随意，能运行就行。

Answer 1

可以先把所有数字放在第一层，遍历每一层，将“倍数”移到下一层

#include<stdio.h>
#include<malloc.h>

const char *intoutputformat = "%4d";

//定义一个整数链表，用于存放每层数字
typedef struct integerlist {
    int num;
    struct integerlist *next;
} integerList;

//定义金字塔，形式为链表的链表
typedef struct intpyramid {
    integerList *list;
    struct intpyramid * nextfloor;
} intPyramid;

//释放链表内存的函数
void deletelist(integerList **intlist) {
    integerList *p = *intlist, *q;
    while (p) {
        q = p->next;
        free(p);
        p = q;
    }
    *intlist = NULL;
}

//创建不大于n的正整数的升序链表
void creatlist(integerList **intlist, int n) {
    int i;
    integerList *p;
    if (*intlist) { //如果intlist已经指向一个链表，则将对应内存释放
        deletelist(intlist);
    }
    if (n < 1)return;
    p = *intlist = (integerList*)malloc(sizeof(integerList));
    for (i = 1; i < n; i++) {
        p->num = i;
        p->next = (integerList*)malloc(sizeof(integerList));
        p = p->next;
    }
    p->num = n;
    p->next = NULL;
}

//释放金字塔内存
void deletepyramid(intPyramid**phead) {
    intPyramid *p = *phead, *q;
    while (p) {
        q = p->nextfloor;
        deletelist(&p->list);
        free(p);
        p = q;
    }
    *phead = NULL;
}

//根据升序链表创建金字塔
void creatpyramid(intPyramid**phead, integerList*intlist) {
    intPyramid *p;
    integerList *plist, *qlist, *rlist, *nextfloortail;
    if (*phead) { //如果intlist已经指向一个金字塔，则将对应内存释放
        deletepyramid(phead);
    }
    if (!intlist)return;
    p = *phead = (intPyramid*)malloc(sizeof(intPyramid));
    p->list = intlist;
    while (1) {
        p->nextfloor = (intPyramid*)malloc(sizeof(intPyramid));
        nextfloortail = p->nextfloor->list = NULL;
        //rlist对应的num作为除数，遍历p指向的金字塔的一层
        for (rlist = p->list; rlist; rlist = rlist->next) {
            plist = rlist;
            qlist = plist->next;
            while (qlist) {
                if (qlist->num % rlist->num == 0) {
                    //条件为真时把qlist指向的节点移到下一层
                    if (nextfloortail) {
                        nextfloortail->next = qlist;
                        nextfloortail = qlist;
                    } else {
                        nextfloortail = p->nextfloor->list = qlist;
                    }
                    plist->next = qlist->next;
                    qlist->next = NULL;
                } else {
                    plist = qlist;
                }
                qlist = plist->next;
            }
        }
        if (p->nextfloor->list) { //如果下一层有数字，则循环，否则退出循环
            p = p->nextfloor;
        } else {
            free(p->nextfloor);
            p->nextfloor = NULL;
            break;
        }
    }
}

//输出链表的函数
void intlist_output(integerList* p) {
    while (p) {
        printf(intoutputformat, p->num);
        p = p->next;
    }
}

//输出金字塔的函数
void intpyramid_output(intPyramid* p) {
    while (p) {
        intlist_output(p->list);
        putchar('\n');
        p = p->nextfloor;
    }
}

//在链表中查找数字，找到时返回是第几个，未找到则返回链表数字个数的相反数
int intlist_search(integerList* p, int num) {
    int index = 0;
    while (p && p->num != num) {
        p = p->next;
        index++;
    }
    if (p) {
        return index + 1;
    } else {
        return -index;
    }
}

//在金字塔中查找数字，找到时返回是第几个，未找到则返回金字塔数字个数的相反数
int intpyramid_search(intPyramid*p, int num) {
    int index = 0, r;
    while (p) {
        r = intlist_search(p->list, num);
        if (r > 0) {
            return index + r;
        }
        index -= r;
        p = p->nextfloor;
    }
    return -index;
}

int main() {
    integerList*intlist=NULL;
    intPyramid*phead=NULL;
    int n;
    char c;
    printf("输入信息:\n");
    scanf("%d", &n);
    creatlist(&intlist, n);
    creatpyramid(&phead, intlist);
    intpyramid_output(phead);
    printf("输出排名:\n");
    while((c=getchar())==','){
        scanf("%d",&n);
        n=intpyramid_search(phead,n);
        printf(intoutputformat,n);
        putchar(',');
    }
    return 0;
}