프로그래머스 레벨2 뒤에 있는 큰 수 찾기 C#(JAVA) peek, pop, push

Stack을 이용하는 거다.

 

C#기준으로 stack은 LIFO 개념인데, Last In First Out이다. 마지막에 들어간 게 처음으로 나온다는 의미이다.

push는 스택에 값을 때려박는 거고 pop는 맨 위에 있는 값(마지막에 들어간 값)을 리턴하면서 그걸 삭제하는 개념인 듯하다.

peek는 가장 top에 위치한 값을 리턴하는데 pop이랑은 다르게 삭제하지는 않는 방식인 거 같다.

2중 for문을 방지하기 위해서 stack을 활용한다.

s.Peek < [i]

리셋하기 위해서 s.Pop도 쓴다.

 

 

 

C#

 

 

 

public class Solution {
    public int[] solution(int[] numbers) {
        int[] answer = new int[numbers.Length];
        var s = new System.Collections.Generic.Stack<int>();
        
        for (int i = 0; i < numbers.Length; i++) 
        {
            answer[i] = -1;
            
            while (s.Count > 0) 
            {
                if (numbers[s.Peek()] < numbers[i]) 
                {
                    answer[s.Peek()] = numbers[i];
                    s.Pop();
                }
                else 
                {
                    break;
                }
            }
            s.Push(i);
        }
        return answer;
    }
}

 

 

 

using System;
using System.Collections.Generic;
using System.Linq;

public class Solution {
    public int[] solution(int[] numbers) {
        int[] answer = new int[numbers.Length]; 
        Stack<int> stack = new Stack<int>();

        for(int i = numbers.Length-1 ; i>=0 ; i--)
        {
            if(stack.Count ==0)
            {
                answer[i]=-1;
                stack.Push(numbers[i]);
                continue;
            }

            while(stack.Count>0)
            {
                if(stack.Peek()>numbers[i])
                {
                    answer[i]=stack.Peek();
                    stack.Push(numbers[i]);                    
                    break;
                }
                stack.Pop();
            }

            if(answer[i]==0)
            {
                answer[i]=-1;
                stack.Push(numbers[i]);
            }


        }
        return answer;
    }
}

 

 

 

자바

 

 

 

import java.util.*;

class Solution {
    public int[] solution(int[] numbers) {
        Stack<Integer> stack = new Stack<>();
        int[] ret = new int[numbers.length];

        for(int i = 0;i<numbers.length;i++) 
        {
         // 하강 직선일 때는 push
            if(stack.isEmpty() || numbers[i]<numbers[i-1]) 
            {
                 stack.push(i);
            } 

            else 
            {
             // 현재값보다 작은 index는 pop하여 현재값으로
                 while(!stack.isEmpty() && numbers[stack.peek()]<numbers[i]) 
                 {
                     ret[stack.pop()] = numbers[i];
                 }
                stack.push(i);
           }
     }
        // 나머지는 -1
         while(!stack.isEmpty()) 
         {
            ret[stack.pop()] = -1;
         }
     return ret;
    }
}