数据结构练习题2（链表）-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_74859128/article/details/143028791

1编程实现多项式运算

多项式 1: 3x^2 + 2x + 1
多项式 2: 4x^1 + 2
多项式和: 3x^2 + 6x^1 + 3
多项式积: 12x^3 + 14x^2 + 10x^1 + 2

1多项式的定义和初始化

#include <stdio.h>
#include <stdlib.h>

#define MAX_TERM 100 // 最大项数

// 多项式结构体
typedef struct {
    int coefficient; // 系数
    int exponent;    // 指数
} Term;

// 定义多项式结构体
typedef struct {
    Term terms[MAX_TERM]; // 存储项的数组
    int  length;          // 多项式项数
} Polynomial;

// 初始化多项式
void init(Polynomial* poly) {
    poly->length = 0;
}

2打印多项式

// 打印多项式
void print(Polynomial* poly) {
    for (int i = 0; i < poly->length; i++) {
        if (i > 0 && poly->terms[i].coefficient > 0) {
            printf(" + "); // 打印加号
        }
        printf("%dx^%d", poly->terms[i].coefficient, poly->terms[i].exponent); // 打印每一项
    }
    printf("\n"); // 换行
}

3多项式运算

// 多项式求和
Polynomial add(Polynomial* p1, Polynomial* p2) {
    Polynomial result;  // 创建结果多项式
    init(&result);      // 初始化结果多项式

    int i = 0, j = 0;   // 指针，用于遍历多项式p1和p2的项
    // 进入循环，直到遍历完p1或p2
    while (i < p1->length && j < p2->length) {
        // 当p1的当前项的指数大于p2的当前项的指数
        if (p1->terms[i].exponent > p2->terms[j].exponent) {
            result.terms[result.length++] = p1->terms[i++]; // 将p1的当前项插入结果中，并移动p1指针
        } 
        // 当p1的当前项的指数小于p2的当前项的指数
        else if (p1->terms[i].exponent < p2->terms[j].exponent) {
            result.terms[result.length++] = p2->terms[j++]; // 将p2的当前项插入结果中，并移动p2指针
        } 
        // 当p1和p2的当前项的指数相等
        else {
            // 合并同类项，计算新的系数
            int sumCoefficient = p1->terms[i].coefficient + p2->terms[j].coefficient;
            // 如果合并后的系数不为零，则添加到结果中
            if (sumCoefficient != 0) {
                result.terms[result.length++] = (Term){sumCoefficient, p1->terms[i].exponent}; // 插入合并后的项
            }
            i++; // 移动p1指针
            j++; // 移动p2指针
        }
    }

    // 将p1中剩余的项添加到结果中
    while (i < p1->length) {
        result.terms[result.length++] = p1->terms[i++]; // 插入p1的剩余项
    }
    // 将p2中剩余的项添加到结果中
    while (j < p2->length) {
        result.terms[result.length++] = p2->terms[j++]; // 插入p2的剩余项
    }

    return result; // 返回求和结果
}

// 多项式乘法
Polynomial multiply(Polynomial* p1, Polynomial* p2) {
    Polynomial result; // 创建结果多项式
    init(&result);     // 初始化结果多项式

    // 遍历多项式p1的每一个项
    for (int i = 0; i < p1->length; i++) {
        // 在当前项与多项式p2的每一个项相乘
        for (int j = 0; j < p2->length; j++) {
            // 计算新项的系数和指数
            int newCoefficient = p1->terms[i].coefficient * p2->terms[j].coefficient; // 计算乘积系数
            int newExponent = p1->terms[i].exponent + p2->terms[j].exponent; // 计算新项的指数

            // 将新项插入结果多项式
            int k;
            // 在结果中查找相同指数的项
            for (k = 0; k < result.length; k++) {
                if (result.terms[k].exponent == newExponent) {
                    result.terms[k].coefficient += newCoefficient; // 如果找到了相同指数，则更新系数
                    break; // 跳出循环
                } else if (result.terms[k].exponent < newExponent) {
                    break; // 如果当前项的指数小于新项的指数，跳出循环
                }
            }

            // 如果k等于结果的长度，说明这是一个新的项
            if (k < result.length) {
                // 确保正确处理系数为零的情况
                if (result.terms[k].exponent == newExponent) {
                    // 如果已经存在该指数的项，更新系数
                    result.terms[k].coefficient += newCoefficient;
                } else {
                    // 在适当位置插入新项
                    for (int m = result.length; m > k; m--) {
                        result.terms[m] = result.terms[m - 1]; // 向后移动项
                    }
                    result.terms[k] = (Term){newCoefficient, newExponent}; // 插入新项
                    result.length++; // 更新结果的长度
                }
            } else {
                // 如果是新的项，直接插入
                result.terms[result.length++] = (Term){newCoefficient, newExponent}; // 插入新项
            }
        }
    }
    return result; // 返回乘法结果
}

4主函数

int main() {
    Polynomial p1, p2;

    // 初始化多项式 1: 3x^2 + 2x^1 + 1
    init(&p1);
    p1.terms[p1.length++] = (Term){3, 2};
    p1.terms[p1.length++] = (Term){2, 1};
    p1.terms[p1.length++] = (Term){1, 0};

    // 初始化多项式 2: 4x^1 + 2
    init(&p2);
    p2.terms[p2.length++] = (Term){4, 1};
    p2.terms[p2.length++] = (Term){2, 0};

    // 打印原始多项式
    printf("多项式 1: ");
    print(&p1);
    printf("多项式 2: ");
    print(&p2);

    // 执行多项式求和
    Polynomial sum = add(&p1, &p2);
    printf("多项式和: ");
    print(&sum);

    // 执行多项式乘法
    Polynomial product = multiply(&p1, &p2);
    printf("多项式积: ");
    print(&product);

    return 0;
}

2编写一个对单向循环链表进行遍历的算法。打印每个结点的值

单向循环链表（Singly Circular Linked List）是一种链表结构，其中每个节点指向下一个节点，最后一个节点则指向头节点，形成一个循环。要遍历这种链表并打印每个节点的值，我们需要从头部节点开始，依次访问每个节点，直到再次回到头部节点。

单向循环链表的节点定义

#include <stdio.h>
#include <stdlib.h>

// 定义节点结构
struct Node {
    int data;          // 节点的数据
    struct Node* next; // 指向下一个节点的指针
};

// 创建一个新节点并返回其指针
struct Node* createNode(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

遍历并打印单向循环链表的算法

// 打印单向循环链表的所有节点值
void printList(struct Node* head) {
    struct Node* current = head; // 当前指针，指向头节点
    
    // 如果链表为空（头节点为NULL），直接返回
    if (head == NULL) {
        printf("链表为空。\n");
        return;
    }

    // 打印节点的值，直到遍历回到头节点
    do {
        printf("%d ", current->data); // 打印当前节点的值
        current = current->next;     // 移动到下一个节点
    } while (current != head);       // 当当前节点不等于头节点时继续遍历

    printf("\n"); // 打印换行
}

主函数示例：创建一个单向循环链表并遍历

int main() {
    // 创建头节点
    struct Node* head = createNode(1);
    head->next = createNode(2); // 添加第二个节点
    head->next->next = createNode(3); // 添加第三个节点
    head->next->next->next = createNode(4); // 添加第四个节点

    // 将链表变成循环链表，最后一个节点指向头节点
    head->next->next->next->next = head;

    // 打印链表节点
    printf("链表中的值：");
    printList(head); // 遍历并打印链表中的值

    return 0;
}