BOJ 10814 나이순 정렬

import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int n = Integer.parseInt(br.readLine());
        ArrayList<Member> members = new ArrayList<>();

        for(int i = 0; i < n; i++) {
            String member = br.readLine();

            int age = Integer.parseInt(member.split(" ")[0]);
            String name = member.split(" ")[1];

            members.add(new Member(age, name));
        }

        Collections.sort(members);

        for(int i = 0; i < members.size(); i++)
            System.out.println(members.get(i).age +" " +members.get(i).name);
    }
}

class Member implements Comparable<Member> {
    int age;
    String name;

    public Member(int age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public int compareTo(Member o) {
        if(this.age != o.age) return this.age - o.age;
        else return 0;
    }
}

Java Docs를 확인해 보면 자바의 Collections.sort() 함수는 안정 정렬인 팀 정렬(Tim Sort)을 사용한다.
따라서 나이가 다를 때만 비교값을 반환해주면 정렬이 완료된다.

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

bool cmp(pair<int, string> p1, pair<int, string> p2) {
    return p1.first < p2.first;
}

int main(int argc, const char * argv[]) {
    int n; cin >> n;
    
    vector<pair<int, string>> members;
    pair<int, string> member;
    
    for(int i = 0; i < n; i++) {
        cin >> member.first >> member.second;
        members.push_back(member);
    }
    
    stable_sort(members.begin(), members.end(), cmp);
    
    for(int i = 0; i < n; i++) {
        cout << members[i].first << " " << members[i].second << '\n';
    }
}

C++의 기본 sort() 함수는 불안정 정렬인 퀵 정렬(Quick Sort)을 사용하고 있다.
하지만 안정 정렬인 병합 정렬(Merge Sort)을 사용한 stable_sort() 함수를 따로 제공해 준다.
stable_sort() 함수를 이용하여 정렬을 완료한다.

class Member {
    var age: Int
    var name: String

    constructor(age: Int, name:String) {
        this.age = age
        this.name = name
    }
}

fun main(args: Array<String>) {
    var N = readLine()!!.toInt()
    var members = ArrayList<Member>()

    for(i in 0 until N) {
        var str = readLine()!!.split(" ")
        members.add(Member(str[0].toInt(), str[1]))
    }

    members.sortBy { it.age }

    for(i in 0 until N) {
        println("${members[i].age} ${members[i].name}")
    }
}

Kotlin 문서에 의하면 어떤 정렬 알고리즘을 사용하는지는 나와있지 않지만
Kotlin의 sortBy() 함수는 안정 정렬이라고 한다.
따라서 나이 기준으로만 정렬 해 주면 정렬이 완료된다.

def main():
    n = int(input())
    members = list()

    for i in range(n):
        member = input().split()
        age = int(member[0])
        name = member[1]
        members.append((age, name))

    members.sort(key = lambda age : age[0])

    for i in members:
        print(i[0], i[1])
        
if __name__ == "__main__":
    main()

Python 문서에 의하면 어떤 정렬 알고리즘을 사용하는지는 나와있지 않지만
Python의 sort() 함수는 안정 정렬이라고 한다.
따라서 나이 기준으로 정렬 해 주면 정렬이 완료된다.

import Foundation

struct Member {
    var age: Int
    var name: String
}

func main() {
    let n = Int(readLine()!)!
    
    var members = Array<Member>()
    
    for i in 0..<n {
        var member = (readLine()?.split(separator: " "))!
        
        if let age: Int = Int(member[0]) {
            members.append(Member(age: age, name: String(member[1])))
        }
    }
    
    members.sort { first, second in
        return first.age < second.age
    }
    
    for i in 0..<n {
        print(members[i].age, members[i].name)
    }
}

main()

Swift의 sort() 함수는 팀 정렬(Tim Sort)을 이용하므로 안정 정렬이다. (Swift 5 부터 안정 정렬이라고 한다.)
따라서 나이 기준으로만 정렬 해 주면 정렬이 완료된다는 것을 알 수 있다.