数据结构上机测试题超全合集【C语言描述算法】(完整可编译代码，含运行结果截图)

已于 2024-03-30 19:11:11 修改
阅读量5.7k 收藏 169
点赞数 34
分类专栏： 数据结构 文章标签： 数据结构 算法 c语言 c++
于 2021-06-21 12:42:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lei20172017/article/details/118082185
版权

完整试题以及代码可以在我的小程序上搜索查看。
在这里插入图片描述

1、 编写算法，将二个升序链表在原表空间内归并成一个升序链表。

/*   1、    编写算法，将二个升序链表在原表空间内归并成一个升序链表。*/
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 50
typedef int ElementType;
typedef struct LNode {
   
    ElementType data;
    struct LNode *Next;
} LNode,*List;


/*尾插法建立链表L */
void createListR(LNode *&L) {
   
    LNode *s, *r;   //s用来指向新申请的结点，r始终指向L的终端结点
    ElementType x;
    L = (LNode *)malloc(sizeof(struct LNode));//申请L的头结点空间
    L->Next = NULL;
    r = L;//r指向头结点，因为此时头结点就是终端结点
    printf("\n(尾插法)请依次输入链表元素(以-999作结束标志)：\n");
    while(1) {
    //循环申请结点来接收输入缓冲区中的元素，直到遇到-999结束接收
        scanf("%d",&x);
        if(x == -999) break;
        s = (LNode *)malloc(sizeof(struct LNode));//s指向新申请的结点
        s->data = x;//用新申请的结点来接收输入的元素
        r->Next = s;//用r来接纳新结点
        r = r->Next;//r指向终端结点，以便于接纳下一个到来的结点
    }
    r->Next = NULL;//输入缓冲区的所有元素都已经装入链表L中，L的终端结点的指针域置位NULL，L建立完成
}


/*打印链表*/
void printList(LNode *L) {
   
    LNode *p = L->Next;
//    printf("\n链表元素依次为：");
    while(p != NULL) {
   
        printf("%d ",p->data);
        p = p->Next;
    }
    printf("\n");
}

//以下是题目算法
void merge_up(LNode *&A, LNode *B) {
   
    LNode *p = A->Next;
    LNode *q = B->Next;
    LNode *s;
    A->Next = NULL;
    free(B);
    s = A;
    while(p !=NULL && q != NULL) {
   
        if(p->data <= q->data) {
   
            s->Next = p;
            p = p->Next;
            s = s->Next;
        } else {
   
            s->Next = q;
            q = q->Next;
            s = s->Next;
        }
    }
    s->Next = NULL;
    //以下两个if语句将还有剩余结点的链表链接在A的尾部
    if(p != NULL) s->Next = p;
    if(q != NULL) s->Next = q;
}


int main(){
   
    LNode *La,*Lb;
    printf("1、编写算法，将二个升序链表在原表空间内归并成一个升序链表。\n");
    printf("尾插法创建链表La(元素升序)：");
    createListR(*&La);
    printf("尾插法创建链表Lb(元素升序)：");
    createListR(*&Lb);
    merge_up(La, Lb);
    printf("归并成一个升序链表(仍使用原表的存储空间)：");
    printList(La);
    system("pause");
    return 0;
}

在这里插入图片描述

2、 编写算法，将二个升序链表在原表空间内归并成一个降序链表。

/* 2、    编写算法，将二个升序链表在原表空间内归并成一个降序链表。*/
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 50
typedef int ElementType;
typedef struct LNode {
   
    ElementType data;
    struct LNode *Next;
} LNode,*List;


/*尾插法建立链表L */
void createListR(LNode *&L) {
   
    LNode *s, *r;   //s用来指向新申请的结点，r始终指向L的终端结点
    ElementType x;
    L = (LNode *)malloc(sizeof(struct LNode));//申请L的头结点空间
    L->Next = NULL;
    r = L;//r指向头结点，因为此时头结点就是终端结点
    printf("\n(尾插法)请依次输入链表元素(以-999作结束标志)：\n");
    while(1) {
    //循环申请结点来接收输入缓冲区中的元素，直到遇到-999结束接收
        scanf("%d",&x);
        if(x == -999) break;
        s = (LNode *)malloc(sizeof(struct LNode));//s指向新申请的结点
        s->data = x;//用新申请的结点来接收输入的元素
        r->Next = s;//用r来接纳新结点
        r = r->Next;//r指向终端结点，以便于接纳下一个到来的结点
    }
    r->Next = NULL;//输入缓冲区的所有元素都已经装入链表L中，L的终端结点的指针域置位NULL，L建立完成
}


/*打印链表*/
void printList(LNode *L) {
   
    LNode *p = L->Next;
//    printf("\n链表元素依次为：");
    while(p != NULL) {
   
        printf("%d ",p->data);
        p = p->Next;
    }
    printf("\n");
}

//题目要求的算法
void merge_down(LNode *&A, LNode *B) {
   
    LNode *p = A->Next;
    LNode *q = B->Next;
    LNode *s;
    A->Next = NULL;
    free(B);
    while(p !=NULL && q != NULL) {
   
        //下边的if else语句体现了链表的头插法
        if(p->data <= q->data) {
   
            s = p;
            p = p->Next;
            s->Next = A->Next;
            A->Next = s;
        } else {
   
            s = q;
            q = q->Next;
            s->Next = A->Next;
            A->Next = s;
        }
    }
    //下边两个循环是和求递增归并序列不同的地方，必须将剩余元素逐个插入C的头部才能得到最终的递减序列
    while(p != NULL) {
   
        s = p;
        p = p->Next;
        s->Next = A->Next;
        A->Next = s;
    }
    while(q != NULL) {
   
        s = q;
        q = q->Next;
        s->Next = A->Next;
        A->Next = s;
    }
}


int main(){
   
    LNode *La,*Lb;
    printf("2、    编写算法，将二个升序链表在原表空间内归并成一个降序链表。\n");
    printf("创建链表La(元素升序)：");
    createListR(*&La);
    printf("创建链表Lb(元素升序)：");
    createListR(*&Lb);
    merge_down(La, Lb);
    printf("归并成一个降序链表(仍使用原来两个链表的存储空间)：");
    printList(La);
    system("pause");
    return 0;
}

在这里插入图片描述

3、 编写算法，用顺序存储结构实现二个升序集合的A=A－B运算。

/*3、    编写算法，用顺序存储结构实现二个升序集合的A=A－B运算。*/
#include<stdio.h>
#include <stdlib.h>
#define maxsize 10
typedef struct sqlist {
   
    int data[maxsize];
    int length;
} sqlist,*lnode;


void create(lnode &l,int a[],int n) {
   
    l=(sqlist*)malloc(sizeof(sqlist));
    for(int i=0; i<n; i++) {
   
        l->data[i]=a[i];
    }
    l->length=n;
}


void del(lnode &l,int n) {
   
    int i;
    for(i=n; i<l->length-1; i++) {
   
        l->data[i]=l->data[i+1];
    }
    l->length--;
}


void listminus(lnode &a,lnode b) {
   
    int m=a->length,n=b->length;
    int i,j,k=0;
    for(i=0; i<m; i++) {
   
        for(j=k; j<=n; j++) {
   
            if(a->data[i]==b->data[j]) {
   
                del(a,i);
                k=j+1;
            }
        }
    }
}

void show(lnode l) {
   
    int i;
    for(i=0; i<l->length; i++)
        printf("%d ",l->data[i]);
}

int main() {
   
    printf("3、    编写算法，用顺序存储结构实现二个升序集合的A=A－B运算。\n");
    lnode A,B;
    int a[10],b[10],i;
    printf("input six number: ");
    for(i=0; i<6; i++) {
   
        scanf("%d",&a[i]);
    }
    printf("input six number: ");
    for(i=0; i<6; i++) {
   
        scanf("%d",&b[i]);
    }
    create(A,a,6);
    create(B,b,6);
    listminus(A,B);
    printf("\nA = A-B :\n");
    show(A);
    printf("\n");
    system("pause");
    return 0;
}

在这里插入图片描述

4、 编写算法，用单链表实现二个升序集合A和B的差集存放在集合C，即C=A－B运算，要求C中元素递增有序。

/*4、    编写算法，用单链表实现二个升序集合A和B的差集存放在集合C，即C=A－B运算，要求C中元素递增有序。*/
#include <stdio.h>
#include <stdlib.h>
typedef struct Node {
   
    int data;
    struct Node* next;
} LNode, * LinkList;

void CreateList(LNode* A) {
    // 创建单循环链表，返回链表头
    LNode* p;
    int i, n;
    printf("输入链表的元素个数:");
    scanf("%d", &n);//输入集合元素的个数
    printf("输入链表元素（按升序）:");
    for (i = 0; i < n; i++) {
   
        p = (LNode*)malloc(sizeof(LNode));
        scanf("%d", &p->data);//输入每个元素，空格隔开
        p->next = A->next;
        A->next = p;
        A = p;
    }
}


void PrintList(LNode* head) {
   
    LNode* p = head->next;
    while (p) {
   
        printf("%d ", p->data);
        p = p->next;
    }
}
void listASC(LNode* A, LNode* B, LNode* C) {
     //用单链表实现二个升序集合A和B的差集存放在集合C，即C=A－B运算，要求C中元素递增有序
    LNode* pa, * pb, * pc;
    int count;
    pa = A->next;
    pc = C->next;
    while (pa) {
   
        count = 0;
        pb = B->next;
        while (pb) {
   
            if (pa->data == pb->data)
                count++;
            pb = pb->next;
        }


        if (count == 0) {
   
            pc = (LNode*)malloc(sizeof(LNode));
            pc->data = pa->data;
            pc->next = C->next;
            C->next = pc;
            C = pc;
        }
        pa = pa->next;
    }
}


void listDESC(LNode* A, LNode* B, LNode* C) {
     //用单链表实现二个升序集合A和B的差集存放在集合C，即C=A－B运算，要求C中元素递减有序
    LNode* pa, * pb, * pc, * p;
    int count;
    pa = A->next;
    pc = C->next;
    while (pa) {
   
        count = 0;
        pb = B->next;
        while (pb) {
   
            if (pa->data == pb->data)
                count++;
            pb = pb->next;
        }


        if (count == 0) {
   
            pc = (LNode*)malloc(sizeof(LNode));
            pc->data = pa->data;
            pc->next = C->next;
            C->next = pc;
        }
        pa = pa->next;
    }
}


int main() {
   
    printf("4、    编写算法，用单链表实现二个升序集合A和B的差集存放在集合C，即C=A－B运算，要求C中元素递增有序。\n");
    LNode* A, * B, * C;
    A = (LNode*)malloc(sizeof(LNode));
    A->next = NULL;
    B = (LNode*)malloc(sizeof(LNode));
    B->next = NULL;
    C = (LNode*)malloc(sizeof(LNode));
    C->next = NULL;
    CreateList(A);
    CreateList(B);
    listASC(A, B, C);  
    printf("\nC = A-B :\n");
    PrintList(C);
    printf("\n");
    system("pause");
    return 0;
}

在这里插入图片描述

5、 编写算法，用单链表实现二个升序集合A和B的差集存放在集合C，即C=A－B运算，要求C中元素递减有序。

/*5、    编写算法，用单链表实现二个升序集合A和B的差集存放在集合C，即C=A－B运算，要求C中元素递减有序。*/
#include <stdio.h>
#include <stdlib.h>
typedef struct Node {
   
    int data;
    struct Node* next;
} LNode, * LinkList;
void CreateList(LNode* A) {
    // 创建单循环链表，返回链表头
    LNode* p;
    int i, n;
    printf("输入链表的元素个数:");
    scanf("%d", &n);//输入集合元素的个数
    printf("输入链表元素（按升序）:");
    for (i = 0; i < n; i++) {
   
        p = (LNode*)malloc(sizeof(LNode));
        scanf("%d", &p->data);//输入每个元素，空格隔开
        p->next = A->next;
        A->next = p;
        A = p;
    }
}
void PrintList(LNode* head) {
   
    LNode* p = head->next;
    while (p) {
   
        printf("%d ", p->data);
        p = p->next;
    }
}
void listASC(LNode* A, LNode* B, LNode* C) {
     //用单链表实现二个升序集合A和B的差集存放在集合C，即C=A－B运算，要求C中元素递增有序
    LNode* pa, * pb, * pc;
    int count;
    pa = A->next;
    pc = C->next;
    while (pa) {
   
        count = 0;
        pb = B->next;
        while (pb) {
   
            if (pa->data == pb->data)
                count++;
            pb = pb->next;
        }


        if (count == 0) {
   
            pc = (LNode*)malloc(sizeof(LNode));
            pc->data = pa->data;
            pc->next = C->next;
            C->next = pc;
            C = pc;
        }
        pa = pa->next;
    }
}
void listDESC(LNode* A, LNode* B, LNode* C) {
     //用单链表实现二个升序集合A和B的差集存放在集合C，即C=A－B运算，要求C中元素递减有序
    LNode* pa, * pb, * pc, * p;
    int count;
    pa = A->next;
    pc = C->next;
    while (pa) {
   
        count = 0;
        pb = B->next;
        while (pb) {
   
            if (pa->data == pb->data)
                count++;
            pb = pb->next;
        }
        if (count == 0) {
   
            pc = (LNode*)malloc(sizeof(LNode));
            pc->data = pa->data;
            pc->next = C->next;
            C->next = pc;
        }
        pa = pa->next;
    }
}


int main() {
   
    printf("5、    编写算法，用单链表实现二个升序集合A和B的差集存放在集合C，即C=A－B运算，要求C中元素递减有序。\n");
    LNode* A, * B, * C;
    A = (LNode*)malloc(sizeof(LNode));
    A->next = NULL;
    B = (LNode*)malloc(sizeof(LNode));
    B->next = NULL;
    C = (LNode*)malloc(sizeof(LNode));
    C->next = NULL;
    CreateList(A);
    CreateList(B);
    printf("\nC = A-B :\n");
    listDESC(A, B, C);
    PrintList(C);
    printf("\n");
    system("pause");
    return 0;
}

在这里插入图片描述

6、 编写算法，将一单链表就地逆置。

/*6、    编写算法，将一单链表就地逆置。*/
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 50
typedef int ElementType;
typedef struct LNode {
   
    ElementType data;
    struct LNode *Next;
} LNode,*List;


/*尾插法建立链表L */
void createListR(LNode *&L) {
   
    LNode *s, *r;   //s用来指向新申请的结点，r始终指向L的终端结点
    ElementType x;
    L = (LNode *)malloc(sizeof(struct LNode));//申请L的头结点空间
    L->Next = NULL;
    r = L;//r指向头结点，因为此时头结点就是终端结点
    printf("\n(尾插法)请依次输入链表元素(以-999作结束标志)：\n");
    while(1) {
    //循环申请结点来接收输入缓冲区中的元素，直到遇到-999结束接收
        scanf("%d",&x);
        if(x == -999) break;
        s = (LNode *)malloc(sizeof(struct LNode));//s指向新申请的结点
        s->data = x;//用新申请的结点来接收输入的元素
        r->Next = s;//用r来接纳新结点
        r = r->Next;//r指向终端结点，以便于接纳下一个到来的结点
    }
    r->Next = NULL;//输入缓冲区的所有元素都已经装入链表L中，L的终端结点的指针域置位NULL，L建立完成
}


/*打印链表*/
void printList(LNode *L) {
   
    LNode *p = L->Next;
//    printf("\n链表元素依次为：");
    while(p != NULL) {
   
        printf("%d ",p->data);
        p = p->Next;
    }
    printf("\n");
}


/*解法一:将头结点摘下，然后从第一结点开始，依次插入到头结点的后面(头插法建立单链
表)，直到最后一个结点为止，这样就实现了链表的逆置
*/
LNode * Reverse_1 (LNode *L) {
   //L是带头结点的单链表，本算法将L就地逆置
    LNode *p, *r;//p为工作指针，r为p的后继，以防断链
    p=L->Next;//从第一个元素结点开始
    L->Next=NULL;//先将头结点L的Next域置为NULL
    while (p!=NULL) {
   //依次将元素结点摘下
        r=p->Next;//暂存P的后继
        p->Next=L->Next;//将P结点插入到头结点之后
        L->Next=p;
        p=r;
    }
    return L;
}




/*解法二 ：假设pre、p和r指向3个相邻的结点，如下图所示。假设经过若干操作后，*pre 之前的;
结点的指针都已调整完毕，它们的Next都指向其原前驱结点。现在令*p结点的Next域指向
*pre结点，注意到一旦调整指针的指向后，*p 的后继结点的链就会断开，为此需要用r来指向
原*p的后继结点。处理时需要注意两点:一是在处理第一个结点时，应将其Next域置为NULL,
而不是指向头结点(因为它将作为新表的尾结点);二是在处理完最后一个结点后，需要将头结
点的指针指向它。
*/
LNode * Reverse_2 (LNode *L) {
   //依次遍历线性表L,并将结点指针反转
    LNode *pre, *p=L->Next, *r=p->Next;
    p->Next=NULL;//处理第一个结点
    while(r!=NULL) {
   //r为空，则说明p为最后一个结点
        pre=p;//依次继续遍历
        p=r;
        r=r->Next;
        p->Next=pre;//指针反转
    }
    L->Next=p;//处理最后一个结点
    return L;
}


int main(){
   
    LNode *La;
    printf("6、    编写算法，将一单链表就地逆置。");
    createListR(*&La);
    La = Reverse_1 (La);
    printf("链表就地逆转后：");
    printList(La);
    system("pause");
    return 0;
}

在这里插入图片描述

7、 编写算法，在一个双链表的第i个元素前插入一个元素。

/*7、    编写算法，在一个双链表的第i个元素前插入一个元素。*/
#include <stdio.h>
#include <stdlib.h>
typedef int ElemType;
typedef struct line {
   
    struct line * prior;
    ElemType data;
    struct line * next;
}line;


line * insertLine(line * head, int data, int add) {
   
    //新建数据域为data的结点
    line * temp = (line*)malloc(sizeof(line));
    temp->data = data;
    temp->prior = NULL;
    temp->next = NULL;
    //插入到链表头，要特殊考虑
    if (add == 1) {
   
        temp->next = head;
        head->prior = temp;
        head = temp;
    }
    else {
   
        int i = 0;
        line * body = head;
        //找到要插入位置的前一个结点
        for (i = 1; i < add - 1; i++) {
   
            body = body->next;
            if (body == NULL) {
   
                printf("插入位置有误\n");
                break;
            }
        }
        if (body) {
   
            //判断条件为真，说明插入位置为链表尾
            if (body->next == NULL) {
   
                body->next = temp;
                temp->prior = body;
            }
            else {
   
                body->next->prior = temp;
                temp->next = body->next;
                body->next = temp;
                temp->prior = body;
            }
        }
    }
    return head;
}


//输出链表的功能函数
void display(line * head) {
   
    line * temp = head;
    while (temp) {
   
        if (temp->next == NULL) {
   
            printf("%d\n", temp->data);
        }
        else {
   
            printf("%d-", temp->data);
        }
        temp = temp->next;
    }
}


line* initLine(line * head) {
   
    int i = 0;
    line * list = NULL;
    head = (line*)malloc(sizeof(line));
    head->prior = NULL;
    head->next = NULL;
    head->data = 1;
    list = head;
    for (i = 2; i <= 10; i++) {
   
        line * body = (line*)malloc(sizeof(line));
        body->prior = NULL;
        body->next = NULL;
        body->data = i;
        list->next = body;
        body->prior = list;
        list = list->next;
    }
    return head;
}


int main() {
   
    ElemType x;
    int i;
    printf("7、    编写算法，在一个双链表的第i个元素前插入一个元素。\n");
    line * head = NULL;
    printf("初始链表为：\n");
    head = initLine(head);
    display(head);
    printf("在表中第 i 的位置插入新元素 x  (input i and x)：\n");
    scanf("%d %d",&i,&x);
    head = insertLine(head, x, i);
    display(head);
    system("pause");
    return 0;
}

在这里插入图片描述

8、 编写算法，删除一个双链表的第i个元素。

/*8、    编写算法，删除一个双链表的第i个元素。*/
#include <stdio.h>
#include <stdlib.h>
typedef int ElemType;
typedef struct line {
   
    struct line * prior;
    ElemType data;
    struct line * next;
} line;


//删除函数，其中，pos 表示要删除结点在双链表中的位置
line *Del_ith(line * p, int pos) {
   
    int i = 0;
    line * temp = p;
    //遍历到被删除结点
    for (i = 1; i < pos; i++) {
   
        temp = temp->next;
        if (temp == NULL) {
   
            printf("删除位置有误！\n");
            break;
        }
    }
    if (temp) {
   
        temp->prior->next = temp->next;
        temp->next->prior = temp->prior;
        free(temp);
//        return p;
    }
    return p;
}


//输出链表的功能函数
void display(line * head) {
   
    line * temp = head;
    while (temp) {
   
        if (temp->next == NULL) {
   
            printf("%d\n", temp->data);
        } else {
   
            printf("%d-", temp->data);
        }
        temp = temp->next;
    }
}


line* initLine(line * head) {
   
    int i = 0;
    line * list = NULL;
    head = (line*)malloc(sizeof(line));
    head->prior = NULL;
    head->next = NULL;
    head->data = 1;
    list = head;
    for (i = 2; i <= 10; i++) {
   
        line * body = (line*)malloc(sizeof(line));
        body->prior = NULL;
        body->next = NULL;
        body->data = i;
        list->next = body;
        body->prior = list;
        list = list->next;
    }
    return head;
}


int main() {
   
    int i;
    printf("8、    编写算法，删除一个双链表的第i个元素。\n");
    line * head = NULL;
    printf("初始链表为：\n");
    head = initLine(head);
    display(head);
    printf("删除一个双链表的第i个元素(input i)：\n");
    scanf("%d",&i);
    head = Del_ith(head,i);
    display(head);
    system("pause");
    return 0;
}

在这里插入图片描述

9、 编写算法，删除一升序单链表中所有值相同的多余元素，释放被删结点空间。

/*9、    编写算法，删除一升序单链表中所有值相同的多余元素，释放被删结点空间。*/
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 50
typedef int ElementType;
typedef struct LNode {
   
    ElementType data;
    struct LNode *Next;
} LNode,*List;
/*尾插法建立链表L */
void createListR(LNode *&L) {
   
    LNode *s, *r;   //s用来指向新申请的结点，r始终指向L的终端结点
    ElementType x;
    L = (LNode *)malloc(sizeof(struct LNode));//申请L的头结点空间
    L->Next = NULL;
    r = L;//r指向头结点，因为此时头结点就是终端结点
    printf("\n(尾插法)请依次输入链表元素(以-999作结束标志)：\n");
    while(1) {
    //循环申请结点来接收输入缓冲区中的元素，直到遇到-999结束接收
        scanf("%d",&x);
        if(x == -999) break;
        s = (LNode *)malloc(sizeof(struct LNode));//s指向新申请的结点
        s->data = x;//用新申请的结点来接收输入的元素
        r->Next = s;//用r来接纳新结点
        r = r->Next;//r指向终端结点，以便于接纳下一个到来的结点
    }
    r->Next = NULL;//输入缓冲区的所有元素都已经装入链表L中，L的终端结点的指针域置位NULL，L建立完成
}
/*打印链表*/
void
最低0.47元/天 解锁文章
X.CloudX
关注
  • 34
    点赞
  • 踩
  • 169
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
数据结构 上机测试题 汇总
blanKey的博客
12-15 7136
1、 编写算法，将二个升序链表在原表空间内归并成一个升序链表。#include <stdio.h> #include <string.h> #include <iostream> #include <queue> #include <math.h> #include <stdlib.h> using namespace std;typedef struct linklist { int
数据结构上机实验答案
11-17
◆1.16② 试写一算法，如果三个整数X，Y和Z 的值不是依次非递增的，则通过交换，令其为 非递增。 要求实现下列函数： void Descend(int &x, int &y, int &z); /* 按从大到小顺序返回x，y和z的值 */ void Descend(int &x, int &y, int &z) /* 按从大到小顺序返回x，y和z的值 */ { int temp; if(x<y) {temp=x;x=y;y=temp;} if(y=temp) y=temp; else{y=x;x=temp;} } } 1.17③ 已知k阶裴波那契序列的定义为 f0=0, f1=0, ..., fk-2=0, fk-1=1; fn=fn-1+fn-2+...+fn-k, n=k,k+1,... 试编写求k阶裴波那契序列的第m项值的函数算法， k和m均以值调用的形式在函数参数表中出现。 要求实现下列函数： Status Fibonacci(int k, int m, int &f); /* 如果能求得k阶斐波那契序列的第m项的值f，则返回OK；*/ /* 否则（比如，参数k和m不合理）返回ERROR */ Status Fibonacci(int k, int m, int &f) /* 求k阶斐波那契序列的第m项的值f */ { int temp[200],i,j,sum; if(k<2||m<0) return ERROR; if(m<k-1) f=0; else if(m==k-1) f=1; else { for(i=0;i<=k-2;i++) temp[i]=0; temp[k-1]=1; //初始化 for(i=k;i<=m;i++) //求出序列第k至第m个元素的值 { sum=0; for(j=i-k;j<=i-1;j++) sum+=temp[j]; temp[i]=sum; } f=temp[m]; } return OK; }
2024西工大数据结构理论上机作业（头歌 C）
最新发布
annesede的博客
03-16 2974
已完结~
《数据结构》上机实验题目
dikaerhanshua的博客
10-10 748
本部分将给各位学弟学妹们分享《数据结构》的上机部分实验题目，已经将一些CSP的题目删除（各位应该可以在网上找到CSP更好的解答吧），更全的实验题目和解答可以私信博主，也可以在资源栏目下载数据结构的源代码，帮助各位在这门课获取更高分数。
c语言数据结构上机实验pdf,《数据结构与算法 C语言版》—— 2.5上机实验
weixin_29495899的博客
05-19 359
本节书摘来自华章出版社《数据结构与算法 C语言版》一 书中的第2章，第2.5节，作者：徐凤生，更多章节内容可以访问云栖社区“华章计算机”公众号查看。2.5上机实验实验1编写一个程序，实现顺序表的各种基本运算，并在此基础上设计一个主程序完成以下功能：1)初始化顺序表L。2)依次采用尾插法或头插法插入元素a，b，c，d，e。3)输出顺序表L。4)输出顺序表L的长度。5)判断顺序表L是否为空。6)输出顺...
数据结构c语言版上机作业,数据结构上机答案(c语言版)
weixin_35779506的博客
05-16 473
数据结构上机答案实习一：1、编写一个读入一个字符串，把它存入一个链表，并按相反的次序打印的程序。2、设有一个单位的人员工资有如下信息：name、department、 base pay、allowance、total。现从键盘输入一组人员工资数据并将它们存储到名为paydata的文件中；再从paydata取出工资数据并给每个人的base pay增加100元，增加后将工资数据显示于屏幕(每行1人)。...
数据结构与算法上机题目及答案
10-20
数据结构上机的参考题目以及优质代码，有兴趣的同学可下载作为参考
数据结构上机实验题及源代码
05-06
这是我们数据结构实验课上的题目还有答案代码，有需要的可以参考一下哈！
数据结构与算法实验程序严蔚敏C语言版源程序源代码
12-21
数据结构与算法是计算机科学的基础，对于理解和设计高效的软件至关重要。严蔚敏教授的《数据结构》一书是该领域的经典教材，它深入浅出地介绍了各种数据结构和算法，并提供了许多实践性的实验和习题。这个压缩包包含...
BIT C语言程序设计课程上机编程AC代码（含期末考试上机题代码）作为上一个文件的补充
06-05
9. **算法与数据结构**：可能包含一些基础的数据结构实现，如链表、栈、队列、树等，以及基础的排序和搜索算法。 10. **AC自动测评系统**：理解在自动测评系统中，代码如何被测试，如何调试代码以满足所有测试用例...
数据结构题库与答案 （C语言版）
11-11
数据结构题库与答案（C语言版） 清华大学出版社 严蔚敏 吴伟明
数据结构实验考试题.docx
10-25
数据结构实验考试题.docx
数据结构上机考试试题（C++语言版）
12-30
顺序方式存储的线性表， 动态链接方式存储的线性表， 动态链接结构存储的二叉树， 选择排序的算法，
C语言上机五十题（已附答案）
06-24
9. **算法与数据结构**：虽然C语言本身不直接支持数据结构，但考生需要掌握常见的数据结构，如链表、栈、队列、树等，以及相关的排序和查找算法，如冒泡排序、快速排序、二分查找等。 10. **上机考试规范**：除了...
计算机二级c语言上机题库
04-07
9. **上机考试特定要求**：熟悉考试环境，例如如何在规定的时间内完成代码编写、编译、运行和调试，以及如何提交程序。 通过反复练习题库中的上机试题，考生可以不断提升对C语言的理解和应用能力，增强实际编程经验...
C语言程序设计题自动评分算法的研究.pdf
12-25
目前，大多数C语言上机考试系统的程序设计题评分主要依赖于结果比对法，即比较考生程序运行的结果与标准答案是否一致来决定分数。然而，这种方法的局限在于它忽略了程序的编写质量、结构和逻辑，无法全面评价学生的...
c语言实现数据结构与算法的上机真题,数据结构与算法课程C语言上机考试题—2011.docx...
weixin_36014846的博客
05-20 287
1、从键盘输入 10 个整数，用冒泡法对这 10 个数排序(由小到大)后输出2、从键盘输入 10 个整数，用选择法对这 10 个数排序(由大到小)后输出。3、对于一个自然数， 如果该数的所有因子之和正好等于该数， 则该数称为完数。 统计 1000 以内的完数个数。4、编写主函数和一个函数 int diff(int year, int m1, int d1, int m2, int d2) 。( 1...
2015数据结构上机考试题解
dihangmeng9104的博客
06-22 175
#include<cstdio> #define inf 0x3f3f3f3f const int maxn=10000; using namespace std; int n,m,q; int a[maxn+10]; int bs(int x){ int l=0,r=n-1; while(l<=r){ ...
数据结构上机题——二叉树
小新
12-11 673
1.判断一个二叉树是否为完全二叉树 思路：设置一个标志位，当遇到一个空节点时，将标志位为修改；当后面在遇到有效节点并且标志位被修改时，则该二叉树不是完全二叉树。 template bool BinaryTree::JudgeTree1() { BinaryTreeNode* pointer = root; ArrayQueue&amp;lt;BinaryTreeNode* &amp;gt; queue(100);...
1. 简答题 从键盘输入一个字符串和一个字符，从字符串中删除制定的字符。
03-24
可以使用字符串的replace方法来删除指定的字符，代码如下： ``` string = input("请输入一个字符串：") char = input("请输入要删除的字符：") new_string = string.replace(char, "") print("删除后的字符串为：", new_string) ``` 这段代码首先从键盘输入一个字符串和一个字符，然后使用replace方法将字符串中所有的指定字符替换为空字符串，最后输出删除后的字符串。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值