1.从键盘输入20个整数，产生不带表头的单链表，并输入结点值。 2.从键盘输入1个整数，在单链表中查找该结点的位置。若找到，则显示“找到了”；否则，则显示“找不到”。 3.从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插入在对应位置上，输出单链表所有结点值，观察输出结果。 4.从键盘输入1个整数，表示欲删除结点的位置，输出单链表所有结点值，观察输出结果。 5.将单链表中值重复的结点删除，使所得的结果表中个结点值均不相同，输出单链表所有结点值，观察输出结果。 6.删除其中所有数据值为偶数的结点，输出单链表所有结点值，观察输出结果。 7.把单链表变成带表头结点的循环链表，输出循环单链表所有结点值，观察输出结果。 8.（★）将单链表分解成两个单链表A和B，使A链表中含有原链表中序号为奇数的元素，而B链表中含有原链表中序号为偶数的元素，且保持原来的相对顺序，分别输出单链表A和单链表B的所有结点值，观察输出结果。

抱歉，我作为一个语言模型无法进行实际的键盘输入和链表操作。但是我可以为你提供相应的算法代码，你可以参考它来进行实现。

1. 产生不带表头的单链表

#include <iostream>
using namespace std;

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

ListNode* createLinkedList() {
    ListNode *head = nullptr, *tail = nullptr;
    for (int i = 0; i < 20; i++) {
        int x;
        cin >> x;
        ListNode *node = new ListNode(x);
        if (head == nullptr) {
            head = tail = node;
        } else {
            tail->next = node;
            tail = node;
        }
    }
    return head;
}

2. 在单链表中查找结点位置

int findNode(ListNode *head, int x) {
    int pos = 1;
    ListNode *p = head;
    while (p != nullptr) {
        if (p->val == x) {
            cout << "找到了" << endl;
            return pos;
        }
        p = p->next;
        pos++;
    }
    cout << "找不到" << endl;
    return -1;
}

3. 在指定位置插入结点

ListNode* insertNode(ListNode *head, int pos, int x) {
    ListNode *node = new ListNode(x);
    if (pos == 1) {
        node->next = head;
        return node;
    }
    ListNode *p = head;
    for (int i = 1; i < pos - 1; i++) {
        p = p->next;
    }
    node->next = p->next;
    p->next = node;
    return head;
}

4. 删除指定位置的结点

ListNode* deleteNode(ListNode *head, int pos) {
    if (pos == 1) {
        ListNode *p = head;
        head = head->next;
        delete p;
        return head;
    }
    ListNode *p = head;
    for (int i = 1; i < pos - 1; i++) {
        p = p->next;
    }
    ListNode *q = p->next;
    p->next = q->next;
    delete q;
    return head;
}

5. 删除值重复的结点

ListNode* deleteDuplicate(ListNode *head) {
    if (head == nullptr) {
        return head;
    }
    ListNode *p = head, *q;
    while (p != nullptr) {
        q = p;
        while (q->next != nullptr) {
            if (q->next->val == p->val) {
                ListNode *t = q->next;
                q->next = t->next;
                delete t;
            } else {
                q = q->next;
            }
        }
        p = p->next;
    }
    return head;
}

6. 删除数据值为偶数的结点

ListNode* deleteEven(ListNode *head) {
    ListNode *newHead = new ListNode(-1);
    newHead->next = head;
    ListNode *p = newHead, *q;
    while (p->next != nullptr) {
        if (p->next->val % 2 == 0) {
            q = p->next;
            p->next = q->next;
            delete q;
        } else {
            p = p->next;
        }
    }
    head = newHead->next;
    delete newHead;
    return head;
}

7. 单链表变成带表头的循环链表

ListNode* toCircularList(ListNode *head) {
    if (head == nullptr) {
        return head;
    }
    ListNode *p = head;
    while (p->next != nullptr) {
        p = p->next;
    }
    p->next = head;
    return head;
}

8. 将链表分解成奇数和偶数链表

void splitList(ListNode *head, ListNode *&A, ListNode *&B) {
    ListNode *p = head, *pA = nullptr, *pB = nullptr;
    while (p != nullptr) {
        if (p->val % 2 == 1) {
            if (A == nullptr) {
                A = pA = p;
            } else {
                pA->next = p;
                pA = pA->next;
            }
        } else {
            if (B == nullptr) {
                B = pB = p;
            } else {
                pB->next = p;
                pB = pB->next;
            }
        }
        p = p->next;
    }
    if (pA != nullptr) {
        pA->next = nullptr;
    }
    if (pB != nullptr) {
        pB->next = nullptr;
    }
}

以上是相应操作的链表算法代码，你可以根据自己的需要进行修改和调整。