OJ常用技巧-排序

OJ常用技巧-排序

1. C/C++

• qsort

#include <stdlib.h>
#include <limits.h>

int compare_ints(const void* a, const void* b) {
    int arg1 = *(const int*)a;
    int arg2 = *(const int*)b;
    if (arg1 < arg2) return -1;
    if (arg1 > arg2) return 1;
    return 0;
    // return (arg1 > arg2) - (arg1 < arg2); // possible shortcut
    // return arg1 - arg2; // erroneous shortcut (fails if INT_MIN is present)
}

int main(void) {
    int ints[] = { -2, 99, 0, -743, 2, INT_MIN, 4 };
    int size = sizeof ints / sizeof *ints;
    qsort(ints, size, sizeof(int), compare_ints);
}

• STL - sort

#include <algorithm>
#include <functional>
#include <array>

int main() {
    std::array<int, 10> s = {5, 7, 4, 2, 8, 6, 1, 9, 0, 3};

    // sort using the default operator<, Ascending Order
    std::sort(s.begin(), s.end());

    // sort using a standard library compare function object, Descending Order
    std::sort(s.begin(), s.end(), std::greater<int>());

    // sort using a custom function object
    struct {
        bool operator()(int a, int b)
        {
            return a < b;
        }
    } customLess;
    std::sort(s.begin(), s.end(), customLess);

    // sort using a lambda expression
    std::sort(s.begin(), s.end(), [](int a, int b) {
        return b < a;
    });
}

---

2. Java

import java.util.Comparator;

import java.util.ArrayList;

import java.util.List;
import java.util.Arrays;
import java.util.Collections;

public class Main {

    public static void main(String[] args) {

        List<Integer> s =
            new ArrayList<Integer>(Arrays.asList(5, 7, 4, 2, 8, 6, 1, 9, 0, 3));

        // 使用 Integer 类自带的 Comparator 接口实现的 compareTo() 方法。
        // 如果没有默认实现则会报错。Ascending Order
        Collections.sort(s);

        // 使用自定义，通过匿名类的方式实现的Comparator接口, 同时调用reversed()方法。
        // Descending Order.
        Collections.sort(s, new Comparator<Integer>() {
                                @Override
                                public int compare(Integer a, Integer b) {
                                    return a.compareTo(b);
                                }
                            }.reversed());

        // 使用静态方法的引用来排序, Ascending Order
        s.sort(Integer::compareTo);

        // 使用 Lambda 表达式，简化Comparator的实现, Descending Order
        s.sort((a, b) -> b.compareTo(a));

        for (int n : s) { System.out.print(n+", "); } System.out.println();

    }

}

---

3. Python

# -*- coding: utf-8 -*-

data = [('a', 5), ('c', 7), ('b', 4), ('g', 2), ('h', 8),
        ('e', 6), ('i', 1), ('f', 9), ('j', 0), ('d', 3)]
# 默认按 Tuple 的第一个元素升序排列
data.sort()
# 按 Tuple 的第一个元素降序排列
data.sort(reverse=True)
# 按 Tuple 的第二个元素升序排列
data.sort(cmp=lambda x, y: x[1] - y[1])
# 按 Tuple 的第二个元素降序排列
data.sort(cmp=lambda x, y: x[1] - y[1], reverse=True)