尾插法 从数组elems中创建链表，n为数据元素个数

尾插法是一种创建链表的方法，可以从数组elems中创建链表，n为数据元素个数。具体实现方法是，先创建一个空链表，然后从elems数组中依次取出每个元素，将其插入到链表的尾部。这样就可以创建一个包含n个元素的链表。

相关问题

gdb中查看数组中有多少元素不同个数

在 gdb 中查看数组中有多少个不同的元素，可以使用 gdb 的 Python API 来实现。具体步骤如下：

1. 在 gdb 中运行程序，使得数组被初始化。
2. 进入 gdb 的 Python 模式，可以使用 `python` 命令。
3. 在 Python 模式下，可以使用 gdb 的 Python API 来获取数组的元素，然后使用 Python 的 set 类型来获取不同的元素个数。

下面是一个示例：

# 进入 gdb 的 Python 模式
(gdb) python

# 导入必要的模块
>>> import gdb
>>> import collections

# 获取数组变量的地址
>>> arr = gdb.parse_and_eval('array')

# 获取数组的元素个数
>>> n = int(arr.type.sizeof / arr.type.target().sizeof)

# 获取数组的所有元素
>>> elems = [int(arr[i]) for i in range(n)]

# 使用 collections.Counter 获取每个元素的出现次数
>>> freq = collections.Counter(elems)

# 输出不同元素的个数
>>> print(len(freq))

# 退出 gdb 的 Python 模式
>>> end

在上面的示例中，`array` 是要查看的数组变量名，`int` 是数组元素的类型。请注意，这个例子仅适用于数组元素是整数类型的情况。如果数组元素是其他类型，需要相应地修改获取元素和计算频率的代码。

(1)随机产生或键盘输入一组元素，建立一个带头结点的单向链表(无序)。(2)遍历单向链表。 (3)把单向链表中元素逆置(不允许申请新的结点空间)。(4)在单向链表中删除所有的偶数元素结点。 (5)编写在非递减有序链表中插入一个元素使链表元素仍有序的雨数，并利用该函数建立一个非递减有序单向链表。 (6)利用算法5建立两个非递减有序单向链表，然后合并成一个非递增链表。(7)利用算法5建立两个非递减有序单向链表，然后合并成一个非递减链表。(8)利用算法1建立的链表，实现将其分解成两个链表，其中一个全部为奇数，另一个全部为偶数(尽量利用已知的存储空间)。 (9)在主函数中设计一个简单的菜单，分别调试上述算法。

我可以回答你的第一个问题。以下是实现这些功能的代码：

class Node:
    def __init__(self, data=None):
        self.data = data
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = Node()

    def add(self, data):
        new_node = Node(data)
        cur = self.head
        while cur.next != None:
            cur = cur.next
        cur.next = new_node

    def display(self):
        elems = []
        cur = self.head.next
        while cur != None:
            elems.append(cur.data)
            cur = cur.next
        print(elems)

    def reverse(self):
        prev = None
        cur = self.head.next
        while cur != None:
            next_node = cur.next
            cur.next = prev
            prev = cur
            cur = next_node
        self.head.next = prev

    def remove_even(self):
        cur = self.head.next
        prev = self.head
        while cur != None:
            if cur.data % 2 == 0:
                prev.next = cur.next
                cur = cur.next
            else:
                prev = cur
                cur = cur.next

    def insert_sorted(self, data):
        new_node = Node(data)
        cur = self.head.next
        prev = self.head
        while cur != None and cur.data < data:
            prev = cur
            cur = cur.next
        new_node.next = cur
        prev.next = new_node

    def merge_sorted(self, other):
        new_list = LinkedList()
        cur1 = self.head.next
        cur2 = other.head.next
        while cur1 != None and cur2 != None:
            if cur1.data < cur2.data:
                new_list.add(cur1.data)
                cur1 = cur1.next
            else:
                new_list.add(cur2.data)
                cur2 = cur2.next
        while cur1 != None:
            new_list.add(cur1.data)
            cur1 = cur1.next
        while cur2 != None:
            new_list.add(cur2.data)
            cur2 = cur2.next
        return new_list

    def split_odd_even(self):
        odd_list = LinkedList()
        even_list = LinkedList()
        cur = self.head.next
        while cur != None:
            if cur.data % 2 == 0:
                even_list.add(cur.data)
            else:
                odd_list.add(cur.data)
            cur = cur.next
        return odd_list, even_list

# 测试代码
lst = LinkedList()
lst.add(3)
lst.add(2)
lst.add(4)
lst.add(1)
lst.display()  # [3, 2, 4, 1]
lst.reverse()
lst.display()  # [1, 4, 2, 3]
lst.remove_even()
lst.display()  # [1, 3]
lst.insert_sorted(2)
lst.insert_sorted(4)
lst.insert_sorted(5)
lst.display()  # [1, 2, 3, 4, 5]
lst2 = LinkedList()
lst2.add(2)
lst2.add(3)
lst2.add(6)
lst2.add(7)
lst2.add(8)
lst2.display()  # [2, 3, 6, 7, 8]
lst3 = lst.merge_sorted(lst2)
lst3.display()  # [1, 2, 2, 3, 3, 4, 5, 6, 7, 8]
odd_list, even_list = lst3.split_odd_even()
odd_list.display()  # [1, 3, 3, 5, 7]
even_list.display()  # [2, 2, 4, 6, 8]

你可以根据需要在主函数中调用这些方法。