코딩 잘하고 싶어

[백준] 1106번 - 호텔(Java)

통통푸딩 — Sun, 9 Feb 2025 17:27:49 +0900

DP문제가 아직도 너무 어려워서, 여러 문제를 풀어보며 실력을 키우려고한다.

<문제>

https://www.acmicpc.net/problem/1106

<풀이>

아직도 점화식을 세우는 게 너무 어렵다.

이 문제도 막 어려운 편은 아닌 것 같은데, 풀지 못해서 인터넷을 참고하였다.

이런식으로 감을 익히고 많은 문제를 풀다보면, 스스로 잘 풀어낼 수 있지 않을까?

이 문제에서 점화식을 세우지 못하기도 했지만,

문제 조건을 간과한 점도 있다. 약간의 함정(?)이라 할 수 있는데..

"호텔의 고객을 적어도 C명 늘이기 위해 형택이가 투자해야 하는 돈의 최솟값을 구하는 것" 이라는 조건이 있다.

여기서 "적어도" 라는 말을 잘 캐치해야한다.
꼭 C명을 딱 맞추는 것이 아니라, 그 이상이어도 더 최솟값이라면 그것을 선택해야한다는 것이다.

그래서 점화식을 세우고 계산할 때, C + 100명까지 계산해야한다. (C + 100인 이유는 도시에서 얻을 수 있는 고객의 수가 100명이 최대)

dp[i] 배열은 i명을 추가하기 위한 최솟값이라고 하자.

(dp 배열을 선언할 때도, dp = new int[C + 101] 로 선언해야한다.)

dp 배열은 0 인덱스를 제외한 모든 인덱스 값을 최대값으로 선언해준다.

그렇게 되면, 점화식은 다음과 같다.

각 도시를 돌며, 현재 도시에서 얻을 수 있는 고객의 수 ~ C + 101까지 구해준다.

for(int i=customerCnt; i<C+101; i++) {
	dp[i] = Math.min(dp[i], cost + dp[i - customerCnt]);
}

그냥 dp[i]를 선택하면, 현재 도시를 선택하지 않는 것이고

cost + dp[i - customerCnt]를 선택하게 되면, 현재 도시를 선택하는 것이 된다.

<코드>

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

class Main {
	static int C, N;
	static int[][] promotionInfo;
	static int[] dp;

	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine(), " ");
		StringBuilder sb = new StringBuilder();

		C = Integer.parseInt(st.nextToken());
		N = Integer.parseInt(st.nextToken());
		promotionInfo = new int[N][2];
		dp = new int[C+101];

		for (int i = 0; i < N; i++) {
			st = new StringTokenizer(br.readLine());
			int cost = Integer.parseInt(st.nextToken());
			int customerCnt = Integer.parseInt(st.nextToken());
			promotionInfo[i][0] = cost;
			promotionInfo[i][1] = customerCnt;
		}

		for (int i = 1; i <= C+100; i++) {
			dp[i] = 123456789;
		}

		for (int i = 0; i < N; i++) {
			int cost = promotionInfo[i][0];
			int customerCnt = promotionInfo[i][1];
			for (int j = customerCnt; j < C + 101; j++) {
				dp[j] = Math.min(dp[j], cost + dp[j - customerCnt]);
			}
		}

		int result = Integer.MAX_VALUE;
		for (int i = C; i < C + 101; i++) {
			result = Math.min(result, dp[i]);
		}

		br.close();
		System.out.print(result);
	}

}

[프로그래머스] 부대복귀 (Java)

통통푸딩 — Wed, 13 Mar 2024 20:35:38 +0900

막 어려운 문제라기보다는,

생각의 전환을 잘 하고 싶어서 글을 적게 된 문제이다.

문제

https://school.programmers.co.kr/learn/courses/30/lessons/132266?language=java

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

내가 푼 풀이

처음에는 dfs + dp를 이용해서 문제를 풀려고 했었다.

이전에 갔던 길이라면, 최단거리를 다시 구할 필요가 없기 때문이다.

이렇게 하니 답은 나왔지만, 시간 초과가 떠서 맞지 못했다.

아래는 그 dfs 코드이다.

이미 최단거리를 구했던 곳이라면 더이상 가지않고 최단거리를 반환하여 바로 구할수 있도록 했다.

private int dfs(int cur, int cnt, boolean[] visited, int dest) {
    if(cur == dest) {
        return cnt;
    }
    if(dp[cur] > 0) {
        return dp[cur] + cnt;
    }

    int minVal = Integer.MAX_VALUE;
    for (Integer next : roadList[cur]) {
        if(visited[next]) continue;

        visited[next] = true;
        minVal = Math.min(minVal, dfs(next, cnt+1, visited, dest));
        visited[next] = false;
    }

    if(minVal == Integer.MAX_VALUE) {
        dp[cur] = minVal;
    } else {
        dp[cur] = minVal - cnt;
    }
    return minVal;
}

그렇지만 이 코드는 결론적으로 시간초과가 났다.

방법들을 살펴보다가 다익스트라를 통해서 푼 것들을 발견했다.

다른 사람의 풀이

다익스트라는 한 정점에서 다른 모든 정점으로 가는 최단경로를 구하는 것이기 때문에,

이 문제는 모든 부대원이 강철부대 지점인 한 정점으로 간다는 점에서 다익스트라를 쓰기에 적합하다.

거꾸로 도착 지점인 강철부대 지점을 기준으로 하여 구하면 된다.

이렇게 반대로 생각하면 쉽게 풀 수 있는 문제인데, 이 생각을 하지 못했다.

이 생각을 하고 나면, 다익스트라를 알고 있다면 풀기에는 어렵지 않다.

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

class Main {
	List<Integer>[] roadList;
	int[] d;

	public int[] solution(int n, int[][] roads, int[] sources, int destination) {
		int[] answer = new int[sources.length];
		roadList = new List[n+1];
		d = new int[n+1];
		Queue<int[]> pq = new PriorityQueue<int[]>((o1, o2) -> Integer.compare(o1[1], o2[1]));

		for (int i = 0; i <= n; i++) {
			roadList[i] = new ArrayList<>();
			d[i] = Integer.MAX_VALUE;
		}

		for (int[] road : roads) {
			roadList[road[0]].add(road[1]);
			roadList[road[1]].add(road[0]);
		}

		d[destination] = 0;
		pq.add(new int[]{destination, 0});

		while(!pq.isEmpty()) {
			int[] x = pq.poll();

			if(d[x[0]] < x[1]) continue;

			for (Integer next : roadList[x[0]]) {
				if(d[next] > (d[x[0]] + 1)) {
					pq.add(new int[]{next, d[x[0]] + 1});
					d[next] = d[x[0]] + 1;
				}
			}
		}

		for (int i = 0; i < sources.length; i++) {
			if(d[sources[i]] == Integer.MAX_VALUE) {
				answer[i] = -1;
				continue;
			}
			answer[i] = d[sources[i]];
		}

		return answer;
	}
}

우선순위 큐를 이용하여 쉽게 풀 수 있었다.

생각을 전환해서 여러가지 알고리즘을 이용하여 잘 풀 수 있도록

많이 문제를 접해보고, 풀 때 협소하게 생각하지 않도록 노력해야겠다.

[Java] 상속, 다형성, Override 원리 (+메모리 구조)

통통푸딩 — Sat, 16 Dec 2023 00:07:34 +0900

상속과 다형성, Override는 자바의 객체지향에 있어서 중요한 개념들이다.

어느정도 개념은 알고 있지만, OS관점? 메모리 구조 관점에서 보았을 때,

어떤식으로 작동이 되는 지 원리를 알고 싶었고, 공부하게 되었다.

상속

상속관계인 클래스에서는 자식 클래스가 부모 클래스의 변수와 메서드를 사용할 수 있다.

이게 어떻게 가능한걸까?

JVM 메모리 구조에는 Runtime Data Area가 있다.

프로그램 수행을 위해 OS로부터 별도로 할당받은 메모리 공간이며,

PC 레지스터, JVM 스택, Native 메서드 스택, 메서드 영역, 힙으로 공간이 나뉘어져있다.

자세한 내용은 아래 글을 참고하면 된다.

[ Java ] JVM란? 자바의 실행 원리 알아보기

1. JVM이란? JVM은 자바 가상 머신으로 Java Virtual Machine의 줄임말이다. Java는 운영체제(OS)에 구애받지 않고 실행할 수 있는데 , JVM이 그 역할을 한다. 자바 프로그램은 컴퓨터가 이해할 수 있는 언어(

codingwell.tistory.com

5가지 공간 중 메서드 영역은 클래스 정보를 처음 메모리 공간에 올릴 때 초기화 되는 대상을 저장하기 위한 공간이다.

모든 스레드가 공유하는 영역이고, 클래스, 인터페이스, 메서드 정보, 필드, static 변수 등의 바이트 코드를 보관한다.

구체적인 예시와 메모리 구조를 통해 원리를 설명하겠다.

class Tv {
    boolean power;
    int channel;

    void power() {}
    void channelUp() {}
    void channelDown() {}
}

class CaptionTv extends Tv {
    String text;
    void caption() {}
}

CaptionTv c = new CaptionTv();

Tv 클래스와 CaptionTv 클래스는 상속관계이고 자식 클래스로 인스턴스 c를 생성하였다.

메모리 구조에선 어떤일이 일어날까?

1. Runtime Data Area의 메서드 영역에 이미 Tv 클래스 정보와 CaptionTv 클래스 정보가 들어있다.

2. 인스턴스를 생성하면 스택에 c 참조변수가 생성되고, CaptionTv 생성자가 동작한다.

3. CaptionTv는 Tv를 상속받았으므로, c의 생성자 동작 시에 super()도 동작되어, 부모 클래스인 Tv의 생성자도 호출된다.

4. 이에 따라 힙에 CapitonTv 객체가 생성된다.(부모 클래스의 멤버를 상속받아 포함하고 있음)

5. 스택에 있는 참조변수 c는 대입 연산자(=)를 통해 힙에 생성된 CaptionTv 객체의 주소를 담고 있다.

주의할 점
많은 블로그에서 잘못 다루고 있는 내용을 발견했다.
위의 4번 과정에서 힙에 자식과 부모 클래스 인스턴스 두개가 모두 생성된다고 언급한 블로그들이 많았다.
이것은 잘못된 내용이다.(제대로된 정보를 얻으려고 애씀ㅠ)

자식 클래스에서 생성자를 호출할 때, 부모 클래스의 생성자도 호출된다.
그렇다고 힙에 두개의 인스턴스가 생성되는 것이 아니다. 자식 클래스의 인스턴스만 생성된다.
부모 클래스의 생성자는 따로 생성되지 않으며,
부모 클래스의 속성과 메서드를 자식 클래스에서 상속받아 사용할 수 있도록 초기화하는 과정이다.

이 때, 변수는 인스턴스가 생성될 때마다 새로 생성되지만, 같은 클래스의 메서드는 인스턴스가 달라도 같은 로직을 수행한다.

그래서 메서드는 메서드 영역에 위치하여, 메서드 호출 시에 메서드 영역의 주소를 참조하여 실행한다.

이로써 참조변수 c는 부모 클래스의 변수와 메서드에 접근할 수 있다.

다형성

1) 클래스 형 변환

Tv t = new Tv();  //Tv인스턴스 생성에는 Tv 타입의 참조변수를 사용
CaptionTv c = new CaptionTv();  //CaptionTv인스턴스 생성에는 CaptionTv 타입의 참조변수를 사용

Tv와 CaptionTv는 상속관계이며,

두 클래스 각각 인스턴스를 생성했다.

보통의 상황에선 위와 같이 인스턴스를 생성한다. 인스턴스 타입과 참조변수 타입을 일치시켜 생성한다.

다형성은 한 타입의 참조변수로 여러 타입의 객체를 참조할 수 있도록 하는 것을 말한다.

즉, 부모클래스 타입의 참조변수로 자식클래스의 인스턴스를 참조할 수 있도록 하였다는 것이다.

이런것을 클래스 형 변환 중에서 업캐스팅이라고 한다.

Tv t = new CaptionTv();

이렇게 생성할 경우 참조변수 t는 힙에 생성된 CaptionTv 인스턴스의 주소값을 가지게된다.

이 인스턴스는 상속관계인 부모의 모든 멤버를 상속받아 가지고 있다.

여기서 t는 Tv클래스에 선언된 멤버들만 접근할 수 있다.

업캐스팅을 통해 하위 클래스 객체를 상위 클래스 타입으로 취급되도록 했기 때문에,

상위 클래스에서 정의한 멤버만 접근가능한 것이다.

CaptionTv 인스턴스에는 상속받은 멤버들뿐만 아니라 CaptionTv 멤버 변수들도 모두 존재하지만

컴파일러가 접근할 수 있는 멤버를 Tv 클래스 멤버로 제한하고 있다.

위의 예시에서는 CaptionTv의 text와 caption()은 사용할 수 없다.(자식 클래스에서 추가로 정의된 멤버)

이처럼 참조변수의 타입에 따라 사용할 수 있는 멤버의 개수가 달라진다.

참조변수 타입에 기반해 멤버 변수와 메서드에 접근할 수 있기 때문이다.

❓ 왜 참조변수 타입에 따라 접근 멤버를 결정할까
타입 안전성(Type Safety)을 보장하기 위해!
실행 시간에 발생할 수 있는 타입 관련 오류를 컴파일 시간에 미리 잡도록함

2) 오버라이드와 가상 메서드

만약에 자식 클래스에서 오버라이드한 메서드가 있다면 어떻게 될까요?

여기서 오버라이드 개념 자체는 따로 설명하지 않겠습니다.

class Tv {
    boolean power;
    int channel;

    void power() {}
    void channelUp() {}
    void channelDown() {}
    void volumeUp() {
        System.out.println("tv volume up");
    }
}

class CaptionTv extends Tv {
    String text;
    void caption() {}

    @Override
    void volumeUp() {
        System.out.println("caption tv volume up");
    }
}

class Main {
    public static void main(String[] args) {
        Tv t = new CaptionTv();
        t.volumeUp();  //caption tv volume up
    }
}

이 때, 자식 클래스인 CaptionTv의 volumeUp()이 출력됩니다.

위에서는 참조변수의 타입이 Tv이기 때문에 CaptionTv의 변수와 메서드는 접근할 수 없다고 했는데,

오버라이딩한 메서드가 어떻게 작동할 수 있을까요?

가상 메서드 테이블을 이용하기 때문이다.

가상 메서드 테이블은 각 클래스마다 존재하고, 클래스가 메모리를 할당받을 때

자신의 메서드와 상속받은 모든 메서드의 주소를 모아 정리한 테이블을 말한다.

JVM이 클래스를 로딩할 때, 메서드 영역에 메서드를 할당하고 가상 메서드 테이블을 생성한다.

가상 메서드 테이블은 각 메서드 이름과 실제 메모리 주소가 짝을 이룬다.

어떤 메서드가 호출되면, 이 테이블에서 주소 값을 찾아서 메서드 바이트코드를 수행한다.

JVM의 메서드 영역

편의를 위해 Tv클래스의 channelUp()과 channelDown()은 생략했습니다.

위 그림에서 보듯 재정의된 volumeUp() 메서드는 서로 다른 메서드 주소를 가지게 되고,

실제 인스턴스에 해당하는 메서드를 호출하게 된다.

힙에 생성된 객체는 다음과 같이 가상 메서드 테이블의 주소를 가진다.

각 클래스의 객체가 생성될때마다 가상 메서드 테이블을 생성하는 것이 아니라,

같은 클래스의 모든 객체들이 메서드 영역의 같은 테이블을 공유한다.

힙에 생성되는 인스턴스의 구조

이를 통하여 가상 메서드 테이블에 접근하고, 가상 메서드 테이블에서 일치하는 메서드를 탐색한다.

찾은 메서드의 메서드 주소 즉, 실제 메모리 주소에 접근하여 바이트코드를 실행한다.

이렇게 프로그램이 실행된 후에, 가상 메서드 테이블을 통해 코드와 메모리가 바인딩 되는 이러한 과정을 동적 바인딩이라고 한다.

따라서, 위의 예시에서 생성한 인스턴스인 CaptionTv의 재정의된 메서드가 실행되는것이다.

[운영체제] 메모리 구조 (Heap vs Stack)

통통푸딩 — Thu, 14 Dec 2023 15:17:18 +0900

메모리 구조에 대해서 어렴풋이만 알고 있는 것 같아 제대로 정리해보려고 합니다.

주 메모리

메모리는 크게 커널(kernal) 영역과 유저(User) 영역으로 나뉘어지고,

커널 영역에는 운영체제가 적재되고 유저 영역에는 일반 프로세스가 적재됩니다.

프로그램이 실행되기 위해서 프로그램이 주 메모리(RAM)에 load되어 프로세스가 되어야합니다.

또한, 프로그램 중에 사용할 변수와 데이터들을 메모리에 저장하여 사용합니다.

유저 영역에 적재되는 프로세스의 메모리 구조는 아래와 같습니다.

유저 영역 메모리 구조

메모리 구조

메모리 구조는 크게 코드, 데이터, 힙, 스택 영역으로 나뉩니다.

운영체제가 실행 프로그램을 위해서 공간을 4가지로 할당해줍니다.

1) 코드(Code) 영역

실행할 프로그램의 코드가 저장되는 영역으로 텍스트 영역이라고도 부릅니다.

한마디로 명령문들이 저장되는 것인데, 제어문이나 함수, 상수들이 여기에 저장됩니다.

CPU는 코드 영역에 저장된 명령어를 하나씩 가져가서 처리합니다.

2) 데이터(Data) 영역

데이터 영역은 프로그램의 전역 변수, 정적 변수(static), 상수가 저장되는 영역입니다.

즉, 보통 메인(main)함수 전에 선언되어 끝날때까지 남아있는 변수들입니다.

프로그램의 시작과 함께 할당되고, 종료될때까지 메모리상에 존재하게 됩니다.

3) 힙(Heap) 영역

힙 영역은 사용자가 직접 관리해야하는 메모리 영역입니다.

동적 할당이 되는 변수들은 힙 영역에 저장됩니다.

사용자에 의해 공간이 동적으로 할당되고 해제됩니다.(런타임에 크기가 결정)

커널 영역을 보호하기 위해 메모리의 낮은 주소에서 높은 주소 방향으로 할당됩니다.

4) 스택(Stack) 영역

스택 영역은 함수의 호출과 관계되는 지역변수와 매개변수가 저장됩니다.

힙보다 접근 속도가 빠르고, 명시적으로 변수를 할당/해제 할 필요가 없습니다.(컴파일 타임에 크기가 결정)

함수의 호출과 함께 할당되고, 호출이 완료되면 소멸합니다.

커널 영역을 보호하기위해 메모리의 높은 주소에서 낮은 주소 방향으로 할당됩니다.

컴파일 타임 vs 런타임
컴파일 타임은 소스코드가 실행 가능한 기계어 코드로 변환되어 머신에서 실행 가능한 프로그램이 되는 과정
런타임은 컴파일 과정을 마친 프로그램이 사용자에 의해 실행되고 동작되는 시점

힙(Heap) vs 스택(Stack)

위에 그림에서 본 것 처럼 스택과 힙 영역은 사실 상 같은 공간을 사용하기 때문에,

스택 영역이 클수록 힙 영역이 작아지고, 스택 영역이 작을수록 힙 영역이 커집니다.

유저 영역보다 높은 주소에 커널 영역이 있기 때문에 커널 영역을 보호하기 위해,

유저의 스택 영역은 높은 주소에서 낮은 주소 방향으로 할당되고, 힙 영역은 낮은 주소에서 높은 주소 방향으로 할당됩니다.

커널 영역 반대로 데이터가 저장되기 때문에 커널 영역을 침범할 수 없습니다.

스택과 힙의 영역이 서로 상대의 영역을 침범하게 되면,

스택 오버플로우(Stack Overflow)와 힙 오버플로우(Heap Overflow)가 발생합니다.

커널 영역 메모리 구조

1) 코드 (커널 코드)

시스템 콜/인터럽트 처리 코드, 자원 관리를 위한 코드, 편리한 인터페이스 제공을 위한 코드

2) 데이터

모든 하드웨어들(cpu, 메모리)을 관리하기 위한 자료구조,

모든 프로세스들을 관리하기 위한 자료구조(PCB)

3) 스택 (커널 스택)

각 프로세스마다 별도로 두고 있음(프로세스 커널 스택)

JWT 로그인 시 RefreshToken 저장에 Redis를 사용하는 이유

통통푸딩 — Wed, 13 Dec 2023 19:28:04 +0900

이전에 진행했던 프로젝트에서 JWT 로그인을 구현하였습니다.

JWT 로그인에는 Access-Token과 Refresh-Token이 쓰입니다.

한마디로 표현하면, 액세스 토큰은 인증을 위한 토큰, 리프레시 토큰은 액세스 토큰을 재발급하기위한 토큰입니다.

리프레시 토큰은 서버에서 만들어서 MySQL에 저장하고, http 쿠키로 생성하여 프론트엔드로 넘겨주었습니다.

그런데 프로젝트 리팩토링을 진행하면서, MySQL에 저장했던 리프레시 토큰을 Redis로 바꾸려고 합니다.!!

왜 Redis로 바꾸는 것이 좋을 지에 대해 정리해보겠습니다.

Redis 란?

Redis(Remote Dictionary Server)는 [키(Key) - 값(Value)] 쌍의 해시 맵과 같은 구조를 가진 비관계형(NoSQL) 데이터베이스입니다.

또한, SSD/HHD 같은 보조기억장치가 아닌, 컴퓨의 주 메모리인 RAM에 데이터를 저장하는 In-Memory 방식의 데이터베이스입니다.

따라서 별도의 쿼리문이 필요 없고, In-Memory에 저장되기 때문에 빠르다는 장점이 있습니다.

인-메모리 방식이 빠른 이유?
프로그램을 실행할 때, CPU는 주 메모리인 RAM에 있는 데이터를 처리합니다.
RAM은 영구적으로 데이터를 저장하는 곳이 아니라, 일시적으로 데이터를 저장하는 휘발성 메모리입니다.(전원이 꺼지면 날아감)
그래서 비휘발성의 특징을 가진 디스크(SSD/HDD)에서 필요한 데이터를 RAM에 올려 CPU가 처리하게끔 합니다.
즉, 디스크 -> 메모리 -> CPU의 과정을 거쳐야하지만, 인메모리 방식의 경우 메모리에 데이터를 저장하기 때문에 디스크에 접근을 하지 않아도 되어 빠른 속도를 가집니다.

이러한 이유로, Redis는 캐싱에 많이 쓰이기도 합니다.

빠르다는 특징 외에도, Refresh-Token을 Redis에 저장하는 경우 장점이 몇가지 더 있습니다.

위에 말한 장점과 같이 정리해보겠습니다.

Refresh Token을 Redis에서 사용하는 이유

1) 유효기간 지정 가능

Redis는 데이터의 유효기간(TTL, Time-To-Live)을 정할 수 있습니다.

관계형 데이터베이스에서는 리프레시 토큰을 만료시키기 위해서 주기적으로 만료된 토큰을 삭제시키는 요청이나 스케쥴링을 해야하고, 이는 비효율적인 비용을 발생시킵니다.

Redis에서는 리프레시 토큰의 만료일과 똑같이 맞춰 지정할 수 있어, 토큰이 자동으로 삭제되도록 하여 더 효율적입니다.

2) 성능 이점

Redis는 앞서 말한것처럼 레디스는 인-메모리 방식이라 성능이 RDB에 비해 빠릅니다.

리프레시 토큰은 액세스 토큰을 재발급하기 위해서 자주 호출해야하기 때문에, 성능이 더 빠른 레디스(인-메모리)에 저장하는 것이 더 유리합니다.

Redis vs RDB

그런데, Redis는 휘발성 메모리여서 장애가 나거나 전원이 끊어질 경우 데이터가 날아갈 수 있습니다.

그렇다면 영구적으로 저장할 수 있는 RDB가 낫지 않을까요?

그렇지만, 리프레시토큰은 전부 지워지더라도 모든 유저가 로그아웃되고 재로그인을 해야한다는 것이 전부여서 그렇게 크리티컬한 일은 아니라고 판단하였습니다. 혹여나 데이터가 날아가 재로그인을 해야하는 상황을 고려하더라도, 속도가 매우 뛰어나기 때문에 Redis를 선택하는 것이 더 이득이라고 생각하여 리팩토링을 진행중입니다.

어떤 기술을 변경할때는 항상 트레이드오프가 있지만, 상황과 비용을 잘 따져서 선택하는 것이 중요하다고 생각합니다.

[데이터베이스] 트랜잭션과 동시성 제어

통통푸딩 — Mon, 13 Nov 2023 18:19:20 +0900

1. 특성 (ACID)

1) 원자성 (Atomicity)

- 한 트랜잭션 내 모든 연산들이 완전히 수행되거나 전혀 수행되지 않아야함 (all or nothing)

- DBMS의 회복 모듈 : 시스템 다운이 될 경우, 트랜잭션의 영향을 취소함으로써 원자성 보장

2) 일관성 (Consisitency)

- 어떤 트랜잭션이 수행되기 전에 데이터베이스가 일관된 상태를 가졌다면 트랜잭션이 수행된 후에 데이터베이스는 또 다른 새로운 일관된 상태를 가짐

- DBMS의 무결성 제약 조건, 동시성 제어 모듈

3) 고립성 (Isolation)

- 한 트랜잭션이 데이터를 갱신하는 동안 이 트랜잭션이 완료되기 전에는 갱신중인 데이터를 다른 트랜잭션들이 접근하지 못하도록 해야함

- 다수의 트랜잭션들이 동시에 수행되더라도 그 결과는 순차적으로 수행했을때랑 같아야함

- DBMS의 동시성 제어 모듈 : 고립성 보장

4) 지속성 (Durability)

- 한 트랜잭션이 완료되면 이 트랜잭션이 갱신한 것은 그 후에 시스템이 고장나도 손실되지 않음

- DBMS의 회복 모듈 : 시스템이 다운되어도 지속성 보장

2. 동시성 제어

1) 다수의 사용자들이 동시에 DBMS에 접근하고 트랜잭션을 수행할때, 서로 간섭이 생기지 않도록 해야함 (일관성과 무결성 보장해야함)

2) 동시성과 일관성은 트레이드 오프 관계 !

동시성을 높이기 위해 lock을 최소화하면 일관성을 유지하기 어려워지고,

일관성을 높이기 위해 lock을 많이 사용하면 동시성이 낮아짐

- 동시성 : 트랜잭션들이 순차적으로 실행되는 것이 아니라, 트랜잭션을 구성하는 각각의 쿼리문들이 트랜잭션의 순서에 상관없이 동시에 실행되는 것

- 일관성 : 자신이 발생시킨 변경사항과 다른 트랜잭션의 변경 사항(읽을 수 있는 버전만 허용)을 포함해 일관성 있는 상태로 데이터를 제공하는 것

3) 종류

- 직렬 스케줄 (serial schedule) : 여러 트랜잭션들의 집합을 한번에 한 트랜잭션씩 차례대로 수행

- 비직렬 스케줄 (non-serial schedule) : 여러 트랜잭션들을 동시에 수행

- 직렬 가능 (serializable) : 비직렬 스케줄의 결과가 어떤 직렬 스케줄의 수행결과와 동등함

4) 동시성 제어를 하지않았을 때 생길 문제

- 갱신 손실 (Lost Update) : 수행중인 트랜잭션이 갱신한 내용을 다른 트랜잭션이 덮어써서 무효화됨

- 오손 데이터 읽기 (Dirty Read) : 완료되지 않은 트랜잭션이 갱신한 데이터를 읽는것

- 반복 가능하지 않은 읽기 (Unrepetable Read) : 한 트랜잭션이 동일한 데이터를 두번읽을때 서로 다른값을 읽는것

5) locking

동시성 제어를 위한 방법.

- x-lock (eXclusive lock, 독점 락)

트랜잭션에서 갱신을 목적으로 데이터항목에 접근할때 요청.

현재 걸려있는 락이 x-lock일 경우, x-lock과 s-lock 요청이 오면 둘다 대기해야함

- s-lock (Shared lock, 공유 락)

트랜잭션에서 읽을 목적으로 데이터 항목에 접근할때 요청.

현재 걸려있는 락이 s-lock일 경우, s-lock 요청은 허용이지만, x-lock 요청은 대기해야함

- 2단계 락 프로토콜 (2-phase locking protocol) : 락을 요청하는 것과 해제하는 것이 2단계로 이루어짐

락 확장 단계 : 트랜잭션이 데이터 항목에 대하여 새로운 락을 요청할 수 있지만 가지고 있던 락을 하나라도 해제할 수 없음
락 수축 단계 : 가지고 있던 락을 해제할 수 잇지만 새로운 락을 요청할 수 없음. 조금씩 해제할 수도 있고 한꺼번에 모든 락을 해제할 수도 있음
lock point : 한 트랜잭션에서 필요로 하는 모든 락을 걸어놓은 시저

- 데드락(Deadlock)

2단계 락 프로토콜에선 데드록이 발생할 수 있음.

두개 이상의 트랜잭션들이 서로 상대방이 보유하고 있는 락을 요청하면서 기다리고 있는 상태.

ex) 예시

1. T1이 X에 대해 x-lock 요청

2. T2가 Y에 대해 x-lock 요청

3. T1이 Y에 대해 s-lock이나 x-lock 요청하면 락 해제될때까지 대기

4. T2가 X에 대해 s-lock이나 x-lock 요청하면 락 해제될때까지 대기

-> 서로 무한정 대기하므로 데드락

- 팬텀 문제 (Phantom Problem) : 한 트랜잭션 내에서 동일한 쿼리를 두번 수행했을 때, 첫번째 쿼리에서 나타나지않았던 투플(Phantom)이 두번째 쿼리에서 나타나는 현상

ex) 다른 트랜잭션에서 중간에 Insert했을 경우.

3. 회복(recovery)

1) 필요성

- 트랜잭션 수행 도중이나 완료된 직후에 시스템이 다운됐을때, 원자성과 지속성을 보장하기 위해

- 고장 발생 전에 트랜잭션이 완료됐다면, 회복 모듈은 갱신 사항을 재수행(redo)하여 지속성을 보장함

- 고장 발생 전에 트랜잭션이 완료되지 못했다면, 데이터베이스에 반영했을 가능성이 있는 갱신 사항을 취소(undo)하여 원자성을 보장함

2) 로그를 사용한 즉시 갱신

- 즉시 갱신에서는 갱신 사항이 주기억 장치 버퍼에 유지되다가 완료되기 전이라도 디스크의 데이터베이스에 기록될 수 있음

- 원자성과 지속성 보장을 위해 DBMS는 로그 파일을 유지함

- 각 로그 레코드는 로그 순서번호로 식별되고 로그 레코드마다 트랜잭션 ID를 포함시킴. 동일한 트랜잭션에 속하는 로그 레코드들은 연결 리스트로 유지됨

3) 완료점(commit point)

- 한 트랜잭션의 데이터베이스 갱신 연산이 다 끝나고 로그에 기록되었을 때를 말함

- 회복 모듈은 로그에 start와 commit 로그 레코드가 모두 존재하는 트랜잭션들은 재수행(redo), start는 존재하지만 commit 로그 레코드는 없는 트랜잭션들은 취소(undo)

4) 로그 먼저 쓰기 (Write-Ahead Logging)

- 주기억 장치 데이터베이스 버퍼에 갱신 사항을 기록하고, 로그 버퍼에는 로그 레코드를 기록

- 만약 데이터베이스 버퍼가 로그 버퍼보다 먼저 디스크에 기록되는 경우 : 로그 버퍼가 기록되기 전에 시스템이 다운되면 주기억 장치는 휘발성이어서 로그 값이 남아있지 않게됨 → 트랜잭션의 취소가 불가능

- 따라서 데이터베이스 버퍼보다 로그 버퍼를 먼저 디스크에 기록해야함

5) 체크 포인트(check point)

- 시스템이 다운된 시점부터 오래전에 완료된 트랜잭션들은 이미 디스크에 반영되었을 가능성이 크지만, 로그를 사용하더라도 어떤 트랜잭션이 주기억 장치로부터 디스크에 기록되었는지 구분할 수가 없음

- 그래서 DBMS는 회복 시 재수행할 트랜잭션의 수를 줄이기 위해 주기적으로 체크포인트를 수행

- 주기억 장치의 버퍼 내용이 디스크에 강제로 기록됨 : 수행중인 트랜잭션을 잠시 멈추고 주기억 장치의 로그 버퍼를 디스크에 강제 출력 후 주기억 장치의 데이터베이스 버퍼를 디스크에 강제 출력함

- 체크포인트가 끝나면 로그에 checkpoint 로그 레코드가 기록됨

- 보통 10~20분마다 한번씩 수행

ex) 예시

트랜잭션 T0, T1, T3은 무시. T4, T5는 재수행. T2, T6은 취소

4. 고립 수준

1) Read Uncommited

- 가장 낮은 고립 수준

- s-lock을 걸지 않고 데이터를 읽기 때문에 Dirty Read 발생 가능

- Phantom Read, Unrepetable Read, Dirty Read 발생 가능

- 갱신하려는 데이터에 대해서는 x-lock을 걸고, 트랜잭션이 끝날때까지 보유함

2) Read Commited

- 기본값으로 많이 사용되는 고립수준

- 다른 트랜잭션이 커밋한 정보만 읽을 수 있음

- 읽으려는 데이터에 대해서 s-lock을 걸고, 읽기가 끝나자마자 락을 해제. 동일한 데이터를 다시 읽기위해 s-lock을 다시 걸고 데이터를 읽으면 이전에 읽은 값과 다른 값을 읽을수도 있음

- Phantom Read, Unrepetable Read 발생가능

- 갱신하려는 데이터에 대해서는 x-lock을 걸고, 트랜잭션이 끝날때까지 보유함

3) Repetable Read

- 읽으려는 데이터에 대해 s-lock을 걸고, 트랜잭션이 끝날때까지 보유함

- 한 트랜잭션 내에서 동일한 질의를 두번 이상 수행할 때 매번 같은 값을 포함한 결과를 검색하게됨

- 새로운 행을 추가하는 것을 막을 수는 없어서 Phantom Read 발생 가능

- 갱신하려는 데이터에 대해서는 x-lock을 걸고, 트랜잭션이 끝날때까지 보유함

4) Serializable

- 가장 높은 고립 수준. 가장 성능이 떨어짐

- 한 트랜잭션에서 읽고 쓰는 레코드들을 다른 트랜잭션에서 절대 접근할 수없음

- 조회되는 투플들뿐만 아니라 인덱스에 대해서도 s-lock을 걸고 트랜잭션이 끝날때까지 보유함

- 갱신하려는 데이터에 대해서는 x-lock을 걸고 트랜잭션이 끝날때까지 보유함

비효율적이나 구현은 쉬운 정렬 알고리즘 : 삽입 정렬, 선택 정렬, 버블 정렬
효율적이고 구현이 복잡한 정렬 알고리즘 : 합병 정렬, 퀵 정렬, 힙 정렬

	최선	평균	최악
삽입 정렬	N	N^2	N^2
선택 정렬	N^2	N^2	N^2
버블 정렬	N^2	N^2	N^2
합병 정렬	NlogN	NlogN	NlogN
퀵 정렬	NlogN	NlogN	N^2
힙 정렬	NlogN	NlogN	NlogN

[SWEA] 5653.줄기세포배양(모의 SW 역량테스트) - JAVA

통통푸딩 — Fri, 13 Oct 2023 19:11:57 +0900

SWEA에서 모의 역량테스트 문제 풀어보다가 신기한?흥미로운? 문제를 발견해서 적어보려고한다.

또, 내가 푼 방법은 다른사람들이 주로 푼 방법과는 달라서 두가지 방법을 모두 정리해보려한다.

문제

https://swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AWXRJ8EKe48DFAUo&categoryId=AWXRJ8EKe48DFAUo&categoryType=CODE&problemTitle=%EB%AA%A8%EC%9D%98&orderBy=FIRST_REG_DATETIME&selectCodeLang=ALL&select-1=&pageSize=10&pageIndex=1

SW Expert Academy

SW 프로그래밍 역량 강화에 도움이 되는 다양한 학습 컨텐츠를 확인하세요!

swexpertacademy.com

내 풀이

일단, 문제를 처음 읽고 든 생각은.. 배양 용기의 크기가 무한하다고 가정해야하고, 배열이 계속해서 커지는데 어떻게 풀지?

심지어 배열이 상하좌우로 알수없게 커진다는점이 고민을 하게 만들었고,,

결국 난 배열이 아니라, 해시맵을 이용해서 풀었다.

해시맵의 key 값을 x,y값으로 하고 value에는 세포의 정보를 담았다.

초기에 좌상단이 0,0이므로 왼쪽으로 커진다면 마이너스 값이 키값으로 들어가게 되었다.

어차피 키값(인덱스값) 관리만 잘해준다면, 배열처럼 O(1)로 조회할 수 있기 때문에 bfs를 할때도 비효율적일 것은 없다고 생각했다.

나중에 사람들이 푼걸 좀 보니 배열을 주로 이용했는데, 배열의 최대 크기를 예상해서 배열을 크게 만들고,

시작을 배열의 중간에서 시작하는 방법을 주로 많이 쓰더라..!!

그래서 이것도 아래 정리해보면서 공부해보려한다.

참고로, 해시맵을 돌면서 번식을 하는데, 죽은 세포와 살아있는 세포는 따로 해시맵을 두어서 쓸데없는 시간을 줄이도록 했다.

또, 세포 정보에는 생성된 시간과 생명력을 저장하도록 해, 이를 현재 시간과 비교해서 활성 상태,비활성 상태,번식을 하도록 했다.

두 개 이상이 같은 곳으로 동시에 번식하려고 하는 경우, 생명력 수치가 더 높은 세포를 해시맵에 put했다.(맵은 put할 경우 갱신되기 때문)

크기가 무한해지는 걸 어떻게할까의 고민을 해결하고보니, 생각보다 쉽게 풀렸다.

import java.io.*;
import java.util.*;
import java.util.Map.Entry;

/**
 * k시간 후 살아있는 줄기세포(비활성 + 활성) 총 개수 구하기
 * <p>
 * 초기 : 비활성 상태(x시간동안) 활성 - x시간동안 살아있은 후 죽음 - 첫1시간동안 네방향으로 동시에 번식(번식된 곳은 비활성) - 이미 줄기세포가 있는곳으론 번식 못함 - 두개이상이 같은곳으로 동시
 * 번식하려고하는 경우 생명력 수치가 높은 줄기세포가 함
 */

class Main {
    static class Point {
        int x, y;

        public Point(int x, int y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            Point point = (Point) o;
            return x == point.x && y == point.y;
        }

        @Override
        public int hashCode() {
            return Objects.hash(x, y);
        }
    }

    static class Cell {
        int x, y;
        int health;
        int createTime;
        int state; //0: 비활성, 1: 활성, 2: 죽음

        public Cell(int x, int y, int health, int createTime, int state) {
            this.x = x;
            this.y = y;
            this.health = health;
            this.createTime = createTime;
            this.state = state;
        }
    }

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

        int T = Integer.parseInt(br.readLine().trim());

        for (int tc = 1; tc <= T; tc++) {
            StringTokenizer st = new StringTokenizer(br.readLine(), " ");
            int n = Integer.parseInt(st.nextToken());
            int m = Integer.parseInt(st.nextToken());
            int k = Integer.parseInt(st.nextToken());

            Map<Point, Cell> cells_lived = new HashMap<>();
            Set<Point> cells_dead = new HashSet<>();

            for (int i = 0; i < n; i++) {
                st = new StringTokenizer(br.readLine());
                for (int j = 0; j < m; j++) {
                    int health = Integer.parseInt(st.nextToken());
                    if (health == 0) {
                        continue;
                    }
                    cells_lived.put(new Point(i, j), new Cell(i, j, health, 0, 0));
                }
            }

            int[] dx = {0, 1, 0, -1}, dy = {1, 0, -1, 0};
            for (int time = 1; time <= k; time++) {
                Map<Point, Cell> newCells = new HashMap<>();  //새로 번식하는 세포들
                List<Point> dead = new ArrayList<>();  //새로 죽는 세포들

                for (Entry<Point, Cell> cellEntry : cells_lived.entrySet()) {
                    int x = cellEntry.getKey().x;
                    int y = cellEntry.getKey().y;
                    Cell cell = cellEntry.getValue();

                    if (cell.state == 2) {
                        continue;
                    }

                    if (cell.state == 0 && (cell.createTime + cell.health) == time) {
                        cell.state = 1;  //활성화 상태로 변경
                    } else if (cell.state == 1) {
                        if (cell.createTime + cell.health + 1 == time) {
                            //번식
                            for (int i = 0; i < 4; i++) {
                                int nx = x + dx[i];
                                int ny = y + dy[i];
                                Point next = new Point(nx, ny);

                                if (cells_lived.containsKey(next) || cells_dead.contains(next)) {
                                    continue;
                                }

                                //두개 이상이 같은곳으로 동시 번식하려는 경우, 생명력 수치가 더 높은걸로 갱신
                                if ((newCells.containsKey(next) && newCells.get(next).health < cell.health)
                                        || !newCells.containsKey(next)) {
                                    newCells.put(next, new Cell(nx, ny, cell.health, time, 0));
                                }
                            }
                        }
                        if (cell.createTime + cell.health * 2 == time) {  //죽은 상태로 변경
                            cell.state = 2;
                            dead.add(new Point(x, y));
                        }
                    }

                }

                cells_lived.putAll(newCells);

                for (Point point : dead) {  //살아있는 세포들에서 죽은 세포 제거
                    cells_lived.remove(point);
                }
                cells_dead.addAll(dead);
            }

            sb.append('#').append(tc).append(' ').append(cells_lived.size()).append('\n');
        }
        br.close();
        System.out.print(sb);
    }
}

다른 풀이

앞서 말한대로 난 해시맵을 이용해서 풀었지만, 대부분은 배열을 크게 선언해서 사용한걸 봤다.

어차피 배열은 n*m이고 위아래로 최대 K만큼 더 커질 수 있기 때문에 map[n+2*k][m+2*k]으로 선언하면 된다.

사실 근데 이거보다 작게 선언해도 된다.

세포 생명력 수치가 1일때 가장 빠르게 번식하는데, 이 세포는 2시간에 한번씩 증식하기 때문에

k시간동안 최대 k/2번 증식한다고 볼 수 있다. 그래서 map[n+k][m+k]로 잡아도 된다.

이렇게 배열의 최대 크기?를 예상한 후 생성해서 푸는 방법도 좋은 것 같다.

대부분의 사람들이 이렇게 푼거보니 내가 푼 방법은 신기한 것 같다.

느낀점

그래도 사람들이 주로 안 푼 방법으로 푼 것도 뭔가 뿌듯? 했다.

그래도 여러가지 풀이들을 보면서 실력을 키워야겠다 생각이든다.

[자료구조] 자바로 Stack 직접 구현해보기

통통푸딩 — Thu, 10 Aug 2023 15:34:17 +0900

오랜만에 자료구조를 직접 구현해보는 연습을 해보고있다.

스택은 자주 사용하는 자료구조이며, 어느정도 개념도 잘 알고 있다보니 직접 구현하는 게 어렵진 않았다.

그래서 나 스스로에게 미션(?)을 부여하면서 구현해보았다.

첫번째는, 제네릭을 사용해서 구현할 것.

두번째는, 스택의 구성은 배열과 링크드리스트 두가지 버젼을 구현해볼것.

이를 구현하기 위해서 인터페이스를 사용했다.

보통 스택에서 사용하는 메소드들을 인터페이스를 통해 선언해놓고 배열 스택과 링크드리스트 스택에서 구현하도록 했다.

역시 이때 요소의 타입은 제네릭을 사용하여 지정하도록 하였다.

Stack

public interface Stack<E> {
    boolean add(E data);
    E pop();
    E peek();
    E get(int idx);
    boolean isEmpty();
    void clear();
}

1) 배열을 이용한 스택 - ArrayStack

import java.util.Arrays;

public class ArrayStack<E> implements Stack<E> {
    private final int initCapacity = 100;
    private Object[] arr = new Object[initCapacity];
    private int size = 0;

    private void increaseCapacity() {
        int newSize = arr.length + initCapacity;
        arr = Arrays.copyOf(arr, newSize);
    }

    @Override
    public boolean add(E data) {
        if(size >= arr.length-1) {
            increaseCapacity();
        }

        arr[size++] = data;
        return true;
    }

    @Override
    public E pop() {
        E data = (E) arr[--size];
        arr[size] = 0;
        return data;
    }

    @Override
    public E peek() {
        return (E) arr[size-1];
    }

    @Override
    public E get(int idx) {
        if(idx >= size) {
            throw new ArrayIndexOutOfBoundsException();
        }
        return (E) arr[idx];
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public void clear() {
        size = 0;
        arr = new Object[initCapacity];
    }
}

배열용 스택은 배열의 크기를 처음에 100만큼 할당해준다음, 꽉차면 배열의 크기를 100씩 늘려주는 식으로 구현했다.

2) 링크드 리스트를 이용한 스택 - LinkedListStack

public class LinkedListStack<E> implements Stack<E> {
    private Node<E> head;
    private Node<E> top;
    private int size = 0;

    private class Node<E> {
        private Node<E> next;
        private E data;

        public Node(E data) {
            this.data = data;
        }
    }

    public Node<E> search(int idx) {
        if(size <= idx) {
            throw new ArrayIndexOutOfBoundsException(idx);
        }
        Node node = head;

        for (int i = 0; i < idx; i++) {
            node = node.next;
        }

        return node;
    }

    @Override
    public boolean add(E data) {
        Node<E> newNode = new Node<>(data);

        if(isEmpty()) {
            head = newNode;
            top = newNode;
        } else {
            Node<E> tmp = top;
            tmp.next = newNode;
            top = newNode;
        }
        size++;
        return true;
    }

    @Override
    public E pop() {
        Node<E> deleted = top;
        E data = deleted.data;

        if(size == 1) {
            head = null;
            top = null;
        } else {
            Node<E> node = search(size - 2);
            node.next = null;
            top = node;
        }
        deleted = null;
        size--;
        return data;
    }

    @Override
    public E peek() {
        return top.data;
    }

    @Override
    public E get(int idx) {
        return search(idx).data;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public void clear() {
        Node<E> node = head;

        while(node != null) {
            Node<E> tmp = node;
            node = node.next;
            tmp = null;
        }
        head = null;
        top = null;
        size = 0;
    }
}

링크드리스트 스택은 head와 top 노드 정보를 가지며 각 노드는 다음 노드 정보를 가지고 있다.

링크드리스트를 구현해봤다면 어렵지 않게 구현할 수 있을 것이다.

혹시 잘못된 부분이 있으면 댓글 남겨주세요!

[자료구조] 자바로 LinkedList 직접 구현해보기

통통푸딩 — Wed, 9 Aug 2023 18:54:21 +0900

오랜만에 손코딩 연습도 해볼겸 개념정리도 한번 할겸 자바로 링크드리스트를 구현해보았다.

링크드리스트는 노드가 연속적으로 다음 포인터를 가지고 있는 자료구조이다.

링크드 리스트의 개념이나 특징을 공부한 후에 구현해보는 것을 추천한다!

처음에는 데이터 타입을 그냥 가장 상위 클래스인 Object 클래스로 구현해보았다.

그렇게 하면 여러개의 다른 데이터 타입을 넣을 수는 있겠지만,

하나의 데이터 타입으로 고정할 수가 없었다. (예를 들면 자바 라이브러리 util에 있는 자료구조들처럼..)

그래서 제네릭 타입으로 구현하여 호출하는 쪽에서 타입을 지정하고,

다른 타입을 파라미터로 넣으면, 컴파일 오류가 나게하여 더 좋은 코드를 작성해보았다.

일반적으로, 컴파일 오류가 나게끔 하는 게 더 좋은 코드이다.
런타임 오류는 프로그램 실행 도중에 나는 오류라 위험하다.
미리 컴파일 전에 오류를 발견하여 수정할 수 있는 것이 좋다.

public class LinkedList<E> {
    private Node<E> head;
    private Node<E> tail;
    private int size = 0;

    private class Node<E> {
        private Node<E> next;
        private E data;

        public Node(E data) {
            this.data = data;
        }
    }

    public Node<E> search(int idx) {  //idx번째 있는 노드 반환
        if(idx >= size) {
            throw new IndexOutOfBoundsException();
        }
        Node<E> node = head;
        for (int i = 0; i < idx; i++) {
            node = node.next;
        }
        return node;
    }

    public void addFirst(E data) {  //맨 앞에 노드 추가
        Node<E> newNode = new Node(data);

        newNode.next = head;
        head = newNode;
        size++;

        if(newNode.next == null) {
            tail = head;
        }
    }

    public void add(int idx, E data) {  //idx번째에 노드 추가
        if(idx == 0) {
            addFirst(data);
            return;
        }

        Node<E> newNode = new Node<>(data);
        Node<E> tmp = search(idx-1);
        newNode.next = tmp.next;
        tmp.next = newNode;
        size++;

        if(newNode.next == null) {
            tail = newNode;
        }
    }

    public E removeFirst() {  //맨 앞 노드 삭제
        if(head == null) {
            throw new IndexOutOfBoundsException();
        }
        E data = head.data;
        Node<E> tmp = head;
        head = tmp.next;

        tmp = null;
        size--;
        return data;
    }

    public E remove(int idx) {  //idx번째에 있는 노드 삭제
        if(idx >= size) {
            throw new IndexOutOfBoundsException();
        }
        if(idx == 0) {
            return removeFirst();
        }

        Node<E> node = search(idx-1);
        Node<E> deleted = node.next;

        node.next = deleted.next;
        E data = deleted.data;
        deleted = null;
        size--;

        if(node.next == null) {
            tail = node;
        }
        return data;
    }

    public void print() {  //모든 노드의 데이터 순서대로 출력
        if(head == null) {
            System.out.println("x");
            return;
        }

        Node<E> node = head;
        while(node != null) {
            System.out.print(node.data + " ");
            node = node.next;
        }
        System.out.println();
    }

    public void printInfo() {  //현재 head, tail의 데이터와 size 출력
        if(size == 0) return;
        System.out.println("head : " + head.data + ",tail : " + tail.data + ",size : " + size);
    }
}

링크드리스트는 head와 tail, size를 가지고 있으며, 각 노드는 다음 노드 정보와 데이터를 가지고 있다.

여러가지 예외 처리는 적당히만 구현했다.

혹시 잘못된 부분 있으면 피드백 부탁드립니다!