✨스택✨

/*스택을 구현하는 구조체*/
typedef struct {
    int max; //스택용량
    int num; //스택에 쌓여있는 데이터의 개수(스택 포인터)
    char *stk;//스택의 첫 요소에 대한 포인터
}IntStack;

/*스택 초기화*/
void Initialisze(IntStack *stack,int max){
    stack->num = 0;
    stack->stk = malloc(max*sizeof(int));
    /*
    인자로 받은 스택 용량 만큼,
    인자로 받은 배열이 가리키는 스택의 첫 요소에 대한 포인터를 동적할당한다.
    */

    //동적할당 실패 시
    if((stack->stk)==NULL){stack->max = 0;return ;}

    //동적할당 성공 시
    stack->max = max;
    return ;
}

/*스택에 데이터를 푸시*/
void Push(IntStack *stack,char wrd){
    //stack의 top에 데이터를 추가한다. 
    //stack이 이미 꽉 차있으면 해당 데이터 는 스택에 저장하지 않고 “Stack FULL”을 출력한다.
    printf("Pushing....\n");

    if(IsFull(stack) == 1){
        puts("Stack FULL");
        return ;
    }
    printf(">>>stack->num = %d\n",stack->num);
    stack->stk[stack->num ++] = wrd;
    //인자로 받은 배열이 가리키는 배열의 num인덱스에 해당하는 공간에 데이터를 저장
    //이후 인덱스를 증가시킴
}

/*스택에 데이터를 팝 == 꺼냄*/
char Pop(IntStack *stack){
    //pop (stack) : stack의 top에 있는 데이터를 반환하고 stack에서 제거한다. 
    //stack이 비어 있 으면 “Stack Empty”를 출력한다.
    if(IsEmpty(stack) == 1) {
        puts("Stack Empty");
        return -1;
    }
    char del = stack->stk[stack->num --];
    //인자로 받은 배열이 가리키는 배열의 num 인덱스에 해당하는 데이터 값을 포인터 del의 참조값으로 저장
    //이후 인덱스를 감소하고 종료
    return del;
}

/*스택에서 데이터를 피크 == 확인*/
void Peek(IntStack *stack){
    //peek(stack): stack의 top에 있는 데이터를 화면에 출력한다. 
    //stack은 변화하지 않는다. stack이 비어 있으면 “Stack Empty”를 출력한다.
    if(IsEmpty(stack) == 1) {
        puts("Stack Empty");
        return ;
    }
    printf("%c\n",stack->stk[stack->num -1]);
    //인자로 받은 배열이 가리키는 배열의 (num-1) 인덱스에 해당하는 값을 포인터 pek의 참조값을 저장
}

/*스택의 모든 데이터 출력*/
void Print(IntStack *stack){
    for(int i=stack->num-1;i>=0;i--) printf("%c",stack->stk[i]);
    //스택의 데이터 수 만큼 반복하여 스택의 데이터를 출력
    printf("\n");
}

/*스택이 비어있는지의 유무*/
int IsEmpty(IntStack *stack){
    return (stack->num <= 0);
    //스택의 데이터 개수가 0보다 작거나 같으면 1
    //스택의 데이터 개수가 0보다 크면 0

    //스택이 비어있으면(데이터 개수가 0 이하) 1을 반환
}

/*스택이 가득 찼는지의 유무*/
int IsFull(IntStack *stack){
    return( stack-> num >= stack->max);
    //스택의 데이터 개수가 스택의 최대 용량보다 많으면 1 반환
    //스택의 데이터 개수가 스택의 최대 용량보다 적으면 0 반환
    //PUSH
}

int duplicate(IntStack *stack){
    //stack의 top에 있는 데이터를 pop해서 두 번 push 한다. 
    //stack이 이미 꽉 차있으면 “Stack FULL”을 출력한다.
    if(IsFull(stack) == 1){
        puts("Stack FULL");
        return -1;
    }
    Push(stack,Pop(stack));
    Push(stack,Pop(stack));

    return 0;
}

int Size(IntStack *stt){return (stt->num);}

void upRotate(IntStack *stack, int n){
    //stack의 맨 위 n 개의 데이터를 회전시킨다. 
    //단, n이 데이터의 개수보다 큰 경우에는 아무 작업을 하지 않는다.
    if( n <= Size(stack)) {
        int save = stack->stk[stack->num-1];
        for(int i=0;i<(n-1);i++){
            stack->stk[(stack->num-1) - i] = stack->stk[(stack->num-1) - i-1];
        }
        stack->stk[(stack->num-1) - (n-1)] = save;
        // printf(">>>");
        // Print(stack);
    }
}

void downRotate(IntStack *stack, int n){
    //stack의 맨 위 n 개의 데이터를 회전시킨다. 
    //단, n이 데이터의 개수보다 큰 경우에는 아무 작업을 하지 않는다.
    if( n <= Size(stack)){
        int save = stack->stk[0];
        for(int i=0;i<(n-1);i++){
            stack->stk[i] = stack->stk[i+1];
        }
        stack->stk[n-1] = save;//PUSH
    }
}

int main(){
}