编写函数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++中，全局变量head指向输入生成的单向链表的首节点，节点类型为tNode。 编写函数cnt()和add()。函数cnt()计算链表中data域为奇数的节点个数并返回。 函数add(n)的功能：如果链表中节点data域的值均不为n，则插 入一个新节点到链表的尾节点之后，新节点的data域为n。

函数cnt()的实现很简单，只需要遍历链表，对于每个节点，如果data域为奇数，计数器加1。代码如下：

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

函数add(n)的实现也比较简单，需要先遍历一遍链表，检查是否已经存在值为n的节点。如果不存在，则新建一个节点，将其插入到链表的尾部。代码如下：

void add(int n) {
    tNode* p = head;
    while (p) {
        if (p->data == n) {
            return;
        }
        if (p->next == nullptr) {
            break;
        }
        p = p->next;
    }
    tNode* newNode = new tNode(n);
    if (p) {
        p->next = newNode;
    } else {
        head = newNode;
    }
}

需要注意的是，如果链表为空，需要特殊处理。此外，函数add()中新建的节点需要手动释放，否则会导致内存泄漏。