使用CPP对任意输入的一组数据，建立一个递增有序的单链表。 将单链表拆分成两个单链表，其中一个全为奇数，另一个全为偶数（尽量利用原存储空间）。 用递增有序的链表A、B表示两个集合，设计算法求它们的并集。 删除递增有序单链表中的重复元素。 求单循环链表中所有结点的最大值、最小值以及平均值。 判断双循环链表是否对称。

1. 使用CPP对任意输入的一组数据，建立一个递增有序的单链表。

可以使用链表的插入排序来实现。具体步骤如下：

1）首先创建一个空链表，将第一个元素插入到链表中。

2）从第二个元素开始遍历输入的数据，将每个元素插入到链表中的正确位置，使得链表保持递增有序。

代码示例：

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

ListNode* insert(ListNode* head, int val) {
ListNode* node = new ListNode(val);
if (!head) {
return node;
}
if (val < head->val) {
node->next = head;
return node;
}
ListNode* cur = head;
while (cur->next && cur->next->val < val) {
cur = cur->next;
}
node->next = cur->next;
cur->next = node;
return head;
}

ListNode* createList() {
ListNode* head = NULL;
int val;
while (cin >> val) {
head = insert(head, val);
}
return head;
}

2. 将单链表拆分成两个单链表，其中一个全为奇数，另一个全为偶数（尽量利用原存储空间）。

可以使用两个指针分别指向奇数链表和偶数链表的尾部，遍历原链表，将奇数节点插入到奇数链表的尾部，偶数节点插入到偶数链表的尾部。

代码示例：

void splitList(ListNode* head, ListNode*& odd, ListNode*& even) {
ListNode* oddTail = NULL;
ListNode* evenTail = NULL;
while (head) {
if (head->val % 2 == 1) {
if (!odd) {
odd = head;
} else {
oddTail->next = head;
}
oddTail = head;
} else {
if (!even) {
even = head;
} else {
evenTail->next = head;
}
evenTail = head;
}
head = head->next;
}
if (oddTail) {
oddTail->next = NULL;
}
if (evenTail) {
evenTail->next = NULL;
}
}

3. 用递增有序的链表A、B表示两个集合，设计算法求它们的并集。

可以使用归并排序的思想，将两个有序链表合并成一个有序链表。具体步骤如下：

1）创建一个新链表，用两个指针分别指向链表A和链表B的头部。

2）比较两个指针所指节点的值，将较小的节点插入到新链表中，并将指针后移。

3）如果其中一个链表已经遍历完了，将另一个链表的剩余部分直接插入到新链表的尾部。

代码示例：

ListNode* merge(ListNode* A, ListNode* B) {
ListNode* head = NULL;
ListNode* tail = NULL;
while (A && B) {
if (A->val < B->val) {
if (!head) {
head = A;
} else {
tail->next = A;
}
tail = A;
A = A->next;
} else {
if (!head) {
head = B;
} else {
tail->next = B;
}
tail = B;
B = B->next;
}
}
if (A) {
tail->next = A;
}
if (B) {
tail->next = B;
}
return head;
}

4. 删除递增有序单链表中的重复元素。

可以使用两个指针，一个指向当前节点，另一个指向下一个节点，如果当前节点的值等于下一个节点的值，就将下一个节点删除。

代码示例：

void deleteDuplicates(ListNode* head) {
ListNode* cur = head;
while (cur) {
ListNode* next = cur->next;
while (next && next->val == cur->val) {
cur->next = next->next;
delete next;
next = cur->next;
}
cur = cur->next;
}
}

5. 求单循环链表中所有结点的最大值、最小值以及平均值。

可以使用一个指针遍历链表，同时记录最大值、最小值和节点个数，最后计算平均值。

代码示例：

void calcStats(ListNode* head) {
if (!head) {
return;
}
ListNode* cur = head->next;
int maxVal = head->val;
int minVal = head->val;
int sum = head->val;
int count = 1;
while (cur != head) {
maxVal = max(maxVal, cur->val);
minVal = min(minVal, cur->val);
sum += cur->val;
count++;
cur = cur->next;
}
double avg = (double)sum / count;
cout << "Max value: " << maxVal << endl;
cout << "Min value: " << minVal << endl;
cout << "Average value: " << avg << endl;
}

6. 判断双循环链表是否对称。

可以使用两个指针，一个指向头部，一个指向尾部，依次比较两个指针所指节点的值是否相等，如果不相等，则不是对称的。

代码示例：

bool isSymmetric(ListNode* head) {
if (!head) {
return true;
}
ListNode* front = head;
ListNode* back = head->prev;
while (front != back && front->prev != back) {
if (front->val != back->val) {
return false;
}
front = front->next;
back = back->prev;
}
return true;
}