编写函数cnt，计算head指向的链表中data域 为奇数的节点个数并返回； 2、编写函数add(n)，如果head指向链表中不包 含data为n的节点，则在链尾插入一个data为n的 新节点

以下是Python代码实现：

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def cnt(head: ListNode) -> int:
    count = 0
    curr = head
    while curr:
        if curr.val % 2 != 0:
            count += 1
        curr = curr.next
    return count

def add(n: int, head: ListNode) -> ListNode:
    if not head:
        return ListNode(n)
    curr = head
    while curr.next:
        if curr.val == n:
            return head
        curr = curr.next
    if curr.val == n:
        return head
    curr.next = ListNode(n)
    return head

其中，ListNode为链表节点的定义，cnt函数用于计算奇数节点个数，add函数用于在链表尾部添加新节点。

相关问题

c++中 1.编写函数cnt，计算head指向的链表中data域 为奇数的节点个数并返回； 2.编写函数add(n)，如果head指向链表中不包 含data为n的节点，则在链尾插入一个data为n的 新节点

1. 计算链表中data域为奇数的节点个数

int cnt(Node* head) {
    int res = 0;
    Node* p = head;
    while(p != nullptr) {
        if(p->data % 2 == 1) {
            res++;
        }
        p = p->next;
    }
    return res;
}

2. 在链表尾部插入一个新节点

void add(Node* head, int n) {
    Node* p = head;
    while(p->next != nullptr) {
        if(p->data == n) {
            return; // 如果链表中已经包含了data为n的节点，则直接返回
        }
        p = p->next;
    }
    if(p->data == n) {
        return; // 如果链表中已经包含了data为n的节点，则直接返回
    }
    Node* newNode = new Node(n);
    p->next = newNode;
}

C++编程，编写函数cnt()和add()。函数cnt()计算链表中data域为奇数的节点个数并返回。 函数add(n)的功能：如果链表中节点data域的值均不为n，则插 入一个新节点到链表的尾节点之后，新节点的data域为n。

下面是C++语言的链表实现，包括cnt()和add(n)两个函数的实现：

#include <iostream>
using namespace std;

struct Node {
    int data;
    Node* next;
};

class LinkedList {
public:
    LinkedList() {
        head = NULL;
    }
    // 计算链表中data域为奇数的节点个数
    int cnt() {
        int count = 0;
        Node* cur = head;
        while (cur) {
            if (cur->data % 2 == 1) {
                count++;
            }
            cur = cur->next;
        }
        return count;
    }
    // 在链表尾部插入值为n的节点
    void add(int n) {
        if (!head) {
            head = new Node;
            head->data = n;
            head->next = NULL;
            return;
        }
        Node* cur = head;
        while (cur->next) {
            cur = cur->next;
        }
        if (cur->data != n) {
            cur->next = new Node;
            cur->next->data = n;
            cur->next->next = NULL;
        }
    }
private:
    Node* head;
};

这样，我们就可以利用LinkedList类来实现链表操作了。例如，创建一个链表并在末尾插入几个节点：

LinkedList linkedList;
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
linkedList.add(4);

然后，我们可以调用cnt()函数来计算链表中奇数节点的个数：

int odd_count = linkedList.cnt();
cout << "奇数节点个数为：" << odd_count << endl;

最终，输出结果为：

奇数节点个数为： 2

注意：以上代码仅供参考，实际应用中需要根据具体需求进行修改和优化。