数据结构Online Judge第二章题目(C语言版)

最新推荐文章于 2024-06-17 19:44:05 发布
最新推荐文章于 2024-06-17 19:44:05 发布
阅读量212 收藏 2
点赞数 1
分类专栏： 数据结构学习记录 文章标签： 数据结构 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_70911939/article/details/129869390
版权

文章为作者记录学习过程，小白一枚，各路大佬多多提建议，感激不尽

题目

前言

本文是作者在学习数据结构时写在课程OJ的代码，在OJ上运行答案正确，编译器版本为GCC5.4，如有不足还望指正。

一、2.11-顺序表插入元素

设顺序表 va 中的数据为递增有序。写一个算法，将x插入到顺序表的适当位置，保证有序性。

输入： 输入分为两行，第一行是 va 顺序表，每个元素按空格分隔，第二行是 x 的值。
顺序表中的元素最多为 100 个，所有元素的值均大于 0，元素为整型。

输出： 输出插入 x 后，va 的结果

输入示例：

1 3 4 6 45 56
20

输出示例：

1 3 4 6 20 45 56

代码：

/* 设顺序表va中的数据为递增有序。写一个算法，将x插入到顺序表的适当位置，保证有序性。*/
#include <stdio.h>
#include <stdlib.h>

void main()
{
    int x, c, len;
    int *va;
    x = c = len = 0;
    va = (int *)malloc((len + 2) * sizeof(int));

    do {
        scanf("%d", &va[len++]);
    } while ((c = getchar()) != '\n');
    len--;
    scanf("%d", &x);

    if (x > va[len])va[len + 1] = x;
    else if (x < va[0]) {
        for (int k = len + 1; k >= 1; k--)
            va[k] = va[k - 1];
        va[0] = x;
    }
    else {
        for (int k = 0; k <= len - 1; k++) {
            if (x >= va[k] && x < va[k + 1]) {
                for (int j = len + 1; j >= k + 2; j--)
                    va[j] = va[j - 1];
                va[k + 1] = x;
                break;
            }
        }
    }

    for (int j = 0; j <= len + 1; j++)
        printf("%d ", va[j]);
    printf("\n");
}

二、2.12-顺序表比较

设 A = ( a 1 , . . . , a m ) A=(a_1,...,a_m) A=(a1​,...,am​) 和 B = ( b 1 , . . . , b n ) B=(b_1,...,b_n) B=(b1​,...,bn​) 均为顺序表， A ′ A' A′ 和 B ′ B' B′ 分别为 A A A 和 B B B 中除去最大共同前缀后的子表（例如， A = ( x , y , y , z , x , z ) A=(x,y,y,z,x,z) A=(x,y,y,z,x,z)， B = ( x , y , y , z , y , x , x , z ) B=(x,y,y,z,y,x,x,z) B=(x,y,y,z,y,x,x,z)，则两者中最大的共同前缀为 ( x , y , y , z ) (x,y,y,z) (x,y,y,z)，在两表中除去最大共同前缀后的子表分别为 A ′ = ( x , z ) A'=(x,z) A′=(x,z) 和 B ′ = ( y , x , x , z ) B'=(y,x,x,z) B′=(y,x,x,z)。若 A ′ = B ′ = N U L L A'=B'=NULL A′=B′=NULL，则 A = B A=B A=B；若 A ′ = N U L L A'=NULL A′=NULL，而 B ′ ≠ N U L L B'\neq NULL B′=NULL，或者两者均不为 N U L L NULL NULL，且 A ′ A' A′ 的首元小于 B ′ B' B′ 的首元，则 A < B A<B A<B；否则 A > B A>B A>B。试写一个比较 A , B A,B A,B 大小的算法。（请注意，在算法中，不要破坏原表 A A A 和 B B B，并且，也不一定先求得 A ′ A' A′ 和 B ′ B' B′ 才进行比较）。

输入： 输入为两行，分别代表 A A A 和 B B B 中的元素，以逗号分开。每个顺序表最多 100 100 100 个元素。

输出： 输出 A A A 和 B B B 的比较结果， 0 0 0 代表 A = B A=B A=B， 1 1 1 代表 A < B A<B A<B， 2 2 2 代表 A > B A>B A>B

输入示例1：

a,b,c,d
a,b,c,d,e

输出示例1：

1

输入示例2：

a,w,s
a,h,l

输出示例2：

2

代码：

/* 顺序表比较 */
#include <stdio.h>
#include <stdlib.h>

int main()
{
    char *A, *B;
    int len_A, len_B, c;
    len_A = len_B = c = 0;
    A = (char *)malloc((len_A + 1) * sizeof(char));
    B = (char *)malloc((len_B + 1) * sizeof(char));

    do {
        scanf("%c", &A[len_A++]);
    } while ((c = getchar()) != '\n');
    len_A--;
    do {
        scanf("%c", &B[len_B++]);
    } while ((c = getchar()) != '\n');
    len_B--;

    int i = 0;
    for (i = 0; i <= len_A && i <= len_B && A[i] == B[i]; i++);
    i--;
    if (i == len_A && i < len_B) {
        printf("1\n"); return 0;
    }
    else if (i == len_B && i < len_A) {
        printf("2\n"); return 0;
    }
    else if (i == len_A && i == len_B){
        printf("0\n"); return 0;
    }
    else {
        if (A[i + 1] < B[i + 1]) {
            printf("1\n"); return 0;
        }
        else {
            printf("2\n"); return 0;
        }
    }
}

三、2.15-链表合并

已知指针 h a ha ha 和 h b hb hb 分别指向两个单链表的头结点，并且已知两个链表的长度分别为 m m m 和 n n n。试写一算法将这两个链表连接在一起（即令其中一个表的首元节点连在另一个表的最后一个节点之后），假设指针 h c hc hc 指向连接后的链表的头结点，并要求算法以尽可能短的时间完成链接运算。

输入： 输入包括三行，第一行是两个链表的长度m和n，第二行和第三行分别为链表ha和hb中的元素，以空格分隔。

输出： 输出合并后的链表hc，元素以空格分隔。

输入示例：

5 3
1 2 3 4 5
1 2 3

输出示例：

1 2 3 1 2 3 4 5

代码：

/* 已知指针ha和hb分别指向两个单链表的头结点，并且已知两个链表的长
*  度分别为m和n。试写一算法将这两个链表连接在一起（即令其中一个表
*  的首元节点连在另一个表的最后一个节点之后），假设指针hc指向连接
*  后的链表的头结点，并要求算法以尽可能短的时间完成链接运算。*/
#include <stdio.h>
#include <stdlib.h>

typedef struct Lnode {
    int data;
    struct Lnode* next;
} Lnode, LinkedList;

void main()
{
    LinkedList* ha, * hb, * hc, * p;
    int n1 = 0, n2 = 0;
    ha = (LinkedList*)malloc(sizeof(Lnode));
    hb = (LinkedList*)malloc(sizeof(Lnode));
    hc = (LinkedList*)malloc(sizeof(Lnode));
    p = (LinkedList*)malloc(sizeof(Lnode));
    ha->next = p;

    scanf("%d %d", &n1, &n2); getchar();
    for (int i = 0; i < n1; i++) {
        scanf("%d", &p->data); getchar();
        p->next = (LinkedList*)malloc(sizeof(Lnode));
        p = p->next;
    }
    hb->next = p;
    for (int i = 0; i < n2; i++) {
        scanf("%d", &p->data); getchar();
        p->next = (LinkedList*)malloc(sizeof(Lnode));
        p = p->next;
    }

    hc->next = hb->next;
    p = hb->next;
    for (int i = 0; i < n2-1; i++) {
        p = p->next;
    }
    p->next = ha->next;
    for (int i = 0; i < n1-1; i++) {
        p = p->next;
    }

    p = hc->next;
    for (int i = 0; i < n1 + n2; i++) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

四、2.18-链表删除元素

试写一算法，在无头节点的动态单链表上实现线性表操作 D E L E T E ( L , i ) DELETE(L,i) DELETE(L,i)。

输入： 输入包含两行，第一行是链表中的元素，第二行表示需要删除的第 i i i 个元素， i i i 从 0 0 0 开始计数；

输出： 输出删除后的链表元素，若删除后，链表不包含元素，则输出 N U L L NULL NULL。

输入示例：

1 2 3 4 5
4

输出示例：

1 2 3 4

代码：

/* 试写一算法，在无头节点的动态单链表上实现线性表操作 DELETE(L,i)。*/
#include <stdio.h>
#include <stdlib.h>

typedef struct Lnode
{
    int data;
    struct Lnode *next;
} Lnode, LinkedList;
extern void DELETE(LinkedList *L, int i);

void main()
{
    int c = 0, len = 0, i = 0;
    LinkedList *L, *p;
    L = (LinkedList *)malloc(sizeof(Lnode));
    p = (LinkedList *)malloc(sizeof(Lnode));
    L = p;
    do {
        scanf("%d", &p->data);
        p->next = (LinkedList *)malloc(sizeof(Lnode));
        p = p->next;
        len++;
    } while ((c = getchar()) != '\n');
    len--;
    scanf("%d", &i);
    if (i > len) {
        printf("Error: The LinkedList is not as long as %d!", i);
    }
    else 
        DELETE(L, i);
    if (len == 0 || i == 0){
        printf("NULL");
    }
    p = L;
    for (int j = 0; j < len; j++){
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

void DELETE(LinkedList *L, int i)
{
    LinkedList *p;
    p = L;
    for(int j = 0; j < i-1; j++){
        p = p->next;
    }
    p->next = p->next->next;
}

五、2.19-链表删除指定范围的元素

已知线性表中的元素以递增有序排列，并以单链表为存储结构。试写一高效算法，删除表中所有值大于 m i n k mink mink 且小于 m a x k maxk maxk 的元素（若表中存在这样的元素），同时释放被删节点的空间。

注意： m i n k mink mink 和 m a x k maxk maxk 是给定的两个参变量，他们的值可以和表中的元素相同，也可以不同。

输入： 输入包含两行，第一行是链表中的元素，以空格分隔；第二行分别为 m i n k mink mink 和 m a x k maxk maxk 两个元素，以空格分隔。

输出： 输出最后的链表中的元素。

输入示例：

1 2 3 4 5 8 12 15 16 22
6 18

输出示例：

1 2 3 4 5 22

代码：

/* 已知线性表中的元素以递增有序排列，并以单链表为存储结构。试写一
*  高效算法，删除表中所有值大于mink且小于maxk的元素（若表中存在
*  这样的元素），同时释放被删节点的空间。注意：mink和maxk是给定
*  的两个参变量，他们的值可以和表中的元素相同，也可以不同。*/
#include <stdio.h>
#include <stdlib.h>

typedef struct Lnode {
    int data;
    struct Lnode *next;
} Lnode, LinkedList;

void main()
{
    int c = 0, mink = 0, maxk = 0;
    LinkedList* L, * p;
    L = (LinkedList*)malloc(sizeof(Lnode));
    p = (LinkedList*)malloc(sizeof(Lnode));
    L->next = p; L->data = 0;
    do {
        scanf("%d", &p->data);
        p->next = (LinkedList*)malloc(sizeof(Lnode));
        p = p->next;
        L->data++;
    } while ((c = getchar()) != '\n');//读取链表

    scanf("%d %d", &mink, &maxk);
    p = L->next;
    while (p->data > mink && p->data < maxk) {
        L->next = p->next;
        L->data--;
        free(p);
        p = L->next;
    }//查询位于首端需要删除的的元素

    LinkedList *tmp;
    for (int i = 1; i <= L->data; i++) {
        if (p->next->data > mink && p->next->data < maxk) {
            tmp = p->next;
            p->next = p->next->next;
            free(tmp);
            L->data--;
            i--;
        }//查询剩余需要删除的元素
        else 
            p = p->next;
    }
    
    p = L->next;
    for (int j = 0; j < L->data; j++) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

六、2.22-链表就地逆置

试写一算法，实现单链表的就地逆置。

输入： 输入为给定链表的所有元素，以逗号分隔。

输出： 输出为链表逆置后的结果，以逗号分隔。

输入示例：

s,a,s,f,w,s,a,d,a,S

输出示例：

S,a,d,a,s,w,f,s,a,s

代码：

/* 试写一算法，实现单链表的就地逆置 */
#include <stdio.h>
#include <stdlib.h>

typedef struct Lnode {
    char data;
    struct Lnode* next;
} Lnode, LinkedList;

int main()
{
    int i = 0, c = 0;
    LinkedList* L, * p;
    L = (LinkedList*)malloc(sizeof(Lnode));
    p = (LinkedList*)malloc(sizeof(Lnode));
    L->next = p; L->data = 0;
    do {
        scanf("%c", &p->data);
        p->next = (LinkedList*)malloc(sizeof(Lnode));
        p = p->next;
        L->data++;
    } while ((c = getchar()) != EOF && c != '\n');//输入链表

    p = L->next;
    char tmp1, tmp2;
    for (int i = 0; i < (int)(L->data) / 2; i++) {
        if (i) p = p->next;
        tmp1 = p->data;
        for (int j = 1; j < L->data - 2 * i; j++) {
            p = p->next;
        }
        tmp2 = p->data; p->data = tmp1;
        p = L->next;
        for (int j = 0; j < i; j++) {
            p = p->next;
        }
        p->data = tmp2;
    }//就地逆置输入的链表

    p = L->next;
    for (int j = 0; j < L->data - 1; j++) {
        printf("%c,", p->data);
        p = p->next;
    }
    printf("%c\n", p->data);//打印逆置操作完成的链表
    return 0;
}

七、2.29-修改链表

已知 A A A， B B B 和 C C C 为三个递增有序的线性表，现要求对 A A A 表做如下操作：删去那些既在 B B B 表中出现又在 C C C 表中出现的元素。试对顺序表编写实现上述操作的算法。

输入： 输入包含三行，分别为 A 、 B 、 C A、B、C A、B、C 三个线性表中的元素，以逗号分隔。

输出： 输出操作之后的A表中的元素。

输入示例：

a,b,c,d,e,f,g
b,e,g,h,h
c,e,g,h

输出示例：

a,b,c,d,f

代码：

/* 已知A，B和C为三个递增有序的线性表，现要求对A表做如下操作：删去
*  那些既在B表中出现又在C表中出现的元素。试对顺序表编写实现上述操
*  作的算法。*/
#include <stdio.h>
#include <stdlib.h>

int main()
{
    int len_A = 0, len_B = 0, len_C = 0;
    char* A, * B, * C;
    A = (char*)malloc((len_A + 1) * sizeof(char));
    B = (char*)malloc((len_B + 1) * sizeof(char));
    C = (char*)malloc((len_C + 1) * sizeof(char));

    int c = 0;
    do {
        scanf("%c", &A[len_A++]);
    } while ((c = getchar()) != '\n');
    do {
        scanf("%c", &B[len_B++]);
    } while ((c = getchar()) != '\n');
    do {
        scanf("%c", &C[len_C++]);
    } while ((c = getchar()) != '\n' && c != EOF);

    for (int k = 0; k < len_C; k++) {
        int j;
        for (j = 0; j < len_B; j++) {
            if (B[j] == C[k]) {
                for (int i = 0; i < len_A; i++) {
                    if (A[i] == B[j]) {
                        for (int m = i; m < len_A; m++)
                            A[m] = A[m + 1];
                        len_A--;
                        i--;
                    }
                }
            }
        }
    }

	if(len_A) {
	    for (int i = 0; i < len_A - 1; i++) {
	        printf("%c,", A[i]);
	    }
	    printf("%c\n", A[len_A - 1]);
	    return 0;
	}
	else {
	  	printf("\n");
	    return 0;
	}
}

八、2.38-双向循环链表访问

设有一双向循环链表，每个节点中除有 p r i o r , d a t a prior,data prior,data 和 n e x t next next 三个域外，还增设了一个访问频度域 f r e q freq freq。在链表被启用之前，频度域 f r e q freq freq 的值均初始化为 0 0 0，而每当对链表进行一次 L O C A T E ( L , x ) LOCATE(L,x) LOCATE(L,x) 的操作后，被访问的节点（即元素值等于 x x x 的节点）中的频度域 f r e q freq freq 的值便增 1 1 1，同时调整链表中节点之间的次序，使其按访问频度非递增的次序顺序排列，以便始终保持被频繁访问的节点总是靠近表头结点。编写符合上述要求的 L O C A T E LOCATE LOCATE 操作的算法。

输入： 输入包含三行，第一行是链表中的元素个数，第二行是链表中的元素，第三行包含所有被访问的元素。

输出： 顺序输出从表头节点开始的链表中的元素。

注意：如果有多个元素的访问次数相同，需要按照访问次序，将先访问到的元素放在前面。

输入示例：

10
1 2 3 4 5 6 7 8 9 10
1 2 2 2 3 4 5 5 4 10 9

输出示例：

2 4 5 1 3 10 9 6 7 8

代码：

/* 设有一双向循环链表，每个节点中除有prior,data和next三个域外，还增设
*  了一个访问频度域freq。在链表被启用之前，频度域freq的值均初始化为0，
*  而每当对链表进行一次LOCATE(L,x)的操作后，被访问的节点（即元素值等
*  于x的节点）中的频度域freq的值便增1，同时调整链表中节点之间的次序，
*  使其按访问频度非递增的次序顺序排列，以便始终保持被频繁访问的节点总是
*  靠近表头结点。编写符合上述要求的LOCATE操作的算法。*/
#include <stdio.h>
#include <stdlib.h>
#define OK      1
#define ERROR   0

typedef int Elemtype;
typedef int Status;

typedef struct ADTList
{
    Elemtype data;
    struct ADTList* prior;
    struct ADTList* next;
    int freq;
} Lnode, LinkedList;

extern Status InitList(LinkedList** L);
extern Status LOCATE(LinkedList* L, int x);
extern Status collate(LinkedList** L, int position);
extern Status PrintList(LinkedList* L);

int main()
{
    int c = 0, i = 0;
    LinkedList* L;
    InitList(&L);
    int *x;
    x = (int *)malloc(100*sizeof(int));
    do {
        scanf("%d", &x[i++]);
    } while ((c = getchar()) != '\n');
    i--;
    for (int j = i; j >= 0; j--) {
        collate(&L, LOCATE(L, x[j]));
    }
    PrintList(L);
    return 0;
}

//从输入读取数据并写入双向循环链表 L
Status InitList(LinkedList** L)
{
    int c = 0;
    *L = (LinkedList*)malloc(sizeof(Lnode));
    LinkedList* p;
    p = (LinkedList*)malloc(sizeof(Lnode));
    (*L)->next = p;//创建第一个结点
    (*L)->data = 0; (*L)->freq = 0;
    p->prior = (*L);

    scanf("%d", &(*L)->data); getchar();//输入链表长度
    for (int i = 0; i < (*L)->data - 1; i++) {
        scanf("%d", &p->data); getchar();
        p->next = (LinkedList*)malloc(sizeof(Lnode));
        p->next->prior = p;
        p->freq = 0;
        p = p->next;
    }
    scanf("%d", &p->data); getchar();//输入链表数据
    p->freq = 0;
    p->next = (*L); (*L)->prior = p;//首尾连接
    return OK;
}

Status LOCATE(LinkedList* L, int x)
{
    Lnode* p; p = L->next;
    int i = 1;
    do {
        if (p->data == x) {
            p->freq++;
            return i;//返回查找到的元素的位置
        }
        p = p->next; i++;
    } while (p != L);
    return ERROR;//链表中不含要查找的元素
}

Status collate(LinkedList** L, int position)
{
    Lnode* p, * q;
    p = (*L)->next;
    for (int i = 1; i < position; i++)p = p->next;//将 p 移动到需要的 position 处
    p->next->prior = p->prior;
    p->prior->next = p->next;//将该处的结点剪除
    q = (*L)->next;
    for (int i = 1; i < (*L)->data && q->freq > p->freq; i++)
        q = q->next;//将 q 移动到需要插入的位置
    p->prior = q->prior;
    p->next = q;
    q->prior->next = p;
    q->prior = p;//将 p 插入
    return OK;
}

Status PrintList(LinkedList* L)
{
    LinkedList* p;
    p = L->next;
    for (int j = 0; j < L->data - 1; j++) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("%d\n", p->data);//打印操作完成的链表
    return OK;
}

九、2.41-稀疏多项式求导

试以循环链表作稀疏多项式的存储结构，编写求其导函数的算法，要求利用原多项式中的节点空间存放其导函数（多项式），同时释放所有无用（被删）节点。

稀疏多项式中采用的循环链表存储结构 L i n k e d P o l y LinkedPoly LinkedPoly 定义为：

typedef struct PolyNode{
  PolyTerm data;
  Struct PolyNode *next;
} PolyNode, *PolyLink;

typedef PolyLink LinkedPoly;

输入： 输入为给定的多项式。

输出： 输出为求导之后的结果，按照多项式中每一项的幂次由高到低排列。如果导数为 0 0 0，则输出 0 0 0。

输入示例1：

- 2x + 4x^2 + 2x^3 + 3x^3 + 2x + 3x^2 - 3x^10

输出示例1：

- 30x^9 + 15x^2 + 14x

输入示例2：

3x^2 + 4

输出示例2：

6x

提示：

注意要化简指数相同的项

注意输入输出中加减号的前后有空格，参见样例。如果第一项的系数是负数，则负号前面没有空格，后面有空格，参见样例。

代码：

/* 试以循环链表作稀疏多项式的存储结构，编写求其导函数的算法，要求利用原多项式中的节点空
*  间存放其导函数（多项式），同时释放所有无用（被删）节点 */
#include <stdio.h>
#include <stdlib.h>
#define OK      1
#define ERROR   0

typedef struct {
    char signal;//符号
    int coefficient;//系数
    int exponent;//指数
} PolyTerm;

typedef struct PolyNode {
    PolyTerm data;
    struct PolyNode* next;
} PolyNode, PolyLink;

typedef PolyLink LinkedPoly;

extern int InitList(PolyLink** L);
extern int MergeList(PolyLink** L);
extern int Derivation(PolyLink** L);
extern int PrintList(PolyLink* L);

void main()
{
    PolyLink* L;
    L = (PolyLink*)malloc(sizeof(PolyNode));
    InitList(&L);
    MergeList(&L);
    Derivation(&L);
    PrintList(L);
}

//将输入的多项式转化为链表
int InitList(PolyLink** L)
{
    char c = '0';
    PolyLink* p, * q;
    p = (PolyLink*)malloc(sizeof(PolyNode));
    q = (PolyLink*)malloc(sizeof(PolyNode));
    (*L)->next = p;

    do {
        c = getchar();
        if (c == '+' || c == '-') {
            p->data.signal = c;
            getchar();
            c = getchar();
            if (c == 'x')
                p->data.coefficient = 1;
            else if (c >= '0' && c <= '9') {
                p->data.coefficient = 0;
                do {
                    p->data.coefficient = p->data.coefficient * 10 + c - '0';
                } while ((c = getchar()) != 'x' && c != ' ' && c != '\n');
            }
            else
                return ERROR;
        }
        else if (c == 'x') {
            p->data.signal = '+';
            p->data.coefficient = 1;
        }
        else if (c >= '0' && c <= '9') {
            p->data.signal = '+';
            p->data.coefficient = 0;
            do {
                p->data.coefficient = p->data.coefficient * 10 + c - '0';
            } while ((c = getchar()) != 'x' && c != ' ' && c != '\n');
        }
        else
            return ERROR;
        if (c != 'x')
            p->data.exponent = 0;
        else if ((c = getchar()) == '^') {
            scanf("%d", &p->data.exponent);
            c = getchar();
        }
        else
            p->data.exponent = 1;
        if (p->data.signal == '-')
            p->data.coefficient = -p->data.coefficient;
        p->next = (PolyLink*)malloc(sizeof(PolyNode));
        q = p;
        p = p->next;
    } while (c != '\n');
    free(p);
    q->next = (*L);
    return OK;
}

//合并多项式中的同类项并重新排列
int MergeList(PolyLink** L)
{
    PolyLink* p, * q, * t;
    p = (*L)->next;
    q = *L;
    while (p->next != (*L)) {
        if (p->next->data.exponent > q->next->data.exponent) {
            t = p->next;
            p->next = t->next;
            t->next = q->next;
            q->next = t;
            q = (*L);
        }//将 p->next 移动到 q->next 前
        else if (p->next->data.exponent == q->next->data.exponent) {
            q->next->data.coefficient += p->next->data.coefficient;
            t = p->next;
            p->next = t->next;
            free(t);
            if (q->next->data.coefficient < 0)
                q->next->data.signal = '-';
            else if (q->next->data.coefficient > 0)
                q->next->data.signal = '+';
            else {
                q->next = q->next->next;
                p = q;
            }
            q = (*L);
        }//合并 p->next 与 q->next 并删除 p->next
        else {
            q = q->next;
            if (q == p) {
                p = p->next;
                q = (*L);
            }
        }
    }
}

//求导
int Derivation(PolyLink** L)
{
    LinkedPoly* p;
    p = (*L)->next;

    while (p != (*L)) {
        if (p->data.exponent != 0)
            p->data.coefficient *= p->data.exponent--;
        else
            p->data.coefficient = p->data.exponent = 0;
        p = p->next;
    }
    return OK;
}

//打印存储多项式的链表
int PrintList(PolyLink* L)
{
    PolyLink* p;
    p = L->next;
    if (p == L)printf("0");
    if (p->data.signal == '+' && p->data.exponent != 0 && p->data.coefficient != 0) {
        printf("%dx", p->data.coefficient);
        if (p->data.exponent != 1)
            printf("^%d ", p->data.exponent);
        else
            printf(" ");
        p = p->next;
    }
    else if (p->data.signal == '+' && p->data.exponent == 0) {
        printf("%d\n", p->data.coefficient);
        return OK;
    }
    else if (p->data.signal == '-') {
        p->data.coefficient = -p->data.coefficient;
        if (p->data.coefficient != 0)
            printf("- ");
        printf("%d", p->data.coefficient);
        if (p->data.exponent != 0) {
            printf("x");
            if (p->data.exponent != 1)
                printf("^%d", p->data.exponent);
        }
        printf(" ");
        p = p->next;
    }

    for (; p != L; p = p->next) {
        if (p->data.coefficient < 0) {
            p->data.coefficient = -p->data.coefficient;
            p->data.signal = '-';
        }
        if (p->data.exponent != 0) {
            printf("%c %dx", p->data.signal, p->data.coefficient);
            if (p->data.exponent != 1)
                printf("^%d ", p->data.exponent);
            else
                printf(" ");
        }
        else if (p->data.exponent == 0 && p->data.coefficient != 0)
            printf("%c %d ", p->data.signal, p->data.coefficient);
    }
    printf("\n");
    return OK;
}

总结

第二章学习后，我已经开始有意识地使用教材中给出的结构解题，同时也把各种数据结构地基本操作实现总结了出来，以后也会发布在博客里。

Jun from a nut shell
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OnlineJudge-OJ最头疼的输入输出问题
肖申克的权力游戏
08-31 1444
OnlineJudge输入输出问题 通常来说OJ对于每道题里面有.in和.out文件，分别表示测试数据的输入和输出。如果某些编程题的所有数据都只做在一个.in和一个.out中，这样就会变成多组测试了，所以需要提交的代码中循环处理。 其实这个问题可以避免，就是编程题后台每个样例做一组对应的.in和.out文件，这样就变成单组测试，代码就不需要循环处理，但是平时练习的题目质量不一，这个问题都会出现。 ...
Online Judge（在线判题系统）+源代码
12-05
Online Judge系统（简称OJ）是一个在线的判题系统。用户可以在线提交程序多种程序（如C、C++、Pascal）源代码，系统对源代码进行编译和执行，并通过预先设计的测试数据来检验程序源代码的正确性。欢迎下载，内含源...
ACM: 基本得输入输出
weixin_30821731的博客
05-31 92
使用c/c++中的输入输出函数是完成操作最基本的知识。 一、利用c语言处理输入和输出 1、输入： 在C语言中输入中stdin指针表示标准的输入，scanf默认读取的就是stdin指向的输入，在acm中我们可能需要不断的测试，最好将stdin重定向到某一个文件，这样可以方便调试，使用方法如下。 freopen("iniflename","r",stdin); 该函数依次指定了输入文...
数据结构习题集作业代码（第二章）
LeoJAM的博客
05-18 789
数据结构习题集第二章部分作业代码
线性表---顺序表
qq_43216283的博客
06-14 317
(1)顺序表: 本质上就是数组，但是，可以动态增长，并且要求顺序表里面存储的数据必须是从左往右连续的.(2)我们可以看到数组和顺序表其实是很相似的，那么使用数组和顺序表有什么区别呢？数组和顺序表都是数据结构中的基础数据结构，它们的实现方式和特点略有不同。实现方式不同数组是一段连续的内存空间，这段内存空间的大小在创建数组时确定，数组中的每个元素都可以通过下标访问，访问和操作元素的时间复杂度均为 O(1)。数组的实现足够简单，不需要额外的指针变量，但是容量不能动态扩展。
Online Judge(OJ)平台输入输出的C、C++、Java语言的一般形式
不断学习
03-30 351
输入输出输入输出 输入 输出
数据结构Online Judge第一章题目(C语言版)
weixin_70911939的博客
03-31 376
数据结构Online Judge第一章题目(C语言版)
数据结构Online Judge第三章题目(C语言版)
weixin_70911939的博客
03-31 212
数据结构Online Judge第三章题目(C语言版)
数据结构C语言版 严蔚敏
LX200384的博客
06-03 507
因此，虽然不同的存储结构会影响数据的访问效率和操作方式，但逻辑结构是指数据元素之间的逻辑关系，是独立于具体存储方式的。数据的逻辑结构是通过抽象描述数据元素之间的关系，而物理结构则是指具体的存储方式。确切地说，数据的逻辑结构是独立于计算机实际存储方式的，描述了数据元素之间的逻辑关系。抽象数据类型的定义仅取决于它的一组逻辑特性，而与在计算机内部如何表示和实现无关，即不论其内部结构如何变化，只要它的数学特性不变，都不影响其外部使用。数据的逻辑结构是从逻辑关系上描述数据，他与数据的存储无关，是独立于计算机的。
UVa Online Judge 所有题目PDF题面（合并版）
02-07
自己整理的UVa所有题目的PDF题面，可根据目录中的Volume快速跳转（与UVa官网一致）。 题目共4965题，PDF共8380页，可能会出现打开较慢的问题。 关于某个题目所在位置的判断方法： 题号除了后两位的其他数字构成...
青岛大学开源 Online Judge
11-03
青岛大学开源 Online Judge | QQ群 496710125 。。。。。
OUC Online Judge部分题目答案（C）
03-16
OUC OJ平台的题库部分习题答案，C语言版本，共82道题，几乎都是通过平台测试的，少量未通过的有标注。 压缩包内文件为txt文件，文件名为对应的题目名，部分是在网上搜索借鉴的，部分为作者原创。 warning：本文件仅...
pku1273.rar_online judge
09-22
北大 online judge 1273 源码
数据结构-绪论
pyc68的博客
06-17 463
本篇文章先介绍数据结构的研究内容，然后再介绍如何去理解数据结构，着重介绍表示数据结构关系的逻辑结构和存储结构（物理结构）。
数据结构-树的性质
WinterXJujube的博客
06-09 275
树是一个有限数据元素的集合，当数据的量为0时，称为空树。在一个非空树T中，最上方的结点没有前驱结点，称为根节点。在一个数据量大于1的树中，除了根节点之外的其余数据元素可以被分为m个互不相交的集合T1,T2,T3等。其中每一个集合T都可以看作一个单独的树，称为整个树的子树。树拥有层级结构，而这种层级结构由递归实现。从根节点开始，根节点为第一层。经过一次递归得到的结点称为第二层，以此类推。而如果同一层的节点之间互相连通，则不成为树结构。
初识数据结构-B树
LeoLei8060的博客
06-17 375
B树是一种多路搜索树（即每个节点可以有多个子节点）。在B树中，每个节点可以包含多个键（和相应的值）以及指向其子节点的指针。B树通过重新分布键值和拆分节点来保持平衡，从而确保树的高度保持较低。
嵌入式学习——数据结构（单向无头链表）——day46
qq_47798402的博客
06-17 98
它不仅包括数据元素的存储方式，还包括数据元素之间的关系，以及对数据进行操作的方法和算法。数据结构的选择和设计直接影响算法的效率和程序的性能，是计算机科学与编程中非常重要的基础。它衡量的是算法的执行时间随输入规模的变化情况，通常用大O记号表示，如O(n)、O(log n)等。3. 散列存储（哈希存储）将数据元素的存储位置与关键码之间建立确定对应关系从而实现查找的存储方式。顺序表、链式表、顺序栈、链式栈、顺序队列、链式队列、二叉树、哈希表。1. 线性结构（一对一）表、数组、链表、队列、栈。
Redis-数据结构-跳表详解
最新发布
喻师傅的学习笔记
06-17 697
Redis跳表详解
online judge
07-27
对了，Online Judge（在线评测系统）是一个用于评测和执行程序代码的平台。它可以接受用户提交的代码，并根据预先设定的测试数据进行评测，输出程序的运行结果或者错误信息。通过在线评测系统，用户可以测试和验证...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值