python根据值的大小排序并返回下标

你可以使用Python内置的`sorted()`函数，将要排序的值和对应下标组成元组，然后按照值的大小排序，最后返回对应的下标即可。

下面是示例代码：

values = [5, 2, 8, 1, 9]
sorted_indexes = [i[0] for i in sorted(enumerate(values), key=lambda x:x[1])]
print(sorted_indexes)

输出结果：

[3, 1, 0, 2, 4]

其中`enumerate()`函数可以将一个列表转换成一个元素为元组的枚举对象，每个元组包含了该元素的下标和值。`sorted()`函数按照元组中第二个元素（即值）的大小排序，然后`[i[0] for i in ...]`使用列表推导式取出排序后元组中的第一个元素（即下标），最终得到一个按照值从小到大排序的下标列表。

相关问题

函数接收两个变量，一个是整数数组 nums：list，另一个是目标值 target: int； 3. 如果存在两种或以上符合目标值 target 的情况，返回下标相加之和较小的数组； 4. 函数返回的值必须为一个数组，list数据类型，元素排序为正序排序，如返回 [1, 3] 符合条件，[3, 1] 不符合条件

可以使用双指针的方法来解决这个问题。

首先将数组 nums 按照元素大小进行排序，然后定义两个指针 left 和 right，分别指向数组的起始位置和末尾位置。

接着，我们可以通过计算 nums[left] + nums[right] 的值与目标值 target 的大小关系来移动指针。如果 nums[left] + nums[right] 小于 target，则将 left 指针向右移动一位；如果 nums[left] + nums[right] 大于 target，则将 right 指针向左移动一位；如果 nums[left] + nums[right] 等于 target，则找到了符合条件的两个数，记录它们的下标并返回。

如果存在两种或以上符合目标值 target 的情况，返回下标相加之和较小的数组，可以在找到第一组符合条件的两个数之后，继续移动指针寻找下一组符合条件的两个数，比较它们的下标之和，并返回下标之和较小的数组。

下面是代码实现：

def twoSum(nums, target):
    nums = sorted(nums)
    left, right = 0, len(nums) - 1
    result = []
    min_sum = float('inf')
    while left < right:
        if nums[left] + nums[right] < target:
            left += 1
        elif nums[left] + nums[right] > target:
            right -= 1
        else:
            if not result:
                result = [left, right]
            else:
                cur_sum = left + right
                if cur_sum < min_sum:
                    result = [left, right]
                    min_sum = cur_sum
            left += 1
            right -= 1
    return result

用Python 写一个排序

### 回答1：
好的，以下是用Python实现排序的示例代码：

1. 冒泡排序：

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(n - i - 1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

2. 插入排序：

def insertion_sort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and key < arr[j]:
            arr[j+1] = arr[j]
            j -= 1
        arr[j+1] = key
    return arr

3. 选择排序：

def selection_sort(arr):
    n = len(arr)
    for i in range(n):
        min_idx = i
        for j in range(i+1, n):
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]
    return arr

以上是三种常见的排序算法的Python实现，可以根据具体情况选择不同的排序算法。

### 回答2：
要使用Python编写一个排序算法，可以选择常见的几种排序算法之一，如冒泡排序、选择排序、插入排序、快速排序、归并排序等。以下以选择排序为例进行说明。

选择排序的基本思想是每次遍历待排序列表，找到最小（或最大）的元素，将其与当前位置的元素交换，从而将最小（或最大）元素放在正确的位置上。重复这个过程，直到整个列表有序。

下面是用Python编写的选择排序的代码示例：

def selection_sort(arr):
    n = len(arr)
    for i in range(n-1):
        min_index = i
        for j in range(i+1, n):
            if arr[j] < arr[min_index]:
                min_index = j
        arr[i], arr[min_index] = arr[min_index], arr[i]
    return arr

上述代码中，`arr`是待排序的列表，`n`是列表的长度。外层循环控制遍历的轮数，内层循环用于找到最小元素的下标。通过比较当前元素与已找到的最小元素的大小，更新最小元素的下标，最后通过交换操作将最小元素放在合适的位置上。

调用`selection_sort`函数并传入待排序的列表，即可得到排序结果。

示例使用了选择排序算法，但也可以根据需要选择其他算法来编写排序程序。编写排序算法的关键是理解算法的思想和原理，然后将其转化为可执行的代码实现。

### 回答3：
使用Python编写排序算法是非常简单的。下面是一个使用冒泡排序算法的示例：

def bubble_sort(arr):
    n = len(arr)
    for i in range(n-1):
        for j in range(n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

if __name__ == '__main__':
    nums = [4, 2, 7, 1, 9, 5]
    sorted_nums = bubble_sort(nums)
    print(sorted_nums)

上述代码使用了冒泡排序算法，其中`bubble_sort`函数接受一个列表`arr`作为参数并返回已排序的列表。在主函数中，我们定义了一个无序的数字列表`nums`，然后调用`bubble_sort`函数对其进行排序，并将排序后的列表打印出来。

冒泡排序算法的思想是，多次遍历列表，每次遍历将当前最大的元素依次“冒泡”到最右侧，直到所有元素都排好序。在每次遍历中，比较相邻的两个元素，如果顺序不对，则交换它们的位置。这样，每次遍历都会将最大的元素移动到最右侧，直到所有元素都排好序。

这只是冒泡排序算法的一种实现方式，还有许多其他排序算法可供选择，如插入排序、选择排序、快速排序等。在实际的应用中，我们可以根据需求选择最适合的排序算法。