[알고리즘문제풀기] 특이한 정렬

문제

내가 작성한 정답

class Solution {
    public int[] solution(int[] numlist, int n) {
        int len = numlist.length;

        for (int i = 0; i < len - 1; i++) {
            for (int j = 0; j < len - 1 - i; j++) {
                int dif1 = Math.abs(numlist[j] - n);
                int dif2 = Math.abs(numlist[j + 1] - n);

                if (dif1 > dif2 || (dif1 == dif2 && numlist[j] < numlist[j + 1])) {
                    int a = numlist[j];
                    numlist[j] = numlist[j + 1];
                    numlist[j + 1] = a;
                }
            }
        }
        return numlist;
    }
}

다른 사람들의 정답

StreamAPI

import java.util.Arrays;

class Solution {
    public int[] solution(int[] numList, int n) {
        // numList 배열을 스트림으로 변환하여 Integer 객체로 박싱
        return Arrays.stream(numList)
                .boxed() // int 배열을 Integer 객체의 스트림으로 변환
                .sorted((a, b) -> 
                    // 두 요소 a와 b를 비교하여 정렬
                    Math.abs(a - n) == Math.abs(b - n) // 두 요소의 n과의 차이가 같은 경우
                        ? b.compareTo(a) // 값이 큰 쪽이 앞에 오도록 정렬
                        : Integer.compare(Math.abs(a - n), Math.abs(b - n)) // 차이가 작은 순서로 정렬
                )
                .mapToInt(Integer::intValue) // Integer 객체를 int로 변환
                .toArray(); // 최종적으로 int 배열로 변환하여 반환
    }
}

Comparator

import java.util.Arrays;
import java.util.Comparator;

class Solution {
    public int[] solution(int[] numlist, int n) {
        // 정렬 기준을 정의
        Arrays.sort(numlist, new Comparator<Integer>() {
            @Override
            public int compare(Integer a, Integer b) {
                int distanceA = Math.abs(n - a);
                int distanceB = Math.abs(n - b);
                
                // 거리 비교
                if (distanceA == distanceB) {
                    // 거리가 같으면 더 큰 수가 앞에 오도록
                    return b - a; // b가 a보다 크면 양수 반환
                }
                return distanceA - distanceB; // 거리 기준으로 정렬
            }
        });
        
        return numlist;
    }
}

class Solution {
    public int[] solution(int[] numlist, int n) {
        int len = numlist.length;
        int[] answer = new int[len];
        int size = 0; // 현재 answer 배열에 들어간 요소 개수

        for (int num : numlist) {
            int idx = size; // 삽입할 위치 찾기

            // 현재 answer 배열의 요소들과 비교하면서 삽입할 위치 탐색
            while (idx > 0) {
                int diff1 = Math.abs(answer[idx - 1] - n);
                int diff2 = Math.abs(num - n);

                // 정렬 기준: (거리가 더 작거나) (거리가 같으면 더 큰 값이 앞으로)
                if (diff2 < diff1 || (diff2 == diff1 && num > answer[idx - 1])) {
                    // 한 칸씩 뒤로 이동
                    answer[idx] = answer[idx - 1];
                    idx--;
                } else {
                    break;
                }
            }

            // 찾은 위치에 현재 숫자 삽입
            answer[idx] = num;
            size++; // 배열 크기 증가
        }

        return answer;
    }
}