编写一个程序，提示用户输入一个整数列表，然后查找并输出列表中的最大奇数。如果列表中没有奇数，则输出提示信息。

编写这个程序的Python示例代码如下：

def find_max_odd(numbers):
    # 检查列表是否为空
    if not numbers:
        return "列表中没有数字"

    max_odd = None
    for num in numbers:
        # 如果数字是奇数并且当前最大值未找到或当前数更大
        if num % 2 != 0 and (max_odd is None or num > max_odd):
            max_odd = num

    # 如果找到了最大奇数，返回它；否则返回提示信息
    if max_odd:
        return f"列表中的最大奇数是 {max_odd}"
    else:
        return "列表中没有奇数"

# 获取用户输入
user_input = input("请输入一个整数列表，用逗号分隔：")
number_list = [int(num) for num in user_input.split(",")]

# 调用函数并打印结果
result = find_max_odd(number_list)
print(result)

相关问题

在一给定元组中，插入任意一个元素，形成元素按升序排序的元组。 数字重复统计：对给定的列表[5,2,6,3,1,5,3,6,5]，升序输出所有不同的数字及每个数字重复的次数。 查找列表b中以a或A开头并且以c 结尾的所有元素。 b = ["alec", " Aric", "Alex", "Tony", "rain"] 4. 编写程序，生成一个包含10个[10,99]范围内的随机整数的列表，然后删除其中所有奇数。 5. s是一个列表，内容如下：s = [123, '456', 789, '123', 456, '798']，求其各整数元素的和。

1. 给定元组中插入任意一个元素并按升序排序的代码如下：

tup = (1, 3, 5, 7, 9)
new_tup = sorted(tup + (4,))
print(new_tup)

输出结果为：`(1, 3, 4, 5, 7, 9)`。

2. 统计列表中数字重复次数的代码如下：

lst = [5, 2, 6, 3, 1, 5, 3, 6, 5]
count_dict = {}
for num in lst:
    if num in count_dict:
        count_dict[num] += 1
    else:
        count_dict[num] = 1
for num, count in sorted(count_dict.items()):
    print(f"{num}: {count}")

输出结果为：

1: 1
2: 1
3: 2
5: 3
6: 2

3. 查找列表中以a或A开头并以c结尾的元素的代码如下：

b = ["alec", " Aric", "Alex", "Tony", "rain"]
result = [name for name in b if (name.startswith('a') or name.startswith('A')) and name.endswith('c')]
print(result)

输出结果为：`['alec', 'Alex']`。

4. 生成随机整数列表并删除奇数的代码如下：

import random

lst = [random.randint(10, 99) for _ in range(10)]
even_lst = [num for num in lst if num % 2 == 0]
print(even_lst)

输出结果为一个包含偶数的列表。

5. 求列表中整数元素的和的代码如下：

s = [123, '456', 789, '123', 456, '798']
sum = 0
for item in s:
    if isinstance(item, int):
        sum += item
print(sum)

输出结果为：`1239`。

3.设有一个由正整数组成的无序单链表，编写完成下列功能的算法: ①找出最小值结点，且打印该数值; ②若该数值是奇数，则将其与直接后继结点的数值交换;③ 若该数值是偶数，则将其直接后继结点删除， 4

对于这个问题，你可以设计一个算法步骤如下：

1. **初始化及查找最小值节点**:
- 首先创建一个指向列表头的指针 `head` 和一个变量 `min_val` 来存储当前找到的最小值。将 `head` 初始化为链表的第一个节点，然后遍历链表：
- 比较当前节点的值与 `min_val`，如果当前节点的值更小，更新 `min_val` 为当前节点的值，并记录下节点指针。

2. **打印最小值并判断操作条件**:
- 找到最小值后，检查其是否为奇数或偶数，可以用取模运算 `%` 来确定。如果是偶数，跳过交换和删除的操作。

3. **奇数情况下的交换**:
- 如果最小值是奇数，找到它的下一个节点 `next_node`。检查 `next_node` 是否存在，然后交换它们的值：
- 将 `min_val` 的值赋给 `next_node.val`
- 然后将 `min_val.next` 更新为 `next_node.next`，以便于链表连接。

4. **偶数情况下的删除**:
- 如果最小值是偶数，再次检查 `next_node` 是否存在，因为我们要删除的是 `min_val` 的下一个节点而不是它本身。如果存在，修改 `min_val.next` 使其直接指向 `next_node.next`。如果不存在（即链表中只有一个节点），不需要特殊处理，因为已知列表是单链表。

5. **结束循环**:
- 当遍历完整个链表后，如果没有找到其他节点，说明整个链表只剩下一个节点，或者已经进行了删除操作，这时链表可能为空或只有一个节点。

完整的伪代码如下：

function processLinkedList(head):
    min_val = head
    current = head

    while current is not None:
        if current.val < min_val.val:
            min_val = current
            
        if current.val % 2 == 0:
            if current.next is not None:
                # 删除偶数节点的下一个节点
                temp = current.next
                current.next = temp.next
                temp.next = None
        else:
            # 交换奇数节点与其后继节点
            next_temp = current.next
            current.val, next_temp.val = next_temp.val, current.val

        current = current.next

    # 输出最小值
    print("最小值:", min_val.val)