알고리즘) comparable Vs comparator

 

 

 

1. Comparable: "나는 나 스스로를 비교할 줄 알아!" (자기 자신과 남을 비교)
2. Comparator: "내가 너희 둘을 비교해 줄게!" (제3자가 두 대상을 비교)

 

 

 

 

 

 

• 오름차순 (기본): a가 b보다 크면 양수를 반환합니다.
  • return a - b; (숫자의 경우)
• 내림차순 (사용자 메모의 질문): "a > b일 때 -1(음수)을 반환하면 내림차순"이 됩니다.
  • 방법 1: return b - a; (매개변수 순서 바꾸기)
  • 방법 2: return (a > b) ? -1 : (a < b) ? 1 : 0;
  • 방법 3 (가장 권장): comparator.reversed() 사용

 

 

 

Merge Sort vs Quick Sort":

• Merge Sort (병합 정렬): Stable(안정성) 합니다. 즉, 값이 같은 원소들의 원래 순서가 정렬 후에도 유지됩니다. 자바의 Collections.sort()나 객체 배열 정렬에서 주로 씁니다.
• Quick Sort (퀵 정렬): 빠르지만 Unstable 합니다. 기본 타입(int, double 등) 배열 정렬(Arrays.sort())에서 주로 씁니다.

 

 

 

 

 

(트리셋 안쓰더라도 )

1. HashSet에 데이터를 막 집어넣는다. (중복은 알아서 사라지고 속도는 엄청 빠름)
2. 다 담았으면 이걸 ArrayList로 옮긴다.
3. Collections.sort()로 한 번만 정렬한다.

 

 

바구니(TreeSet)를 만들 때 아예 정해주기 

TreeSet<String> ts = new TreeSet<String>(mc.reversed());

• 의미: "이 바구니(TreeSet)는 태생부터 정렬 기능이 있는 바구니야. 데이터를 넣을 때마다 mc.reversed()라는 규칙에 맞춰서 자동으로 줄을 세워!"
• 이미지의 예시는 MyComp라는 규칙을 반대로 뒤집어서(reversed) 바구니를 만들었기 때문에, A, B, C...를 넣어도 나올 때는 F, E, D...로 나옵니다.

 

 

 

TreeSet은 생성자에 Comparator(정렬 규칙)를 넣을 수 있도록 설계되어 있습니다.

사용자님이 말씀하신 "크기(초기 용량)"를 넣는 생성자는 주로 ArrayList나 HashSet에 있고, TreeSet에는 오히려 크기를 지정하는 생성자가 없습니다.

 

 

 

 

// 1. 인터페이스 이름은 '-able' (할 수 있는)
class Student implements Comparable<Student> {
    String name;
    int age;

    // 2. 메서드 이름은 'compareTo' (누구와 비교하다)
    @Override
    public int compareTo(Student other) {
        // 나(this)와 상대방(other)을 비교 (매개변수 1개)
        return this.age - other.age; 
    }
}

// 사용법: 그냥 정렬하면 알아서 나이순으로 됨
Collections.sort(studentList);

 

 

 

// 1. 인터페이스 이름은 '-or' (하는 사람/심판)
class NameJudge implements Comparator<Student> {

    // 2. 메서드 이름은 그냥 'compare' (비교하기)
    @Override
    public int compare(Student s1, Student s2) {
        // 심판이 제3자인 s1과 s2를 비교 (매개변수 2개)
        return s1.name.compareTo(s2.name);
    }
}

// 사용법: 정렬할 때 '심판(NameJudge)'을 같이 넘겨줌
Collections.sort(studentList, new NameJudge());

 

 

Set<Map.Entry<String, Double>> set = tm.entrySet(); // 모든 줄(Entry)을 뽑아냄
for(Map.Entry<String, Double> me : set) { // 한 줄씩 꺼내서 (me)
    System.out.println(me.getKey() + ": " + me.getValue()); // 키와 값을 출력
}

 

 

 

 

// 예: aStr = "John Doe", bStr = "Jane Baker"
i = aStr.lastIndexOf(' '); // 1. 이름 뒤의 공백(' ') 위치를 찾습니다.
j = bStr.lastIndexOf(' '); //    (성(Last Name)이 어디서 시작하는지 알아내려고)

// 2. substring(i)를 해서 성만 뽑아내어 비교합니다.
// " Doe".compareToIgnoreCase(" Baker")
k = aStr.substring(i).compareToIgnoreCase(bStr.substring(j));

// 3. 만약 성이 같으면(k == 0), 전체 이름("John Doe" vs "Jane Doe")으로 다시 비교!
// 성이 다르면 방금 비교한 결과(k)를 그대로 사용합니다.
return (k == 0) ? aStr.compareToIgnoreCase(bStr) : k;

 

 

 

Comparator<String> myComp = compLN             // 1. 성으로 비교해보고
    .thenComparing(new CompFirstName())        // 2. 같으면 이름으로 비교하고
    .thenComparing(new CompAge())              // 3. 그것도 같으면 나이로 비교해!
    .thenComparing(new CompPhone());           // 4. 그것도 같으면 전화번호로... (계속 가능)

 

 

Collections.sort() 괄호 안에 리스트만 넣으면 되나요?

네, 맞습니다. 하지만 딱 List 인터페이스를 구현한 것들만 들어갈 수 있습니다.

• 되는 것: ArrayList, LinkedList, Vector 등 (순서가 있는 목록들)
• 사용법: Collections.sort(myList); 이렇게 리스트만 툭 던져주면 됩니다.

 

 

 

1. List<T> list라고 적힌 것들: (sort, shuffle, binarySearch, swap, reverse)
   • 이 메서드들은 오직 List 종류만 들어갈 수 있습니다.
   • 순서가 중요한 작업들이라 그렇습니다.
2. Collection<? extends T> c라고 적힌 것들: (min, max)
   • 얘네는 List뿐만 아니라 Set도 가능합니다!
   • 최솟값, 최댓값은 순서가 없어도 주머니를 다 뒤져서 찾아낼 수 있기 때문입니다.

 

 

• System.arraycopy: 이름 그대로 **'배열(Array)'**을 복사할 때 씁니다.
  • 예: int[], String[] 같은 순수 배열.
  • 매우 원시적이고 로우레벨(Low-level)한 방식이라 속도가 엄청나게 빠릅니다.
• Collections.copy: **'리스트(List)'**를 복사할 때 씁니다.
  • 예: ArrayList, LinkedList 같은 객체들.
  • 이미지에서 보신 것처럼 List 인터페이스를 구현한 것들끼리 데이터를 주고받을 때 사용합니다.

 

 

 

 

• Collections.reverseOrder() (비어있음):
  • "기본 정렬(Natural Order)을 반대로 뒤집는 심판을 바로 만들어줘!"라는 뜻입니다.
  • 예: 숫자를 내림차순(3, 2, 1)으로 정렬하고 싶을 때, 아무런 심판도 안 만든 상태에서 그냥 Collections.sort(list, Collections.reverseOrder()) 라고 쓰면 끝납니다.

 

List<Integer> list = Arrays.asList(1, 5, 3, 2, 4);

// 1. 오름차순 심판을 만듦
Comparator<Integer> comp = (a, b) -> a.compareTo(b);

// 2. 심판 뒤에 점(.)을 찍어서 뒤집음 (Method Chaining)
list.sort(comp.reversed()); 

System.out.println(list); // [5, 4, 3, 2, 1]

 

 

List<Integer> list = Arrays.asList(1, 5, 3, 2, 4);

// 1. 오름차순 심판을 만듦
Comparator<Integer> comp = (a, b) -> a.compareTo(b);

// 2. 도구 상자의 메서드 안에 심판을 매개변수로 전달
Comparator<Integer> revComp = Collections.reverseOrder(comp);

Collections.sort(list, revComp);

System.out.println(list); // [5, 4, 3, 2, 1]