hyunmin43240 님의 블로그

Dijkstra: Shortest Reach 2

hyunmin43240 — Mon, 5 May 2025 17:05:47 +0900

https://www.hackerrank.com/challenges/dijkstrashortreach/problem

Dijkstra: Shortest Reach 2 | HackerRank

Learn to use Dijkstra's shortest path algorithm !

www.hackerrank.com

 public static List<Integer> shortestReach(int n, List<List<Integer>> edges, int s) {
    // Write your code here
     List<List<int[]>> graph = new ArrayList<>();
    for (int i = 0; i <= n; i++) {
        graph.add(new ArrayList<>());
    }

    // Build adjacency list (undirected)
    for (List<Integer> edge : edges) {
        int u = edge.get(0);
        int v = edge.get(1);
        int w = edge.get(2);
        graph.get(u).add(new int[]{v, w});
        graph.get(v).add(new int[]{u, w});
    }

    int[] dist = new int[n + 1];
    Arrays.fill(dist, Integer.MAX_VALUE);
    dist[s] = 0;

    PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[1]));
    pq.offer(new int[]{s, 0});

    boolean[] visited = new boolean[n + 1];

    while (!pq.isEmpty()) {
        int[] curr = pq.poll();
        int u = curr[0];
        int d = curr[1];

        if (visited[u]) continue;
        visited[u] = true;

        for (int[] neighbor : graph.get(u)) {
            int v = neighbor[0];
            int weight = neighbor[1];

            if (!visited[v] && dist[u] + weight < dist[v]) {
                dist[v] = dist[u] + weight;
                pq.offer(new int[]{v, dist[v]});
            }
        }
    }

    List<Integer> result = new ArrayList<>();
    for (int i = 1; i <= n; i++) {
        if (i == s) continue;
        result.add(dist[i] == Integer.MAX_VALUE ? -1 : dist[i]);
    }

    return result;
}
}

Prim's(MST): Special Subtree

hyunmin43240 — Mon, 5 May 2025 15:59:16 +0900

https://www.hackerrank.com/challenges/primsmstsub/problem?isFullScreen=true

public static int prims(int n, List<List<Integer>> edges, int start) {
    // Write your code here
        
        List<List<int[]>> graph = new ArrayList<>();
    for (int i = 0; i <= n; i++) graph.add(new ArrayList<>());
    for (List<Integer> edge : edges) {
        int u = edge.get(0), v = edge.get(1), w = edge.get(2);
        graph.get(u).add(new int[]{v, w});
        graph.get(v).add(new int[]{u, w}); 
    }

    boolean[] visited = new boolean[n + 1];
    PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[1]));
    pq.offer(new int[]{start, 0});
    int totalWeight = 0;

    while (!pq.isEmpty()) {
        int[] curr = pq.poll();
        int node = curr[0], weight = curr[1];
        if (visited[node]) continue;
        visited[node] = true;
        totalWeight += weight;

        for (int[] neighbor : graph.get(node)) {
            int nextNode = neighbor[0], nextWeight = neighbor[1];
            if (!visited[nextNode]) {
                pq.offer(new int[]{nextNode, nextWeight});
            }
        }
    }

    return totalWeight;
        
    }

Kruskal(MST) : Really Special Subtree

hyunmin43240 — Mon, 5 May 2025 15:16:29 +0900

https://www.hackerrank.com/challenges/kruskalmstrsub/problem?isFullScreen=true

public static int kruskals(int gNodes, List<Integer> gFrom, List<Integer> gTo, List<Integer> gWeight) {
        class Edge implements Comparable<Edge> {
        int u, v, weight;

        Edge(int u, int v, int weight) {
            this.u = Math.min(u, v); 
            this.v = Math.max(u, v);  
            this.weight = weight;
        }

        public int compareTo(Edge other) {
            if (this.weight != other.weight) {
                return this.weight - other.weight;
            } else if (this.u != other.u) {
                return this.u - other.u;
            } else {
                return this.v - other.v;
            }
        }
    }

    class UnionFind {
        int[] parent;

        UnionFind(int n) {
            parent = new int[n + 1]; // 1-based indexing
            for (int i = 1; i <= n; i++) parent[i] = i;
        }

        int find(int x) {
            if (parent[x] != x) parent[x] = find(parent[x]);
            return parent[x];
        }

        boolean union(int a, int b) {
            int rootA = find(a);
            int rootB = find(b);
            if (rootA == rootB) return false;
            parent[rootB] = rootA;
            return true;
        }
    }

    List<Edge> edges = new ArrayList<>();
    for (int i = 0; i < gFrom.size(); i++) {
        edges.add(new Edge(gFrom.get(i), gTo.get(i), gWeight.get(i)));
    }

    Collections.sort(edges);

    UnionFind uf = new UnionFind(gNodes);
    int totalWeight = 0;
    int edgeCount = 0;

    for (Edge edge : edges) {
        if (uf.union(edge.u, edge.v)) {
            totalWeight += edge.weight;
            edgeCount++;
            if (edgeCount == gNodes - 1) break;
        }
    }

    return totalWeight;
    }
}

BFS

hyunmin43240 — Mon, 5 May 2025 13:27:20 +0900

https://www.hackerrank.com/challenges/bfsshortreach/problem?isFullScreen=true

//Hackerrank Breadth First Search: Shortest Reach
import java.util.*;
class Result {

    public static List<Integer> bfs(int n, int m, List<List<Integer>> edges, int s) {
        // Write your code here
        List<List<Integer>> graph = new ArrayList<>();
        for (int i = 0; i <= n; i++) {
            graph.add(new ArrayList<>());
        }

        for (List<Integer> edge : edges) {
            int u = edge.get(0);
            int v = edge.get(1);
            graph.get(u).add(v);
            graph.get(v).add(u);
        }

        int[] distances = new int[n+1];
        Arrays.fill(distances, -1);
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(s);
        distances[s] = 0;

        while (!queue.isEmpty()) {
            int curr = queue.poll();
            for (int neighbor : graph.get(curr)) {
                if (distances[neighbor] == -1) {
                    distances[neighbor] = distances[curr] + 6;
                    queue.offer(neighbor);
                }
            }
        }
        List<Integer> result = new ArrayList<>();
        for (int i =1; i <= n; i++) {
            if (i != s) {
                result.add(distances[i]);
            }
        }
        return result;
    }
}

알고리즘 스터디 6주차

hyunmin43240 — Fri, 11 Apr 2025 13:01:19 +0900

Graph Theory - Synchronous Shopping

import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.regex.*;

class Result {

    /*
     * Complete the 'shop' function below.
     *
     * The function is expected to return an INTEGER.
     * The function accepts following parameters:
     *  1. INTEGER n
     *  2. INTEGER k
     *  3. STRING_ARRAY centers
     *  4. 2D_INTEGER_ARRAY roads
     */

    public static int shop(int n, int k, List<String> centers, List<List<Integer>> roads) {
    // Write your code here
    int[] fishAtCenter = new int[n + 1];
    for (int i = 0; i < n; i++) {
        String[] items = centers.get(i).split(" ");
        int fishMask = 0;
        for (int j = 1; j < items.length; j++) {
            int fishType = Integer.parseInt(items[j]);
            fishMask |= (1 << (fishType - 1)); // 물고기 종류를 비트로 마킹
        }
        fishAtCenter[i + 1] = fishMask;
    }

    // 2. 그래프 만들기 (인접 리스트)
    List<List<int[]>> graph = new ArrayList<>();
    for (int i = 0; i <= n; i++) {
        graph.add(new ArrayList<>());
    }

    for (List<Integer> road : roads) {
        int u = road.get(0);
        int v = road.get(1);
        int time = road.get(2);
        graph.get(u).add(new int[]{v, time});
        graph.get(v).add(new int[]{u, time});
    }

    // 3. 다익스트라 준비 (dist[노드번호][물고기상태] = 시간)
    int[][] dist = new int[n + 1][1 << k];
    for (int[] row : dist) Arrays.fill(row, Integer.MAX_VALUE);

    PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
    int startFish = fishAtCenter[1];
    dist[1][startFish] = 0;
    pq.offer(new int[]{0, 1, startFish}); // {시간, 노드번호, 물고기상태}

    // 4. 다익스트라 실행
    while (!pq.isEmpty()) {
        int[] cur = pq.poll();
        int time = cur[0];
        int u = cur[1];
        int fishMask = cur[2];

        if (dist[u][fishMask] < time) continue;

        for (int[] edge : graph.get(u)) {
            int v = edge[0];
            int cost = edge[1];
            int newFishMask = fishMask | fishAtCenter[v];
            int newTime = time + cost;

            if (dist[v][newFishMask] > newTime) {
                dist[v][newFishMask] = newTime;
                pq.offer(new int[]{newTime, v, newFishMask});
            }
        }
    }

    // 5. 최종 목적지(n)에서 가능한 모든 물고기 상태 조합 중 최소값 찾기
    int minTime = Integer.MAX_VALUE;
    int allFish = (1 << k) - 1;

    for (int i = 0; i < (1 << k); i++) {
        for (int j = 0; j < (1 << k); j++) {
            if ((i | j) == allFish) {
                int maxTime = Math.max(dist[n][i], dist[n][j]);
                minTime = Math.min(minTime, maxTime);
            }
        }
    }

    return minTime;
        }

    }

public class Solution {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));

        String[] firstMultipleInput = bufferedReader.readLine().replaceAll("\\s+$", "").split(" ");

        int n = Integer.parseInt(firstMultipleInput[0]);

        int m = Integer.parseInt(firstMultipleInput[1]);

        int k = Integer.parseInt(firstMultipleInput[2]);

        List<String> centers = new ArrayList<>();

        for (int i = 0; i < n; i++) {
            String centersItem = bufferedReader.readLine();
            centers.add(centersItem);
        }

        List<List<Integer>> roads = new ArrayList<>();

        for (int i = 0; i < m; i++) {
            String[] roadsRowTempItems = bufferedReader.readLine().replaceAll("\\s+$", "").split(" ");

            List<Integer> roadsRowItems = new ArrayList<>();

            for (int j = 0; j < 3; j++) {
                int roadsItem = Integer.parseInt(roadsRowTempItems[j]);
                roadsRowItems.add(roadsItem);
            }

            roads.add(roadsRowItems);
        }

        int res = Result.shop(n, k, centers, roads);

        bufferedWriter.write(String.valueOf(res));
        bufferedWriter.newLine();

        bufferedReader.close();
        bufferedWriter.close();
    }
}

비트마스킹 개념

다익스트라 방식

int[][] dist = new int[n + 1][1 << k];

for (int[] row : dist) Arrays.fill(row, Integer.MAX_VALUE);

PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));

int startFish = fishAtCenter[1];

dist[1][startFish] = 0;

pq.offer(new int[]{0, 1, startFish});

알고리즘 스터디 5주차

hyunmin43240 — Thu, 3 Apr 2025 10:10:58 +0900

11286

import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.Comparator;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>() {

            @Override
            public int compare(Integer a, Integer b) {
                int absA = Math.abs(a);
                int absB = Math.abs(b);

                if (absA == absB) {
                    return a - b;  // 실제 값 비교
                }
                return absA - absB;  // 절댓값 비교
            }
        });

        int N = scanner.nextInt();

        for (int i = 0; i<N; i++) {
            int z = scanner.nextInt();
            if (z != 0) {
                pq.add(z);
            } else {
                if (pq.isEmpty()) {
                    System.out.println(0);
                } else {
                    System.out.println(pq.poll());
                }
            }
        }
            
    }
}

1966

1929

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int M = scanner.nextInt();
        int N = scanner.nextInt();

        for (int num = M ; num <= N ; num++) {
            if (isPrime(num)) {
                System.out.println(num);
                }
            }
    }

    public static boolean isPrime(int n) {
        if (n < 2) return false;

        for (int i =2; i <= Math.sqrt(n); i++) {
            if (n % i ==0) return false;
        }

        return true;
    }
}

1850

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        long num1 = scanner.nextLong();
        long num2 = scanner.nextLong();

        long gcd = getGCD(Math.max(num1, num2), Math.min(num1, num2));

        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= gcd; i++) sb.append("1");

        System.out.println(sb.toString());
    }

    public static long getGCD(long a, long b) {
        while (b > 0) {
            long tmp = a;
            a = b;
            b = tmp % b;
        }
        return a;
    }
}

알고리즘 스터디 4주차

hyunmin43240 — Sat, 29 Mar 2025 21:27:04 +0900

스택 & 큐 [1874, 2164]

1874

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.Stack;
 
public class Main {
	public static void main(String[] args) throws IOException {
		
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringBuilder sb = new StringBuilder();	// 출력할 결과물 저장
		
		Stack<Integer> stack = new Stack<>();
		
		int N = Integer.parseInt(br.readLine());
		
		int start = 0;
		
		// N 번 반복
		while(N -- > 0) {
			
			int value = Integer.parseInt(br.readLine());
			
			if(value > start) {
				// start + 1부터 입력받은 value 까지 push를 한다.
				for(int i = start + 1; i <= value; i++) {
					stack.push(i);
					sb.append('+').append('\n');	// + 를 저장한다. 
				}
				start = value; 	// 다음 push 할 때의 오름차순을 유지하기 위한 변수 초기화 
			}
			
			// top에 있는 원소가 입력받은 값과 같이 않은 경우  
			else if(stack.peek() != value) {
				System.out.println("NO");
				return;		// 또는 System.exit(0); 으로 대체해도 됨. 
			}
			
			stack.pop();
			sb.append('-').append('\n');
			
		}
		
		System.out.println(sb);
	}
}

2164

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

// The main method must be in a class named "Main".
class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt(); 
        Queue<Integer> queue = new LinkedList<>();
        
        for (int i = 1; i<=n; i++)
            queue.add(i);


        while(queue.size() > 1) {
        queue.poll();
        int val = queue.peek();
        queue.poll();
        queue.add(val);
        }
        System.out.println(queue.peek());
        
    }
}

탐욕 알고리즘 [11047, 1541]

11047

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

// The main method must be in a class named "Main".
class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt(); 
        int k = sc.nextInt();

        int[] coin = new int[n];

        for(int i=0; i < n; i++) {
            coin[i] = sc.nextInt();
        }

        int count = 0;

        for(int i =n-1; i >= 0; i--) {
            if(coin[i] <= k) {
                count += (k/coin[i]);
                k = k%coin[i];
            }
        }
        System.out.println(count);
    }
}

1541

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

// The main method must be in a class named "Main".
class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int sum = 0;
        String[] subtraction = sc.nextLine().split("-");

        for (int i = 0; i < subtraction.length; i++) {
            int temp = 0; 

            String[] addition = subtraction[i].split("\\+");
            for(int j = 0; j < addition.length; j++) {
				temp += Integer.parseInt(addition[j]);
			}

            if ( i== 0) {
                sum += temp;
            } else {
				sum -= temp;
            }
		}
        
		System.out.println(sum);
        }
    }

재귀, 자기호출 (recursion)

hyunmin43240 — Tue, 8 Oct 2024 15:21:34 +0900

재귀는 '내 안의 나를 찾는것' -> 성격은 같고 크기만 작은 나를 찾아 큰 나와 작은 나가 연결된 관계를 드러내는 것 즉, 자기 자신을 호출하는 방법

예시) 팩토리얼 계산

public class RecursionExample {
	public static int factorial(int n) {
		if (n==1) {
    		return 1;
    	} else {
    		return n* factorial (n-1);
    	}
	}

	public static void main(String[] args) {
    	int number = 5;
        int result = factorial(number);
        System.out.prntln(result);
    }
}

예시) 피보나치 수열

public class FibonacciRecursion {
	public static int fibonacci(int n) {
    	if (n ==1 || n==2) {
        	return 1;
        } else {
        	return fibonacci(n-1) + fibonacci(n-2);
        }
    }

예시) 하노이 탑

move( n, a, b, c):
	if (n > 0 )
    	move(n-1, a,c,b)
        a 에 있는 원반을 b로 옮긴다
        move(n-1, c, b, a)

move(n, a, b, c) 를 수행하는 과정에서 move(0, ...)이 총 2^n번이나 호출된다. 왜..? 설명해주실 분?

큐 (Queue)

hyunmin43240 — Mon, 23 Sep 2024 23:09:16 +0900

선입선출(First in first out) - 큐

후입선출(Last in First out) - 스택

배열 큐 객체의 구조

필드

- queue[] - 큐의 원소들이 저장되는 배열

- numItems - 큐의 총 원소 수 저장

- front - 큐의 맨 앞 원소의 인덱스

- tail - 큐의 맨 뒤 원소의 인덱스

매소드

- enqueue(x) - 큐의 끝에 원소 x를 삽입한다.

- dequeue() - 큐의 맨 앞에 있는 원소를 알려주고 삭제한다.

- front() - 큐의 맨 앞에 있는 원소를 알려준다.

- isEmpty() - 큐가 비어 있는지 알려준다.

- dequeueALL() - 큐를 깨끗이 청소한다.

tail이 할당받은 배열 공간의 맨 끝에 오면 큐가 꽉 찬 상태라 여김 -> 공간의 비효율 생김

-> 배열을 원형으로 해석함으로 해결가능

나머지로 해석

tail <- (tail+1)%queue.length

front <-(tail+1)%queue.length

연결 리스트 큐의 구조

필드

- tail - 큐의 맨 뒤 원소의 인덱스

매소드

- enqueue(x) - 큐의 끝에 원소 x를 삽입한다.

- dequeue() - 큐의 맨 앞에 있는 원소를 알려주고 삭제한다.

- front() - 큐의 맨 앞에 있는 원소를 알려준다.

- isEmpty() - 큐가 비어 있는지 알려준다.

- dequeueALL() - 큐를 깨끗이 청소한다.

연결 리스트 큐의 구조 또한 원형으로 이루어져 있다 tail 이 가르키는 다음 노드가 front를 가르키고 있다.

원소 삽입의 경우 -> tail 이 newnode를 가르키게 되며 그 노드가 front를 가르키게 된다.

원소 삭제의 경우 -> tail 이 가르키는 노드가 front 노드 다음 노드를 가르키게 한다.

클래스 LinkedList 상속

public class InheritedQueue<E> extends LinkedList<E>

implements QueueInterface<E> {....

public InheritedQueue<> {

super();

}

import java.util.LinkedList;

public class Main {
    public static void main(String[] args) {
        // LinkedList 선언
        LinkedList<String> list = new LinkedList<>();
        
        // 데이터 추가 (맨 뒤에 추가)
        list.add("A");
        list.add("B");
        list.add("C");
        
        // 리스트 출력
        System.out.println(list);  // 출력: [A, B, C]
        
        // 첫 번째에 데이터 추가
        list.addFirst("Start");
        
        // 마지막에 데이터 추가
        list.addLast("End");
        
        // 리스트 출력
        System.out.println(list);  // 출력: [Start, A, B, C, End]
        
        // 데이터 삭제
        list.remove(2);  // 인덱스 2의 요소(B) 삭제
        System.out.println(list);  // 출력: [Start, A, C, End]
        
        // 첫 번째 요소 가져오기
        System.out.println(list.getFirst());  // 출력: Start
        
        // 마지막 요소 가져오기
        System.out.println(list.getLast());  // 출력: End
    }
}

큐 응용: 좌우동형 문자열 체크

package queue;
import stack.LinkedStack;

public class Palindrom {
	private static boolean isPalindrom(String A) {
    	LinkedStack s = new LinkedStack();
        LinkedQueue q = new LinkedQueue();
        for(int i=0; i < A.length(); i++) {
        	s.push(A.charAt(i));
            q.enqueue(A.charAt(i));
        }
        while(!s.isEmpty() && s.pop() == q.dequeue()) {
        }
        if(s.isEmpty()) return true;
        else return false;
    }
    
    public static void main(String[] args) {
    	System.out.println("Palindrom Check!");
        String str = "lioninoil";
        boolean t = isPalindrom(str);
        System.out.println(str + " is Palindrom?: " + t);
    }
}

스택(Stack)

hyunmin43240 — Thu, 8 Aug 2024 14:57:53 +0900

LIFO(Last-in-first-out) - 후입선출

(스택의 방식)

FIFO(First-in-first-out) - 선입선출

(큐의 방식)

스택의 개념과 원리

- push

- pop

- top

배열을 이용한 스택 객체 구조

- stack[] -> 스택의 원소들이 저장되는 배열

- topIndex -> 스택 탑 원소 자리의 인덱스

- push() -> 스택의 맨 위에 원소 x를 삽입한다

- pop() -> 스택의 맨 위에 있는 원소를 알려주고 삭제한다

- top() -> 스택의 맨 위에 있는 원소를 알려준다

- isEmpty() -> 스택이 비었는지 알려준다

- popAll() -> 스택을 깨끗이 청소한다

package stack;

public interface StackInterface<E> {
	public void push(E newItem);
    public E pop();
    public E top();
    public boolean isEmpty();
    public void popAll();
}

public class ArrayStack<E> implements StackInterface<E> {
	private E stack[];
    private int topIndex; // 스택의 탑 인덱스
    private static final int DEFAULT_CAPACITY = 64;
    private final E ERROR = null; //임의의 에러 값
    
    public ArrayStack() {
    	stack =(E[]) new Object[DEFAULT_CAPACITY];
        topIndex = -1;
    } //생성자 1
    
    public ArrayStack(int n) {
    stack = (E[]) new Object[n];
    topIndex = -1;
    } // 생성자 2 
    
    // 스텍에 원소 x 삽입하기
    public void push(E newItem) {
    	stack[++topIndex] = newItem;
    }
    
    //스택에서 원소 삭제하기
    public E pop() {
    	if (isEmpty()) return ERROR;
        else return stack[topIndex--];
    }
    
    //스택 탑 원소 알려주기
    public E top() {
    if (isEmpty()) return ERROR;
    else return stack[topIndex];
    }
   
    // 스택이 꽉 찼는지 확인하기
    public boolean isEmpty() {
    	return(topIndex<0);
    }
    
    // 스택이 비었는지 확인하기
    public boolean isFull() {
    	return (topIndex == stack.length-1);
    }
    
    // 스택 비우기
    public void popAll() {
    	stack = (E[]) new Object[stack.length];
        topIndex = -1;
    }
}

연결리스트 스택 객체 구조

- topNode -> 스택 탑 원소를 가리키는 래퍼런스

- push() -> 스택의 맨 위에 원소 x를 삽입한다

- pop() -> 스택의 맨 위에 있는 원소를 알려주고 삭제한다

- top() -> 스택의 맨 위에 있는 원소를 알려준다

- isEmpty() -> 스택이 비었는지 알려준다

- popAll() -> 스택을 깨끗이 청소한다

배열을 이용한 스택 구조와 다른점: 배열 스택에서는 삽입 시 스택이 꽉 차 있으면 삽입을 못 했는데 연결 리스트 스택에서는 노드를 만들어 붙이므로 삽입을 못 하는 경우는 없다. 새로 만든 노드를 newNode 라고 함.

push(x):

newNode.item <- x

newNode.next <- topNode

topNode <- newNode

스택에서 삽입할때는 항상 맨 앞에서 일어나기에 topNode 로 래퍼런스가 되어있음

package stack;
import list.Node;

public class LinkedStack<E> implements StackInterface<E> {
	private Node<E> topNode;
    private Final E ERROR = null;
    public LinkedStack() {
    	topNode = null;
    }
    
//스택에 원소 x 삽입하기
public void push(E newItem) {
	topNode = new Node<>(newItem, topNode);
}

//스택에서 원소 삭제하기
public E pop() {
	Node<E> temp = topNode;
    topNode = topNode.next;
    return temp.item;
}

//스택 탑 원소 알려주기
public E top() {
	return topNode.item;
}

//스택이 비었는지 확인하기
public boolean isEmpty() {
	return (topNode ==null);
}

//스택 비우기
public void popAll() {
	topNode = null;
}

클래스 '연결 리스트' 상속

5장에서 만들어 놓은 클래스 LinkedList<E>를 상속받아 재사용한다

public class inheritedStack<E> extends LinkedList<E> implements StackInterface<E> {

스택 응용

1. 문자열 뒤집기

- 스택의 특성을 이용해 문자열을 스택에 넣고 반대로 빼면서 나열하면 처음 문자열의 뒤집힌 형태가 나오게 된다.

package stack; 

public class ReverseString {

	public static void main(String[]args) {
    	String input = "Test seq 12345";
        String t = reverse(input);
        System.out.println("input string: " + input);
        System.out.println("Reversed string; " + t);
    }
    
    private static String reverse(String s) {
    	ArrayStack<Character> st = new ArrayStack<>(s.length());
        for(int i = 0; i< s.length(); i++)
        	st.push(s.charAt(i)); // s의 i번 문자. 번호는 0부터 시작
        String output = "";
        while(!st.isEmpty())
        	output = output + st.pop();
        return output;
    }
}

Postfix 계산

예시)

47* = 4*7

472+* = 4*(7+2)

47*20-=(4*7)-20

347*2/+ = 3+((4*7) /2)

1. 문자가 숫자 -> push()통해 스택에 삽입

2. 문자가 연산자 -> 스택의 맨 위에 있는 수 2개 pop 계산 후 스택에 push

3. 공백이면 무시

package stack;

public class PostfixEval {
	public static void main(String[] args) {
    	String postfix = "700 3 47 + 6*-4/";
        System.out.println("input string: " + postfix);
        int answer = evaluate(postfix);
        System.out.println("Answer: " + answer);
    }
    
    private static int evaluate(String postfix) {
    	int A, B;
        LinkedStack<integer> s = new LinkedStack<>();
        boolean digitPreviously = false;
        for (int = 0; i < postfix.length(); i++) {
        	char ch = postfix.charAt(i);
            if (Character.isDigit(ch)) {
            	if (digitPreviously == true) {
                	int tmp= s.pop();
                    tmp = 10*tmp + (ch-'0');
                    s.push(tmp);
                    } else s.push(ch-'0');
                    digitPreviously = true;
                    } else if (isPperator(ch)) {
                    A = s.pop();
                    B = s.pop();
                    int val = operation (A, B, ch);
                    s.push(val);
                    digitPreviously = false;
                  } else digitPreviously = false;
              }
              return s.pop();
          }
          
          private static int operation (int a, int b, char ch) {
          	int val = 0;
            switch (ch) {
            case'*':
            	val = b*a;
                break; 
            case '/':
            	val = b/a;
                break;
             case '+':
             	val = b + a;
                break;
             case '-':
             	val = b-a;
                break;
                
             }
             return val;
         }
         
         private static boolean isOperator(char ch) {
         	return ch == '+' || ch == '-' || ch == '*' || ch== '/';
         }
 }