cpp判断两个数的余数是否大于0，大于0则置为1

在C++中，判断两个整数相除后的余数是否大于0，可以通过取模运算符`%`来实现，并利用位运算将结果转换为布尔值（1代表真，0代表假）。下面是一个简单的函数示例：

#include <bitset>

bool isRemainderPositive(int a, int b) {
    // 取模运算得到余数
    int remainder = a % b;

    // 如果余数大于0，返回true；否则返回false
    return (remainder > 0) ? true : false;
    
    // 或者也可以更简洁地使用位运算（适用于余数非负的情况）
    // bool result = (remainder != 0);
}

int main() {
    int num1 = 10, num2 = 3;
    if (isRemainderPositive(num1, num2)) {
        std::cout << "余数大于0，置为1" << std::endl;
    } else {
        std::cout << "余数不大于0" << std::endl;
    }
    return 0;
}

这个函数会返回一个布尔值，如果余数大于0，那么`isRemainderPositive`函数返回`true`，对应的`result`会被设置为`1`；否则返回`false`，对应的是`0`。如果只需要知道结果而不是转换，可以直接使用`remainder != 0`代替。

相关问题

1.分隔链表 要求有main函数，包括create链表（参考期中考试） 给你一个头结点为 head 的单链表和一个整数 k ，请你设计一个算法将链表分隔为 k 个连续的部分。 每部分的长度应该尽可能的相等：任意两部分的长度差距不能超过 1 。这可能会导致有些部分为 null 。 这 k 个部分应该按照在链表中出现的顺序排列，并且排在前面的部分的长度应该大于或等于排在后面的长度。 返回一个由上述 k 部分组成的数组。

好的，我了解了你的要求。以下是一个可能的解决方案：

#include <iostream>
#include <vector>

using namespace std;

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

vector<ListNode*> splitListToParts(ListNode* head, int k) {
    int len = 0;
    ListNode* p = head;
    while (p != nullptr) {
        len++;
        p = p->next;
    }
    int remainder = len % k, quotient = len / k;
    vector<ListNode*> res(k, nullptr);
    p = head;
    for (int i = 0; i < k && p != nullptr; i++) {
        res[i] = p;
        int partSize = quotient + (remainder-- > 0 ? 1 : 0);
        for (int j = 0; j < partSize - 1; j++) {
            p = p->next;
        }
        ListNode* next = p->next;
        p->next = nullptr;
        p = next;
    }
    return res;
}

int main() {
    ListNode* head = new ListNode(1);
    head->next = new ListNode(2);
    head->next->next = new ListNode(3);
    head->next->next->next = new ListNode(4);
    head->next->next->next->next = new ListNode(5);
    int k = 3;
    vector<ListNode*> res = splitListToParts(head, k);
    for (ListNode* p : res) {
        while (p != nullptr) {
            cout << p->val << " ";
            p = p->next;
        }
        cout << endl;
    }
    return 0;
}

该算法的思路是先计算出链表的长度 len ，然后计算出每部分的长度 partSize ，其中 remainder 表示余数，quotient 表示商。然后将链表分割成 k 部分，每部分的长度为 partSize ，并将它们存储在一个 vector 中，最后返回该 vector。在分割链表时，我们需要使用一个指针 p 来遍历链表，并将链表从 p 处分割为两部分，将第一部分作为当前部分的头节点，并将第二部分作为下一部分的头节点。

用出++编程，并包含main函数：给你一个头结点为 head 的单链表和一个整数 k ，请你设计一个算法将链表分隔为 k 个连续的部分。 每部分的长度应该尽可能的相等：任意两部分的长度差距不能超过 1 。这可能会导致有些部分为 null 。 这 k 个部分应该按照在链表中出现的顺序排列，并且排在前面的部分的长度应该大于或等于排在后面的长度。 返回一个由上述 k 部分组成的数组。并逐句解释代码

当然，我会尽力回答你的问题。下面是满足你要求的代码：

#include <iostream>
#include <vector>
using namespace std;

// 链表节点的定义
struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

vector<ListNode*> splitListToParts(ListNode* head, int k) {
    // 先计算链表的长度
    int len = 0;
    ListNode *cur = head;
    while (cur != NULL) {
        len++;
        cur = cur->next;
    }

    // 计算每个部分的长度
    int partSize = len / k;  // 每个部分的基本长度
    int remainder = len % k;  // 长度余数，用于平均分配到每个部分
    vector<ListNode*> res;  // 存储结果的数组
    cur = head;  // 当前节点指针
    for (int i = 0; i < k; i++) {
        res.push_back(cur);  // 将当前节点作为当前部分的头节点
        int curSize = partSize + (remainder-- > 0 ? 1 : 0);  // 计算当前部分的长度
        if (cur != NULL) {
            for (int j = 1; j < curSize; j++) {
                cur = cur->next;  // 将当前节点后移，直到当前部分的最后一个节点
            }
            ListNode *next = cur->next;  // 记录当前节点的下一个节点
            cur->next = NULL;  // 将当前节点的 next 指针置空，断开链表
            cur = next;  // 将当前节点后移一位，准备处理下一部分
        }
    }

    return res;
}

// 测试代码
int main() {
    ListNode *head = new ListNode(1);
    head->next = new ListNode(2);
    head->next->next = new ListNode(3);
    head->next->next->next = new ListNode(4);
    head->next->next->next->next = new ListNode(5);
    int k = 3;
    vector<ListNode*> res = splitListToParts(head, k);
    for (int i = 0; i < res.size(); i++) {
        ListNode *cur = res[i];
        while (cur != NULL) {
            cout << cur->val << " ";
            cur = cur->next;
        }
        cout << endl;
    }
    return 0;
}

这段代码可以将一个单链表分隔为 k 个连续的部分，并返回一个由这些部分组成的数组。我们来逐句解释一下代码：

vector<ListNode*> splitListToParts(ListNode* head, int k) {
    // 先计算链表的长度
    int len = 0;
    ListNode *cur = head;
    while (cur != NULL) {
        len++;
        cur = cur->next;
    }

    // 计算每个部分的长度
    int partSize = len / k;  // 每个部分的基本长度
    int remainder = len % k;  // 长度余数，用于平均分配到每个部分
    vector<ListNode*> res;  // 存储结果的数组
    cur = head;  // 当前节点指针
    for (int i = 0; i < k; i++) {
        res.push_back(cur);  // 将当前节点作为当前部分的头节点
        int curSize = partSize + (remainder-- > 0 ? 1 : 0);  // 计算当前部分的长度
        if (cur != NULL) {
            for (int j = 1; j < curSize; j++) {
                cur = cur->next;  // 将当前节点后移，直到当前部分的最后一个节点
            }
            ListNode *next = cur->next;  // 记录当前节点的下一个节点
            cur->next = NULL;  // 将当前节点的 next 指针置空，断开链表
            cur = next;  // 将当前节点后移一位，准备处理下一部分
        }
    }

    return res;
}

首先，我们定义了一个函数 `splitListToParts`，该函数接受一个单链表的头节点 `head` 和一个整数 `k`，返回一个由 `k` 个部分组成的数组，每个部分是一个单链表。

接下来，我们用一个变量 `len` 记录链表的长度，用一个指针 `cur` 遍历整个链表，计算出链表的长度。

然后，我们计算每个部分的长度。我们先计算出每个部分的基本长度 `partSize`，即链表长度除以 `k` 的商。如果链表长度不能被 `k` 整除，就需要将余数平均分配到前面的部分中，因此我们用 `remainder` 变量记录余数，并在计算每个部分的长度时，如果余数大于 0，就将当前部分的长度加 1。

接下来，我们创建一个 `vector` 类型的变量 `res`，用于存储最终的结果。我们将当前节点指针 `cur` 初始化为头节点 `head`，然后开始循环，共循环 `k` 次，处理每个部分。

在循环中，我们先将当前节点 `cur` 添加到结果数组 `res` 中，作为当前部分的头节点。然后计算出当前部分的长度 `curSize`，根据上面的计算方法，如果余数大于 0，就将当前部分的长度加 1。

接下来，我们需要将当前节点 `cur` 后移，直到当前部分的最后一个节点。我们用一个循环将当前节点后移 `curSize-1` 次，即可找到当前部分的最后一个节点。在这个过程中，需要注意判断当前节点是否为 NULL，防止出现空指针异常。

当我们找到当前部分的最后一个节点后，我们需要将当前链表断开，将当前节点的 `next` 指针置空，这样就可以将当前部分从原链表中分离出来。然后我们将当前节点 `cur` 后移一位，准备处理下一部分。

最后，我们返回结果数组 `res`，即可得到分隔后的链表。我们在 `main` 函数中测试了一下代码的正确性。