1. 수 정렬하기 2750번

package 정렬;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;

public class 수정렬하기_2750 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int count = Integer.parseInt(br.readLine());
        ArrayList<Integer> arr = new ArrayList<Integer>(); // 동적할당을 위해

        for(int i = 1; i <= count; i++){
            int num = Integer.parseInt(br.readLine());
            arr.add(num);
        }

        Collections.sort(arr); // 컬랙션으르 이용하여 ArrayList 정렬

        for (Integer integer : arr) {
            System.out.println(integer);
        }

        

    }
}

1. 나이순 정렬 10814번

package 정렬;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.StringTokenizer;

class Person {
    int age;
    String name;

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

public class 나이순정렬_10814 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int count = Integer.parseInt(br.readLine());
        ArrayList<Person> list = new ArrayList<>();

        for (int i = 0; i < count; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine(), " ");
            int age = Integer.parseInt(st.nextToken());
            String name = st.nextToken();
            list.add(new Person(age, name));
        }

        // 나이순으로 정렬하되, 나이가 같으면 입력 순서대로 정렬되도록.
        Collections.sort(list, new Comparator<Person>() { //제네릭을 사용하여 비교 및 정려
            @Override
            public int compare(Person p1, Person p2) {
                return Integer.compare(p1.age, p2.age); 
            }
        });

        for (Person person : list) {
            System.out.println(person.age + " " + person.name);
        }
    }
}

1. 카드2 2164번

package 정렬;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

    public class 카드{

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

            int N = Integer.parseInt(br.readLine());

            int[] queue = new int[2 * N];  // 2 * N - 1 의 공간이 필요하다.
            for(int i = 1; i <= N; i++) { // 입력 받은에 인덱스 넣기
                queue [i] = i;
            }
            int first = 1, last = N;

            while(N-- > 1) {
                first++;
                queue[last + 1] = queue[last];
                last++;
                first++;
            }

            System.out.println(queue[first]);
        }

    }
}

1. 나무자르기 2805번

package 이분탐색;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class 나무자르기 {
    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer st = new StringTokenizer(br.readLine(), " ");

        int n = Integer.parseInt(st.nextToken());
        int m = Integer.parseInt(st.nextToken());

        int[] arr = new int[n];
        StringTokenizer st1 = new StringTokenizer(br.readLine()); // 그 다음 읽기
        int min = 0;
        int max = -1;
        for(int i=0; i<n; i++) {
            arr[i] = Integer.parseInt(st.nextToken());
            max = Math.max(max, arr[i]); // 이 가운데에서 최댓값을 구하자!
        }

        while(min<=max) { // 이진탐색 중앙값을 2로 나눈값을 target으로 잡고 구하자!
            int mid = (min+max)/2;
            long tree=0;

            for(int i=0; i<n; i++) {
                if(arr[i]>mid) // 만약 중앙 값보다 크다면?
                    tree+= arr[i]-mid; // 잘라버리기(이것이 트리의 합이된다.)
            }
            if(tree>=m) { // 최솟값을 높혀라 한 값보다 크다면?
                min = mid+1; //
            }else if(tree<m) { // 작다면 맞추도록! max를 낮추기!
                max = mid-1;
            }
        }

        System.out.println(max);
    }
}

1. 트리의 지름

package 이분탐색;

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

public class 트리의지름 {
    // 노드의 개수
    static int N;
    // 노드의 인접 리스트 배열
    static List<Node> nodes[];
    // 방문 여부를 확인하는 배열
    static boolean[] visited;
    // 최대 거리를 저장할 변수
    static int max;

    public static void main(String[] args)throws IOException{
        // 입력을 받기 위한 BufferedReader
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        // 노드의 개수를 입력받음
        N = Integer.parseInt(br.readLine());
        // 노드 배열 초기화
        nodes = new ArrayList[N+1];
        // 각 노드에 대한 인접 리스트 초기화
        for(int i = 1; i <= N; i++)nodes[i] = new ArrayList<>();

        // 노드 사이의 간선 정보를 입력받음
        for(int i = 1; i < N; i++){
            StringTokenizer st = new StringTokenizer(br.readLine());
            int from = Integer.parseInt(st.nextToken());
            int to = Integer.parseInt(st.nextToken());
            int value = Integer.parseInt(st.nextToken());
            // 양방향 간선을 인접 리스트에 추가
            nodes[from].add(new Node(to,value));
            nodes[to].add(new Node(from,value));
        }

        // 각 노드에서 DFS를 수행하여 트리의 지름을 찾음
        for(int i = 1; i <= N; i++){
            // 방문 배열을 초기화
            visited = new boolean[N+1];
            // 시작 노드를 방문 처리
            visited[i] = true;
            // DFS 시작
            dfs(i,0);
        }
        // 트리의 지름 출력
        System.out.println(max);
    }

    // DFS를 사용하여 트리의 지름을 찾는 메소드
    public static void dfs(int num, int value){
        // 현재 노드에서 연결된 모든 노드를 방문
        for(Node node : nodes[num]){
            // 아직 방문하지 않은 노드라면
            if(!visited[node.link]){
                // 해당 노드를 방문 처리
                visited[node.link] = true;
                // 다음 노드로 이동하며 거리를 누적
                dfs(node.link, value + node.value);
            }
        }
        // 최대 거리를 갱신
        max = Math.max(max,value);
    }
}

// 노드 클래스
class Node{
    // 연결된 노드 번호
    public int link;
    // 해당 간선의 거리
    public int value;

    // 노드 생성자
    public Node(int link, int value){
        this.link = link;
        this.value =value;
    }
}