라이크위키

프로바이오틱스 제품 최저가 알려드립니다. (변비탈출 100% 효과)

나무고딕 — Wed, 28 Jul 2021 22:20:45 +0900

시중에 정말 여러가지 존재하는 프로바이오틱스 제품 중, 어떤 것을 골라야 할 지 너무 고민이시라면 다음 2가지 제품 중 하나를 시도해보시는 것은 어떠시나요?

사실 이미 아시는 분들께서는 아실 만한 유명한 제품들이기는 합니다. 그렇지만, 그 만큼 자신있게 추천드릴 수 있는 프로바이오틱스 상품이기 때문에 오늘 소개를 드리려고 합니다.

※ CFU: "Colony Forming Unit" 의 줄임말로, 유산균의 수를 표기하는 단위를 말합니다.

1. 락토비프 프로바이오틱스 (300억 CFU, 60정)

최저가 바로가기 (클릭)

캘리포니아 골드 뉴트리션(California Gold Nutrition) 회사에서 제작한 프로바이오틱스 제품으로, 가성비가 좋다고 알려져서 이미 굉장히 많은 사람들에게 사랑받는 제품입니다.

하루에 1번 1정, 음식과 함께 혹은 공복에 섭취하는 제품이기 때문에 총 2개월 분입니다.

가격은 한화로 23,040원으로 300억이라는 유산균 수에 비해 굉장히 합리적입니다.

안전 밀봉 방식으로, 냉장 보관이 필요 없도록 제작이 되었기 때문에 휴대가 간편하고 섭취하기도 쉽습니다.

60정 ⇒ 23,040원
300억 CFU
캡슐 형태
냉장 보관 X
낱개 포장 O

2. 프로바이오틱 베지 캡슐 (500억 CFU, 30정)

헬시바이옴(Healthybiom) 이라는 회사에서 제작한 프로바이오틱 베지캡슐 제품으로, 가성비가 아주 좋은 제품 중 하나입니다.

하루에 1번 1정, 음식과 함께 혹은 공복에 섭취하는 것으로 총 1개월 분 들어있습니다.

가격은 한화로 14,960원으로 500억이라는 유산균 수를 고려하면 굉장히 합리적인 가격입니다.

또한 이 제품은 락토바실러스 가세리 성분을 포함한 제품입니다. 락토바실러스 가세리 제품을 찾으시는 분에게는 딱 맞는 제품일 것입니다.

낱개 포장 방식이 아니며, 냉장 보관이 필요하다는 점은 조금 불편하지만, 꽉 찬 성분으로 구성되어 있습니다. 집에 두고 꾸준히 드실 분들께서는 적절한 제품이라고 할 수 있습니다.

30정 ⇒ 14,976원
500억 CFU
캡슐 형태
냉장 보관 O
낱개 포장 X
락토바실러스 가세리 성분 포함

아이허브 할인 코드

아이허브에서 구매하실 때에 꼭 고려하셔야 하는 점은 할인 코드입니다

아래 링크를 통해서 할인코드들을 쉽게 알아보실 수 있습니다.

아이허브 할인코드들은 워낙 다양한데요.

일단 이것저것 자동 적용을 해두시면, 여러 할인 코드들 중 가장 할인율이 높은 것으로 적용되어 할인됩니다.

아이허브 전체 할인코드 프로모션 (바로가기)

펜트하우스 시즌3 7회 요약 다시보기

나무고딕 — Sat, 17 Jul 2021 00:33:54 +0900

펜트하우스 시즌3 7회 요약 다시보기

강남 8학군을 천수지구로 이주시키기 위해 강장관을 구워 삶는 중인 주단태 패밀리.

심수련은 강장관과 대립 관계에 있는 차관을 만나서 이를 막는 것을 제안한다.

천서진은 어떠한 이유인지는 모르겠지만, 로건을 살리려고 하윤철을 이용한다.

"그래, 주단태로 오해해. 그게 내가 원하는 바야"

단순히 주단태와 하윤철을 이간질하기 위함일까..?

심수련과 강마리는 배채식을 협박하여 건축 포기 각서를 작성한다.

강마리 남편은 제시카라는 이름을 듣고 마리에게 가서 주단태와 대립하지 말 것을 이야기 하지만, 강마리는 이를 거절하고 한 소리를 한다.

주석경은 이태리로 유학갈 것이라면서 주석훈에게 전화하고, 석훈이는 석경이에게 그걸 이제 이야기 하나면서, 우리가 가족이냐며 화를 낸다. 공항으로 나와달라고 석훈이에게 말을 하지만, 네 마음대로 살 것이면 연락하지 말라며 화를 내고 전화를 끊는다.

석훈이는 석경이의 유학 소식을 심수련에게 말하면서 로나 엄마의 살인범을 찾는 것을 자신도 돕겠다며 나선다. 하지만, 수련은 이를 거절하면서, 로나 엄마의 살인에 주단태가 관련되어있을지도 모른다는 이야기를 꺼낸다. 그리고 주석훈은 이 이야기에 충격을 받고 자리를 떠난다.

천서진은 하윤철에게 은별이의 사진을 보내면서 협박을 한다.

주단태는 심수련 앞에 나타나면서 비아냥 거리고 심수련은 "네가 여긴 어쩐 일이냐면서 화를 낸다."

로나는 오디션에 떨어지고서도 열심히 도서관에서 다음을 준비한다. 제니는 로나를 데리고 떡볶이를 먹으러 간다.

천서진은 은별이를 세계 무대에 내보내기 위한 서포트를 하겠다는 이야기를 하며, 자신을 뛰어넘어야 한다는 이야기를 한다. 그래야 자신이 보상받을 수 있다는 것을 강조하면서 은별이가 잘 해낼 것이라면서 미소짓는다. 은별이는 아직 기억을 못하는 상태로 기뻐하면서 천서진 품에 안긴다.

천수지구 입찰을 위해서 500억의 돈이 필요한 주단태는 천서진에게 부탁을 한다.

청아그룹 주식 10프로를 넘기는 조건으로 천서진은 이를 받아들인다.

주단태 일행은 여러가지 공약 조건을 내세우면서, 조합원들을 구슬리는 사업계획을 발표한다.

크라크 리 이라는 유명한 지휘자에게 은별이를 보여주기 위한 만반의 준비를 하고 크라크 리의 기자회견 당일이 된다.

기자회견과 인터뷰가 마무리되고 크라크 리를 데리고 자리를 옮겨 은별이를 소개해주려는 타이밍에, 노랫소리가 울려퍼진다.

관심을 표하면서 다가간 크라크 리는 배로나를 발견하게 된다.

완벽한 하이에프를 구현하는 배로나는 배로나에게 기회를 줄 것을 천서진에게 요구한다.

크라크 리에게 제대로 눈도장을 찍은 배로나는 많은 기자들 앞에서 천서진이 자신에게 기회를 줄 수밖에 없는 상황을 만든다.

배로나는 완벽한 피치의 하이에프를 구현했던 윤희의 과거를 이야기 하면서 천서진을 도발한다.

진쌤한테 연락하는 은별이..

크라크리는 심수련과 함께 식사를 하면서 배로나의 이야기를 꺼내고, 심수련은 배로나와 관련해서 어떠한 부탁을 하게 된다.

은별이에게 가는 길인 진분홍을 붙잡는 배로나

실랑이하는 와중에 어떤 약을 발견한다.

약을 전해주는 진분홍. 약이 부족하다면서 짜증을 내고 일어서는데 갑자기 은별이가 쓰러진다.

잠시 쓰러졌다가 정신을 차린 은별이는 방금 전의 상황을 기억하지 못하고 되묻는다.

무슨 약인지는 아직 정체가 밝혀지지 않았지만, 그 부작용으로 은별이는 중독 증세와 단기기억 상실의 증상을 보이는 것처럼 보인다.

진분홍은 연락이 되지 않는 주단태를 찾아가서 화를 내고, 이런 모습을 석훈이가 보게 된다. 석훈이는 진분홍이 주단태와 연관되어 있음을 알게 되고 절망한다.

찐단태 앞에 로건의 조부모가 나타난다. 로건과의 약속 때문에 죽을 위험을 각오하면서 이 곳에 왔다는 찐단태는 로건을 찾고 있는 중이라면서 거짓말을 한다.

로건을 찾는 비용으로 쓰라면서 찐단태한테 돈을 건네주고, 찐단태는 로건을 찾고 있지도 않으면서 찾고 있다고 거짓말 하며 그 돈을 받아 처먹는다.

찐단태는 천서진을 찾아가서 협박한다.

천서진은 제임스에게 돈을 받게 되면 그 절반을 주겠다면서 찐단태를 다시 돌려보낸다.

로건을 살리려는 천서진의 목적은 로건의 몸값인 듯 하다.

심수련은 강신모 기획부장관의 룸살롱 접대 영상이 들어있는 영상을 경찰에 넘긴다.

이 영상이 언론 보도를 타게 되면서 주단태가 계획한 천수지구 개발 계획은 전부 틀어지게 된다.

신도시 개발 건설 업체 또한 계획된 대로 진행되지 않게 되면서, 이에 발을 담궜던 사람들이 모두 몰려와서 돈을 갚고 돌려주라면서 화내고 따진다.

계획된대로 전혀 굴러가지 않은 주단태는

도외건설에 최종적으로 1000억을 입금하지 않도록 하면 된다면서 방법을 짜낸다.

해연건설 쪽에서 돈을 빌리려고 송회장을 찾아간 주단태.

송회장은 주단태가 요구한 천억을 빌려주기로 하고, 담보를 요구한다.

한시간 내로 입금하기로 하고, 펜트하우스를 담보로 요구한다. 형식적인 절차라면서 안심을 시키지만, 마리탕에서 강마리와 긴밀한 관계를 가지고 있는 송회장은 무슨 생각이 있어 보인다.

역시나 심수련을 돕고 있었던 송회장. 송회장은 진천댁을 위해서는 무엇이든 하겠다면서 심수련을 도우겠다는 의지를 확실히 표시한다.

주단태는 도외건설의 로비스트를 구워삶기 위해 어렵게 접대자리를 마련한다.

하지만 도외건설의 로비스트는 심수련이었고, 그 사실을 알게 된 주단태는 분노한다.

두 사람은 접대자리에서 치고 박고 싸운다. 싸움 과정에서 주단태는 머리에서 피가 나는데, 피를 보고 발작하면서 쓰러진다.

그러면서 나타나는 주단태(구 백준기)의 과거.

불법 철거업체에서, 가족들이 안에 있는 상태에서 건물을 무너뜨리는 미친 짓을 한다. 주단태(구 백준기)는 눈 앞에서 엄마와 동생을 잃게 된다.

그 때의 트라우마로, 피를 보면 발작을 일으키게 되는 듯 하다.

그 때 가족을 잃었던 그 자리에 펜트하우스를 지었던 주단태(구 백준기)였다.

정신을 잃은 주단태를 끌고간 심수련.

결박된 주단태를 주차장에서 이리저리 차로 위협하면서 자백할 것을 요구한다.

끝까지 잡아떼는 주단태에게 분노한 심수련이 주단태를 죽이려는 순간, 주석훈이 주단태를 구한다.

주단태의 회사로 들어가 일을 배우기로 한 주석훈. 대신 엄마가 다치게 하지 않게 해달라고 요구한다.

로나에게도 이별을 고한다.

아무래도 로나에게 미안한 마음 때문인 것 같아 보인다.

경찰에게 오윤희의 소지품이 발견되었다는 연락이 온다. 심수련은 발견된 스마트워치의 데이터 복구를 맡긴다.

복구된 데이터에서 죽기 전 오윤희가 남긴 진실의 녹음본을 발견하게 된다.

결국, 주석경이 자신의 친딸임을 알게 된 심수련.

한편, 이태리에 유학을 간 것으로 알려진 주석경은 알 수 없는 공간에서 눈을 뜬다. 그 곳은 기도원.

아무래도 주단태가 주석경을 기도원으로 보내버린 듯 하다. 주석경은 성격대로 악을 지르고 물건을 휘두르지만, 그 곳에 있는 사람들이 만만치 않다. 주석경에게 무차별적인 다구리를 시전한다.

(맨 뒤에서 허공에 손을 휘두르시는 분이 시선을 사로잡아 웃겼다 ㅋㅋ)

로건을 살리기 위해 고군분투하는 하윤철.

그러던 중, 로건이 마침내 깨어난다. 그리고 깨어난 로건과 이를 발견한 하윤철, 그리고 이를 지켜보는 천서진의 얼굴을 끝으로 7화가 마무리된다.

포스트바이오틱스 효능과 주의사항에 관한 모든 것

나무고딕 — Thu, 1 Jul 2021 01:45:56 +0900

포스트바이오틱스 효능과 주의사항에 관한 모든 것

프로바이오틱스, 프리바이오틱스에 이어 포스트바이오틱스라는 새로운 바이오틱스가 등장했는데요.

대략 유산균의 한 종류라는 점은 유추할 수 있지만, 정확히 무슨 차이가 있고 어떤 것이 나에게 적합한 것인지는 알지 못하시는 분들이 많습니다.

포스트바이오틱스란?

포스트바이오틱스란 프로바이오틱스로 인해 일어나는 발효과정 중에 생산되는 부산물을 말합니다.

즉, 프로바이오틱스, 프리바이오틱스, 포스트바이오틱스 3가지의 관계를 정의하면 다음과 같습니다.

프로바이오틱스 (Probiotics)	프리바이오틱스 (Prebiotics)	포스트바이오틱스 (Postbiotics)
많은 사람들이 알고 있는 일반적인 유산균을 말합니다. 살아있는 생균이기 때문에 냉장보관이 필수입니다.	프로바이오틱스(유산균) 의 먹이입니다. 프로바이오틱스의 생존과 번식을 돕는 역할을 합니다.	프로바이오틱스(유산군)이 프리바이오틱스를 먹으며 발생하는 발효과정 중에 만들어지는 부산물을 말합니다. 유산균의 대사산물이라고도 합니다. 살아있지 않은 사균이기 때문에 실온 보관이 가능합니다.

포스트바이오틱스의 효능

포스트바이오틱스의 효능은 다음과 같습니다.

1. 유익한 박테리아(프로바이오틱스 등)의 성장에 도움이 됨

포스트바이오틱스는 프로바이오틱스의 번식을 돕는 것 이외에도 프로바이오틱스처럼 중금속 제거를 돕고 바이러스 및 독소를 줄이는 등의 작용을 합니다.

또한, 유익한 박테리아의 성장을 도와서 미숙한 장벽을 가지고 있거나 면역 방어가 손상된 환자들에게 도움이 될 수 있습니다.

2. 유해 병원균 감소에 도움

유해한 박테리아 및 병원균의 감소에 도움을 주기 때문에 감염과 질병 예방에 도움이 될 수 있습니다.

이처럼 포스트바이오틱스는 항균 능력을 가지고 있다는 연구 결과가 있기도 합니다.

3. 항비만, 항염증에 도움

유산균 케이스이디지(LC-DG)를 포함한 프로바이오틱스가 생산한 포스트바이오틱스 물질은 염증/면역 반응을 조절하는 데에 도움이 된다는 연구 결과가 있습니다.

또한 염증 감소 능력 때문에 IBS, IBD 증상 치료를 위해 프로바이오틱스와 포스트바이오틱스를 함께 사용하기도 합니다.

4. 혈당을 낮추어 당뇨 예방에 도움

포스트바이오틱스는 당뇨를 앓는 비만인들의 혈당 수치 감소에 도움을 준다는 연구 결과가 있습니다.

이는 포스트바이오틱스가 인체의 인슐린 사용을 증가시키기 때문입니다. 이 밖에도 지방염 감소, 간 인슐린 저항력 감소를 포함한 효과가 있습니다.

5. 면역력 상승에 도움

포스트바이오틱 박테리아는 소화, 흡수, 영양분의 저장과 발육 및 면역력 증진에 도움이 될 수 있다고 합니다.

포스트바이오틱스 특징

가장 큰 특징은 포스트바이오틱스가 사균이라는 점입니다. 따라서, 생균과는 달리 위산이나 담즙산에 따라 파괴될 위험이 없습니다.

그리고 또한 프로바이오틱스와 달리, 긴 시간 동안 실온 보관이 가능하다는 장점이 있습니다.

포스트바이오틱스 부작용과 주의사항

1. 복통 및 설사가 발생할 수 있습니다.

사람에 따라 다르지만, 복통과 설사가 나타날 수 있습니다. 큰 부작용은 아니지만 유의하시는 것이 좋습니다.

2. 항생제와 최소 2시간 간격을 두고 복용하기

항생제와 동시에 복용하게 된다면, 유익균이 죽을 수 있기 때문에 최소 2시간의 차이를 두고 복용하는 것을 추천드립니다.

3. 변비약과는 함께 복용하지 않도록 하기

장 내에 흡수되어야 하는 유익균이 흡수 전에 배출될 위험이 있기 때문에 변비약과는 함께 복용하지 않도록 합니다.

파이어보이 앤 워터걸 전 시리즈 (1, 2, 3, 4, 5) 게임하기

나무고딕 — Thu, 22 Apr 2021 21:17:29 +0900

파이어보이 앤 워터걸 전 시리즈 (1, 2, 3, 4, 5) 게임하기

기억하시나요?

저는 어렸을 때 특히 이 게임을

정말 즐겨했던 기억이 있는데요.

최근에도 즐겁게 플레이하기도 했습니다.

킬링 타임 용으로는 특히 딱이라,

여러분께도 소개드리고 싶어

가지고 오게 되었어요.

파이어보이(불 소년)과 워터걸(물 소녀)가

게임에서 등장하는데요.

파이어보이는 물에 약하고

워터걸은 불에 약하다는 설정이 있습니다.

게임 조작 방법도 굉장히 간단한데요.

PC에서는 W-A-S-D 와 방향키를 사용하고

모바일에서는 모바일 용 방향 버튼을

사용하면 됩니다.

게임은 하면서 방법을 배우는 거니까요 ㅎㅎ

여러분도 한 번 플레이 해보세요!

링크 남겨놓도록 하겠습니다.

▼▼▼

Fireboy and Watergirl 1 (파이어보이 앤 워터걸 1) - SOK SOK

게임하기 - 파이어보이 앤 워터걸 1 - 파이어보이 앤 워터걸 게임은 많은 이들에게 사랑받는 작품으로 두 캐릭터들(파이어 보이, 워터걸)과 함께 빛나는 다이아몬드를 찾아 나서는 게임입니다.

soksok.co.kr

Fireboy and Watergirl 2 (파이어보이 앤 워터걸 2) - SOK SOK

게임하기 - 파이어보이 앤 워터걸 2 - "빛나는 사원"이라는 새로운 땅과 함께할 것입니다. 파이어보이와 워터걸 길을 찾아야 하는데요. 조명의 방향을 움직여 수위가 끝나는 곳으로 이동할 수 있

soksok.co.kr

Fireboy and Watergirl 3 (파이어보이 앤 워터걸 3) - SOK SOK

게임하기 - 파이어보이 앤 워터걸 3 - 파이어보이와 워터걸(물 소녀)는 북극의 얼음사원으로 여행을 떠납니다. 뜨거운 불꽃을 이용해 얼음을 녹이고 다이아몬드를 모아서 출구에 도달하세요. 조

soksok.co.kr

Fireboy and Watergirl 4 (파이어보이 앤 워터걸 4) - SOK SOK

게임하기 - 파이어보이 앤 워터걸 4 - 가능한 빨리 길을 따라서 빨간색, 파란색, 회색 다이아몬드를 수집하여 비상구에 도달하는 방식으로 진행됩니다. 조작방법 - PC 조작법 & 모바일 조작법

soksok.co.kr

Fireboy and Watergirl 5 (파이어보이 앤 워터걸 5) - SOK SOK

게임하기 - 파이어보이 앤 워터걸 5 - 가능한 빨리 길을 따라서 빨간색, 파란색, 회색 다이아몬드를 수집하여 비상구에 도달하는 방식으로 진행됩니다. 조작방법 - PC 조작법 & 모바일 조작법

soksok.co.kr

큐(Queue) - 링크드 큐

나무고딕 — Sun, 19 Jul 2020 23:02:24 +0900

큐(Queue) - 링크드 큐

순환 큐와 링크드 큐

사실 순환 큐는 복잡한 개념을 가지고 있을 뿐더러 구현이 쉽지가 않습니다. 전단과 후단에 대한 개념은 특히 이해하기 어려울 수 있습니다.

반면 링크드 큐는 각 노드가 앞 노드에 대한 포인터를 이용하여 구성되어 있기 때문에, 삽입은 새 노드의 포인터에 후단을 연결하고 제거는 전단 바로 이후의 노드에서 전단에 대한 포인터를 거두어 들이는 것으로 구현할 수 있습니다.

또한, 링크드 큐는 큐가 가득 차 있는 상태인지 여부를 확인할 필요가 없습니다. 일반적으로는 용량의 한계가 없기 때문에 '가득찬다' 라는 개념이 없기 때문입니다.

하지만 순환 큐는 성능이 보다 빠르다는 장점이 있습니다. 노드를 생성하고 삭제하기 위해 malloc() 함수를 호출할 필요가 없기 때문입니다.

따라서 큐의 크기가 예측 가능하고 고성능이 필요한 버퍼와 같은 사례에는 순환 큐가 더 적절 하고, 그렇지 않을 경우 링크드 큐가 적절할 것입니다.

링크드 큐 구현하기

링크드 리스트로 큐를 표현하는 것은 순환 큐에 비해 간단합니다. 직관에 따라 설계와 구현이 가능합니다.

링크드 큐와 노드의 선언

링크드 큐의 노드는 링크드 리스트의 노드처럼 데이터 필드와 다음 노드를 가리키는 포인터로 구성됩니다.

typedef struct tagNode
{
    char* Data;
    struct tagNode* NextNode;
}    Node;

링크드 큐에서 각 노드의 데이터 필드는 문자열 char* 형입니다. 노드의 데이터 필드에 char* 가 아닌 다른 자료형을 사용하고 싶다면 그렇게 해도 좋습니다. 단, 노드를 생성하고 소멸시킬 때 데이터 필드의 메모리 관리는 자료형에 따라 적절히 대응해주어야 합니다.

typedef struct tagLinkedQueue
{
    Node*    Front;
    Node*    Rear;
    int     Count;
}    LinkedQueue;

링크드 큐의 구조체는 위와 같이 선언됩니다. 필드가 모두 세 개이며, 첫 번째는 큐의 시작(전단)을 가리키는 Front, 두 번째는 큐의 끝(후단)을 가리키는 Rear, 마지막 필드는 노드의 수를 나타내는 Count 입니다.

링크드 큐의 생성과 소멸

링크드 큐의 생성을 담당하는 함수의 이름은 LQ_CreateQueue() 이고, 소멸을 담당하는 함수의 이름은 LQ_DestroyQueue() 입니다. 링크드 큐에 관련된 함수의 이름은 모두 LQ_(Linked Queue)라는 접두사를 사용하였습니다.

먼저, LQ_CreateQueue()는 LinkedQueue 구조체를 자유 저장소에 생성하고 이 구조체의 각 필드를 초기화하는 일을 수행합니다.

void  LQ_CreateQueue( LinkedQueue** Queue )
{
    /*  큐를 자유저장소에 생성 */
    (*Queue )        = ( LinkedQueue*)malloc(sizeof( LinkedQueue ) );
    (*Queue )->Front = NULL;
    (*Queue )->Rear  = NULL;
    (*Queue )->Count = 0;
}

링크드 큐의 소멸을 담당하는 LQ_DestroyQueue() 함수는 큐 내부에 있는 모든 노드를 자유 저장소에서 제거하고 마지막에는 큐를 자유 저장소에서 제거합니다.

void LQ_DestroyQueue( LinkedQueue* Queue )
{
    while ( !LQ_IsEmpty( Queue ) )
    {
        Node* Popped = LQ_Dequeue( Queue );
        LQ_DestroyNode(Popped);    
    }

    /*  큐를 자유 저장소에서 해제 */
    free( Queue );
}

삽입(Enqueue) 연산

링크드 큐의 삽입 연산은 후단에 새로운 노드를 붙이면 됩니다. 다음 코드는 링크드 큐의 삽입 연산을 수행하는 LQ_Enqueue() 함수입니다.

void LQ_Enqueue( LinkedQueue* Queue, Node* NewNode )
{
    if ( Queue->Front == NULL ) 
    {        
        Queue->Front = NewNode;
        Queue->Rear  = NewNode;
        Queue->Count++;
    } 
    else
    {
        Queue->Rear->NextNode = NewNode;
        Queue->Rear = NewNode;
        Queue->Count++;
    }
}

제거 (Dequeue) 연산

링크드 큐의 제거 연산은 전단의 바로 다음 노드를 새로운 전단으로 만들고, 전단이었던 노드의 포인터를 호출자에게 반환하는 방식으로 구현됩니다. 다음은 제거 연산을 수행하는 LQ_Dequeue() 함수입니다.

Node* LQ_Dequeue( LinkedQueue* Queue )
{
    /*  LQ_Dequeue() 함수가 반환할 최상위 노드 */
    Node* Front = Queue->Front;

    if ( Queue->Front->NextNode == NULL )
    {
        Queue->Front = NULL;
        Queue->Rear  = NULL;
    }
    else
    {
        Queue->Front = Queue->Front->NextNode;
    }

    Queue->Count--;

    return Front;
}

링크드 큐 예제 프로그램

링크드 큐 예제 프로그램은 LinkedQueue.h, LinkedQueue.c, Test_LinkedQueue.c 총 3개의 파일로 구성되어 있습니다.

LinkedQueue.h

#ifndef LINKED_QUEUE_H
#define LINKED_QUEUE_H

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef struct tagNode
{
    char* Data;
    struct tagNode* NextNode;
} Node;

typedef struct tagLinkedQueue
{
    Node* Front;
    Node* Rear;
    int   Count;
} LinkedQueue;

void  LQ_CreateQueue( LinkedQueue** Queue );
void  LQ_DestroyQueue( LinkedQueue* Queue );

Node* LQ_CreateNode(char* Data);
void  LQ_DestroyNode(Node* _Node );

void  LQ_Enqueue( LinkedQueue* Queue, Node* NewNode );
Node* LQ_Dequeue( LinkedQueue* Queue );

int   LQ_IsEmpty( LinkedQueue* Queue );

#endif LINKED_QUEUE_H

LinkedQueue.c

#include "LinkedQueue.h"

void  LQ_CreateQueue( LinkedQueue** Queue )
{
    /*  큐를 자유저장소에 생성 */
    (*Queue )        = ( LinkedQueue*)malloc(sizeof( LinkedQueue ) );
    (*Queue )->Front = NULL;
    (*Queue )->Rear  = NULL;
    (*Queue )->Count = 0;
}

void LQ_DestroyQueue( LinkedQueue* Queue )
{
    while ( !LQ_IsEmpty( Queue ) )
    {
        Node* Popped = LQ_Dequeue( Queue );
        LQ_DestroyNode(Popped);    
    }

    /*  큐를 자유 저장소에서 해제 */
    free( Queue );
}

Node* LQ_CreateNode( char* NewData )
{
    Node* NewNode = (Node*)malloc( sizeof( Node ) );
    NewNode->Data = (char*)malloc( strlen( NewData) + 1);

    strcpy(NewNode->Data, NewData);  /*  데이터를 저장한다. */

    NewNode->NextNode = NULL; /*  다음 노드에 대한 포인터는 NULL로 초기화 한다. */

    return NewNode;/*  노드의 주소를 반환한다. */
}

void  LQ_DestroyNode(Node* _Node )
{
    free(_Node->Data);
    free(_Node );
}

void LQ_Enqueue( LinkedQueue* Queue, Node* NewNode )
{
    if ( Queue->Front == NULL ) 
    {        
        Queue->Front = NewNode;
        Queue->Rear  = NewNode;
        Queue->Count++;
    } 
    else
    {
        Queue->Rear->NextNode = NewNode;
        Queue->Rear = NewNode;
        Queue->Count++;
    }
}

Node* LQ_Dequeue( LinkedQueue* Queue )
{
    /*  LQ_Dequeue() 함수가 반환할 최상위 노드 */
    Node* Front = Queue->Front;

    if ( Queue->Front->NextNode == NULL )
    {
        Queue->Front = NULL;
        Queue->Rear  = NULL;
    }
    else
    {
        Queue->Front = Queue->Front->NextNode;
    }

    Queue->Count--;

    return Front;
}

int LQ_IsEmpty( LinkedQueue* Queue )
{
    return ( Queue->Front == NULL);
}

Test_LinkedQueue.c

#include "LinkedQueue.h"

int main( void )
{
    Node* Popped;
    LinkedQueue* Queue;

    LQ_CreateQueue(&Queue );

    LQ_Enqueue( Queue, LQ_CreateNode("abc") );
    LQ_Enqueue( Queue, LQ_CreateNode("def") );
    LQ_Enqueue( Queue, LQ_CreateNode("efg") );
    LQ_Enqueue( Queue, LQ_CreateNode("hij") );

    printf("Queue Size : %d\n", Queue->Count);

    while ( LQ_IsEmpty( Queue ) == 0 )
    {
        Popped = LQ_Dequeue( Queue );

        printf( "Dequeue: %s \n", Popped->Data );

        LQ_DestroyNode( Popped );
    }

    LQ_DestroyQueue( Queue );

    return 0;
}

큐 (Queue) - 큐의 주요 기능, 순환 큐

나무고딕 — Wed, 15 Jul 2020 13:11:22 +0900

큐 (Queue) - 큐의 주요 기능, 순환 큐

은행에서 먼저 온 순서대로 대기하는 줄을 만들어서 먼저 온 사람이 먼저 일을 보고 갈 수 있게 하듯이, 먼저 들어가고 먼저 나오는(FIFO(First In First Out), 또는 선입선출(先入先出)) 자료구조를 큐(Queue)라고 합니다.

큐는 작업을 처리하는 요소에 부하를 주지 않으면서도 처리 능력을 넘어서는 작업들도 놓치지 않고 수용할 수 있도록 돕는 역할을 합니다. 큐가 이처럼 '완충장치' 역할을 하는 사례는 아주 많습니다. 놀이공원의 롤러코스터에서 30인승 롤러코스터에 200명의 손님이 몰린다면, 롤러코스터는 자신의 능력 한계치인 30명을 태워서 레일로 나가고 나머지 170명은 큐에서 기다립니다. 손님이 몰린다고 하여 30명이 정원인 롤러코스터에 50명을 태우지는 않습니다.

큐의 주요 기능: 삽입과 제거

큐의 형태

큐는 위와 같이 생겼습니다. 큐의 가장 앞 요소를 가리켜 전단(前段, Front), 그리고 가장 마지막 요소를 가리켜 후단(後段, Rear)이라고 합니다.

스택은 삽입과 제거가 모두 최상위 노드(Top) 한쪽에서만 이루어졌습니다. 하지만 큐는 삽입(Enqueue)은 후단, 제거(Dequeue)는 전단에서 각각 수행됩니다.

다시말해, 삽입은 후단에 노드를 덧붙여서 새로운 후단을 만드는 연산이고, 제거는 전단의 노드를 없애서 전단 뒤에 있는 노드를 새로운 전단으로 만드는 연산입니다.

순환큐

큐를 배열로 구현해야 한다면 어떨까요? 먼저 제거 연산을 떠올려보면 다음과 같을 수 있습니다.

위 그림에 있는 큐 배열의 크기는 5이며 그 안에는 1, 2, 3, 4, 5 의 값을 가진 요소가 있습니다. 전단인 1을 제거하면 배열 내에 첫 번째 인덱스의 요소는 비게 되고 빈 자리를 채우기 위해 뒤에 있던 2, 3, 4, 5 요소가 앞으로 한 칸씩 옮겨옵니다.

이 방식의 문제점이 무엇일까요? 바로 전단을 제거한 후 나머지 요소들을 한 칸씩 앞으로 옮기는 데에 드는 비용입니다. 큐의 용량이 100개라면 한 번의 제거 연산에 99번의 이동이 필요하게 됩니다. 이 정도 성능이라면 구현이 아무리 간단하더라도 사용되기 어려운 수준일 것입니다.

이 문제를 해결할 수 있는 방법은 전단을 가리키는 변수를 도입하여 배열 내의 요소를 옮기는 대신 변경된 전단의 위치만 관리하는 것입니다. 이와 함께 후단을 가리키는 변수도 도입하여 삽입이 일어날 때마다 변경되는 후단의 위치를 관리합니다. 후단을 가리키는 변수에는 실제 후단의 위치보다 1을 더한 값을 가집니다.

이렇게 하면 배열 요소들의 이동으로 인한 부하 문제는 해결할 수 있습니다. 그런데 새로운 문제가 또 발생합니다. 제거 연산을 수행할 수록 가용 용량도 줄어들기 때문입니다.

그렇기 때문에 등장한 것이 순환 큐 입니다. 시작과 끝을 연결해서 순환하도록 고안된 큐를 '순환 큐(Circular Queue)'라고 합니다. 실제 배열의 시작과 끝을 연결하는 것이 아닌 논리적인 개념으로, 이러한 개념을 코드로 구현해야 합니다.

비어 있거나 가득 차 있거나

하지만 순환 큐의 문제는 아직 존재합니다. 순환 큐는 비어 있는 상태와 가득 차 있는 상태를 구분할 수가 없기 때문입니다. 순환 큐의 구현에서 후단을 실제의 후단에 1을 더한 값을 가진다는 것을 기억해야 합니다.

이 문제를 어떻게 해결하면 좋을까요? 일반적인 해결책은 큐 배열을 생성할 때에 실제의 용량보다 1만큼 더 크게 만들어서 전단과 후단(실제의 후단)사이를 비우는 것입니다. 이렇게 하면 큐가 비어있을 때 전단과 후단은 같은 곳을 가리키게 되고 큐가 가득 차 있을 때에는 후단이 전단보다 1 작은 값을 가지게 됩니다.

순환 큐 구현하기

모든 문제가 해결되었으니 이론을 바탕으로 어떻게 구현할 것인지에 대한 이야기를 해보도록 하겠습니다.

순환 큐의 선언

순환 큐의 노드는 다음과 같은 구조체로 표현됩니다. 링크드 리스트나 스택에서 사용해왔던 노드 구조체와 같은 모습을 하고 있습니다.

typedef int ElementType;

typedef struct tagNode
{
    ElementType Data;
}    Node;

순환 큐를 나타내는 CircularQueue 구조체는 Queue의 용량(Capacity), 전단의 위치(Front), 후단의 위치(Rear), 그리고 순환 큐 요소의 배열에 대한 포인터를 가지고 있습니다.

typedef struct tagCircularQueue
{
    int        Capacity;    /* 용량 */
    int        Front;        /* 전단의 인덱스 */
    int        Rear;        /* 후단의 인덱서 */
    Node*    Nodes;        /* 노드 배열 */
}    CircularQueue;

CircularQueue 구조체의 Nodes 포인터가 가리키는 배열은 자유 저장소에 생성됩니다. Capacity에는 배열의 크기, 즉 큐의 용량이 저장되는데 Capacity가 가지는 값은 실제의 용량보다 하나 작습니다. 순환 큐에는 공백/포화 상태 구분을 위한 더미 노드(Dummy Node)를 위해 한 개의 공간을 더 가지고 있기 때문입니다.

그리고 Front는 전단의 위치를, Rear는 후단의 위치를 가리킵니다. 이들이 가지는 값은 실제의 메모리 주소는 아니고 배열 내의 인덱스입니다. Rear는 실제의 후단보다 1 더 큰 값을 갖는다는 것을 기억하시기 바랍니다.

순환 큐의 생성과 소멸

다음은 순환 큐 구조체를 자유 저장소에 생성하는 CQ_CreateQueue() 함수입니다. CQ는 CircularQueue를 줄인 것입니다. CQ_CreateQueue()는 순환 큐에 대한 포인터의 포인터인 Queue와 용량을 결정하는 Capaciry를 매개 변수로 받습니다.

매개 변수를 받아들인 CQ_CreateQueue() 함수는 가장 먼저 순환 큐를 자유 저장소에 생성하고 Node의 크기 x (Capacity + 1)의 크기로 배열을 자유 저장소에 할당합니다. 앞서 말했듯 배열이 실제 데이터가 담길 공간보다 1만큼 더 큰 이유는 순환 큐가 공백 상태인지 포화 상태인지 여부를 구분하는 더미노드가 필요하기 때문입니다.

void  CQ_CreateQueue( CircularQueue** Queue, int Capacity)
{
    /*  큐를 자유저장소에 생성 */
    (*Queue )           = ( CircularQueue*)malloc(sizeof( CircularQueue ));

    /*  입력된 Capacity+1 만큼의 노드를 자유저장소에 생성 */
    (*Queue )->Nodes    = (Node*)malloc(sizeof(Node )* ( Capacity+1) );

    (*Queue )->Capacity = Capacity;
    (*Queue )->Front = 0;
    (*Queue )->Rear  = 0;
}

순환 큐를 자유 저장소에서 제거하는 CQ_DestroyQueue() 함수에서는 배열을 먼저 자유 저장소에서 제거한 후, 순환 큐 구조체를 제거하는 내용을 가집니다.

void CQ_DestroyQueue( CircularQueue* Queue )
{
    free(Queue->Nodes);
    free(Queue );
}

삽입(Enqueue) 연산

삽입 연산은 후단의 위치를 가리키는 Rear를 살피고 잘 다루는 것이 포인트입니다.

아래의 CQ_Enqueue() 함수에 if/else 블록의 if 블록에서 Rear의 값이 *Queue -> Capacity + 1과 같은 값을 가지고 있다면 후단이 배열의 끝에 도달했다는 것을 의미하므로 Rear와 Position을 0으로 지정합니다. 그렇지 않은 경우에는 else 블록으로 넘어가서 현재 Rear의 위치를 Position에 저장하고 Rear를 1 증가시킵니다.

그리고 if/else 블록이 끝난 이후에 Nodes 배열에서 Position이 가리키는 곳에 데이터를 저장합니다.

void CQ_Enqueue( CircularQueue* Queue, ElementType Data)
{
    int Position=0;

    if(Queue->Rear==Queue->Capacity)
    {
        Position=Queue->Rear;
        Queue->Rear=0;
    }
    else
        Position=Queue->Rear++;

    Queue->Nodes[Position].Data=Data;
}

제거(Dequeue) 연산

순환 큐의 제거 연산에서는 전단을 잘 다루는 것이 중요합니다.

다음 CQ_Dequeue() 합수를 보면 가장 먼저 전단의 위치(Front)를 Position에 저장합니다. 이 값은 마지막에 함수를 종료하면서 전단의 데이터를 반환할 때에 배열의 인덱스로 사용됩니다.

ElementType CQ_Dequeue( CircularQueue* Queue )
{
    int Position = Queue->Front;

    if ( Queue->Front == Queue->Capacity )
        Queue->Front = 0;
    else
        Queue->Front++;

    return Queue->Nodes[Position].Data;
}

그리고 가운데의 if/else 블록에서는 Front의 값이 Capacity와 같을 때 Front를 0으로 초기화하고, 그렇지 않으면 Front의 값을 1만큼 증가시킵니다. Front의 값이 Capacity와 같다는 것은 전단이 곧 배열의 끝에 도달해 있는 것이라는 사실을 의미합니다.

공백 상태 확인

순환 큐의 공백 상태를 확인하는 CQ_IsEmpty() 함수입니다. 전단과 후단읙 밧이 같으면 공백이라고 판정합니다.

int CQ_IsEmpty( CircularQueue* Queue )
{
    return (Queue->Front == Queue->Rear);
}

포화 상태 확인

순환 큐의 포화 상태를 확인하는 CQ_IsFull() 함수입니다.

이는 두 가지 경우의 수를 고려해야 합니다. 순환 큐 배열 내에서 전단이 후단 앞에 위치하는 경우 후단과 전단의 차가 큐의 용량과 동일한 지 여부를 확인해야 하고, 전단이 후단 뒤에 위치하는 경우 Rear에 1을 더한 값이 Front와 같은지 여부를 확인해야 합니다.

int CQ_IsFull( CircularQueue* Queue )
{
    if ( Queue->Front < Queue->Rear )
        return ( Queue->Rear - Queue->Front) == Queue->Capacity;
    else
        return ( Queue->Rear + 1 ) == Queue->Front;
}

순환 큐 예제 프로그램

프로그램은 세 개의 소스 코드 파일로 구성됩니다. CircularQueue.h와 CircularQueue.c는 순환 큐의 연산을 함수로 구현하고 있고, Test_CircularQueue.c는 이 함수들을 테스트합니다.

CircularQueue.h

#ifndef CIRCULAR_QUEUE_H
#define CIRCULAR_QUEUE_H

#include <stdio.h>
#include <stdlib.h>

typedef int ElementType;

typedef struct tagNode
{
    ElementType Data;
} Node;

typedef struct tagCircularQueue
{
    int   Capacity;
    int   Front;
    int   Rear;

    Node* Nodes;
} CircularQueue;

void        CQ_CreateQueue( CircularQueue** Queue, int Capacity);
void        CQ_DestroyQueue( CircularQueue* Queue );
void        CQ_Enqueue( CircularQueue* Queue, ElementType Data);
ElementType CQ_Dequeue( CircularQueue* Queue );
int         CQ_GetSize( CircularQueue* Queue );
int         CQ_IsEmpty( CircularQueue* Queue );
int         CQ_IsFull( CircularQueue* Queue );

#endif

CircularQueue.c

#include "CircularQueue.h"

void  CQ_CreateQueue( CircularQueue** Queue, int Capacity)
{
    /*  큐를 자유저장소에 생성 */
    (*Queue )           = ( CircularQueue*)malloc(sizeof( CircularQueue ));

    /*  입력된 Capacity+1 만큼의 노드를 자유저장소에 생성 */
    (*Queue )->Nodes    = (Node*)malloc(sizeof(Node )* ( Capacity+1) );

    (*Queue )->Capacity = Capacity;
    (*Queue )->Front = 0;
    (*Queue )->Rear  = 0;
}

void CQ_DestroyQueue( CircularQueue* Queue )
{
    free(Queue->Nodes);
    free(Queue );
}

void CQ_Enqueue( CircularQueue* Queue, ElementType Data)
{
    int Position=0;

    if(Queue->Rear==Queue->Capacity)
    {
        Position=Queue->Rear;
        Queue->Rear=0;
    }
    else
        Position=Queue->Rear++;

    Queue->Nodes[Position].Data=Data;
}

ElementType CQ_Dequeue( CircularQueue* Queue )
{
    int Position = Queue->Front;

    if ( Queue->Front == Queue->Capacity )
        Queue->Front = 0;
    else
        Queue->Front++;

    return Queue->Nodes[Position].Data;
}

int CQ_GetSize( CircularQueue* Queue )
{
    if ( Queue->Front <= Queue->Rear )
        return Queue->Rear - Queue->Front;
    else
        return Queue->Rear + (Queue->Capacity - Queue->Front) + 1;
}

int CQ_IsEmpty( CircularQueue* Queue )
{
    return (Queue->Front == Queue->Rear);
}

int CQ_IsFull( CircularQueue* Queue )
{
    if ( Queue->Front < Queue->Rear )
        return ( Queue->Rear - Queue->Front) == Queue->Capacity;
    else
        return ( Queue->Rear + 1 ) == Queue->Front;
}

Test_CircularQueue.c

#include "CircularQueue.h"

int main( void )
{
    int i;
    CircularQueue* Queue;

    CQ_CreateQueue(&Queue, 10);

    CQ_Enqueue( Queue, 1 );
    CQ_Enqueue( Queue, 2 );
    CQ_Enqueue( Queue, 3 );
    CQ_Enqueue( Queue, 4 );

    for ( i=0; i<3; i++)
    {
        printf( "Dequeue: %d, ",       CQ_Dequeue( Queue ) );
        printf( "Front:%d, Rear:%d\n", Queue->Front, Queue->Rear );
    }

    i = 100;
    while ( CQ_IsFull( Queue ) == 0 )
    {
        CQ_Enqueue( Queue, i++ );
    }

    printf( "Capacity: %d, Size: %d\n\n", 
        Queue->Capacity, CQ_GetSize(Queue ) );

    while ( CQ_IsEmpty( Queue ) == 0)
    {        
        printf( "Dequeue: %d, ",       CQ_Dequeue( Queue ) );
        printf( "Front:%d, Rear:%d\n", Queue->Front, Queue->Rear );
    }

    CQ_DestroyQueue( Queue );

    return 0;
}

스택 응용하기 - 사칙연산 계산기 만들기

나무고딕 — Wed, 15 Jul 2020 00:17:11 +0900

스택 응용하기 - 사칙연산 계산기 만들기

스택을 응용하여 '사칙 연산 계산기'를 만들어보려고 합니다. 정확히 말하자면 '수식 분석기 기반의 사칙 연산 계산기'라고도 할 수 있습니다.

계산기의 요구 조건은 간단합니다. 다음과 같이 사칙 연산 만으로 이루어진 식을 분석해서 풀 수 있으면 됩니다.

1 + 3.334 / (4.28 * (110 - 7729) )

이 문제를 직접 푼다고 하면 이렇습니다. 가장 먼저 괄호 내에 있는 식을 풀 것입니다. 괄호가 중첩되어 있다면 가장 안쪽에 있는 괄호부터 풀 것입니다. 그리고 곱셈(*)과 나눗헴(/)을, 그 후에 덧셈과 뺄셈 계산을 할 것입니다.

하지만 이는 사람이기에 할 수 있는 계산입니다. 컴퓨터는 이와 같은 방법으로 계산할 수가 없습니다. 따라서 컴퓨터가 이 문제를 풀도록 만들려면 컴퓨터가 사용할 알고리즘을 제공해야 합니다.

이후 자세히 설명할 것이지만, 이 알고리즘이 동작하는 원리에 대해 간단히 설명하자면 우선 수식을 프로그램이 풀기에 적당한 형식으로 변환한 다음, 변환된 수식을 프로그램이 계산하는 과정으로 동작합니다. 여기에서 스택은 수식을 다른 형식으로 변환할 때, 그리고 변환된 수식을 계산할 때에 사용됩니다.

수식을 변환하기 위해서는 수식의 중위 표기법, 후위 표기법에 대해 잘 이해하고 있어야 합니다.

수식의 중위 표기법과 후위 표기법

다음 식의 결과를 계산할 수 있으시나요?

1 2 33 / + 9 13 * -

무언가 이상해보이지만 위의 식은 엄연히 계산이 가능한 수식입니다. 이 식의 결과는 다음의 식과 같습니다.

1 + 2 / 33 - 9 * 13

전자는 후위 표기법(Postfix Notation)으로 수식을 표현한 것이고, 후자는 일반적으로 많은 사람들이 이용하는 중위 표기법(Infix Notation)으로 표현한 것입니다.

후위 표기법은 역(易) 폴리쉬 표기법(Reverse Polish Notation)이라고도 하며, 호주의 찰스 햄블린이 1950년대 중반에 개발한 알고리즘입니다. 이 표기법의 규칙은 연산자를 피연산자 뒤에 위치시키는 것입니다. 그렇기 때문에 '후위' 표기법 입니다. 반면 중위 표기법은 연산자가 피연산자 가운데에 위치하는 것이 규칙입니다.

다음은 중위 표기법과 후위 표기법의 몇 가지 예시입니다.

중위 표기법	후위 표기법
1 + 3	1 3 +
23 / 7 + 12	23 7 / 12 +
(117.32 + 83) * 49	117.32 83 + 49 *
1 - 3 * 2	1 3 2 * -

후위 표기식을 계산하는 알고리즘

후위 표기식을 계산하는 알고리즘은 두 가지 규칙으로 이루어져 있습니다. 예를 들어 후위 표기식 1 3 2 * -(중위 표기법으로는 1 - 3 * 2)를 풀어보도록 하겠습니다.

| 1 | 3 | 2 | * | - |

후위 표기식 계산 알고리즘의 첫 번째 규칙은 식의 왼쪽부터 요소를 읽어내면서 피연산자는 스택에 담는 것입니다. 처음 나오는 요소 '1'은 피연산자이므로 스택에 삽입합니다.

| 1 | 3 | 2 | * | - |

< 스 택 >  

  | 1 |

두 번째 요소도 피연산자이므로 스택에 삽입합니다. 이제 스택은 1, 3 두 개의 요소를 담고 있습니다.

| 1 | 3 | 2 | * | - |

< 스 택 >  

  | 3 |  
  | 1 |

세 번째 요소도 피연산자이고 역시 스택에 삽입합니다.

| 1 | 3 | 2 | * | - |

< 스 택 >  

  | 2 |  
  | 3 |  
  | 1 |

여기까지 했으면 두 번째 규칙을 설명드리겠습니다. 두 번째 규칙은 연산자가 나타난 경우에 스택에서 피연산자 두 개를 꺼내어 연산을 실행하고 그 연산 결과를 다시 스택에 삽입하는 것입니다. 네 번째 요소는 곱셈을 수행하는 * 이므로 스택에서 두 번의 제거 연산을 수행하여 피연산자 2 와 3을 꺼낸 후 3 * 2 의 결과 6을 스택에 삽입합니다. 그 결과 스택에는 1과 6이 저장됩니다.

| 1 | 3 | 2 | * | - |

< 스 택 >  
        → | 2 | 제거
        → | 3 | 제거

  | 6 | ← 3 * 2 의 결과를 삽입  
  | 1 |

다섯 번째 요소는 - 입니다. 연산자를 만났을 때에는 2회의 제거 연산을 실행하여 피연산자 두 개를 꺼내어 계산을 수행한다고 앞서 설명했습니다. 6과 1을 꺼낸 후 1 - 6의 결과 - 5를 스택에 저장합니다.

| 1 | 3 | 2 | * | - |

< 스 택 >  
        → | 6 | 제거
        → | 1 | 제거

  | - 5 | ← 1 - 6 의 결과를 삽입

이렇게 하여 식을 모두 읽었고 스택에는 식의 최종 계산 결과만 남게 됩니다. 이 값을 스택에서 꺼내면 계산 결과를 얻는 것입니다.

다음은 후위 표기식을 계산하는 함수의 뻐대만 작성한 것입니다. 실제 구현에 비하면 많은 것이 생략되어있지만, 주요한 내용은 존재합니다.

double Calculate( char* PostfixExpression )
{
    /* ... Stack 생성 */
    while ( PostfixExpression을 끝까지 다 읽을 때까지 )
    {
        /* PostfixExpression에서 토큰을 읽어내고, 읽은 토큰 크기를 Read에 누적 */
        Read += GetNextToken( &PostfixExpression[Read], Token, &Type );
        /* ... */
        if ( Type == OPERAND ) /* 토큰이 피연산자라면 스택에 삽입 */
        {
            LLS_Push( &Stack, LLS_CreateNode ( Token ) );
        }
        else /* 토큰이 연산자라면 스택의 피연산자들과 함께 계산 */
        {

            Operator2 = LLS_Pop(&Stack);
            Operator1 = LLS_Pop(&Stack);

            switch (Type) /* 연산자의 종류에 따라 계산 */
            {
            case PLUS:     TempResult = Operator1 + Operator2; break;
            case MINUS:    TempResult = Operator1 - Operator2; break;
            case MULTIPLY: TempResult = Operator1 * Operator2; break;
            case DIVIDE:   TempResult = Operator1 / Operator2; break;
            }

            LLS_Push( &Stack, LLS_CreateNode( TempResult ) );
        }
    }
    /* 스택에 가장 마지막까지 남아있는 결과 값을 Result에 저장 */
    Result = LLS_Pop(&Stack);

    /* ... Stack 소멸 */
    return Result;
}

중위 표기법에서 후위 표기법으로의 변환 알고리즘

이 알고리즘은 위대한 수학자이자 프로그래머였던 애드거 다익스트라(Edsger Dijkstra)가 고안한 알고리즘입니다. 동작과정은 다음과 같습니다.

입력받은 중위 표기식에서 토큰을 읽는다.
토큰이 피연산자이면 토큰을 결과에 출력한다.
토큰이 연산자(괄호 포함)일 경우, 스택의 최상위 노드에 담겨있는 연산자가 토큰보다 우선 순위가 높은지 여부를 검사한다. 검사 결과가 참이면 최상위 노드를 스택에서 꺼내어 결과에 출력하고, 이 검사 작업을 반복하여 수행하되 그 결과가 거짓이거나 스택이 비게 되면 작업을 중단한다. 검사 작업이 끝난 이후에는 토큰을 스택에 삽입한다. (이로 인해 스택에는 최상위 노드보다 우선순위가 높은 연산자는 존재하지 않게 된다.)
토큰이 오른쪽 괄호 )이면 최상위 노드에 왼쪽 괄호 (가 올 때까지 스택에 제거 연산을 수행하고 제거한 노드에 담긴 연산자를 출력한다. 왼쪽 괄호를 만나면 제거만 하고 출력하지는 않는다.
중위 표기식에 더 읽을 것이 없으면 빠져나가고 더 읽을 것이 있다면 1부터 다시 반복한다.

이 알고리즘을 토대로 중위 표기식을 후위 표기식으로 변환해봅니다.

(117.32 + 83) * 49

예를 들어 이 식을 후위 표기식으로 변환하는 과정은 다음과 같습니다.

토큰	작업	출력	스택
( 117.32 + 83 ) * 49	스택에 `(` 삽입		`(`
( 117.32 + 83 ) * 49	`117.32` 출력	117.32	`(`
( 117.32 + 83 ) * 49	스택에 `+` 삽입	117.32	`+` `(`
( 117.32 + 83 ) * 49	`83` 출력	117.32 83	`+` `(`
( 117.32 + 83 ) * 49	스택의 모든 연산자가 제거 후 출력(`(`는 출력 안함)	117.32 83 +
( 117.32 + 83 ) * 49	스택에 `*` 삽입	117.32 83 +	`*`
( 117.32 + 83 ) * 49	`49` 출력	117.32 83 + 49	`*`
( 117.32 + 83 ) * 49	식 모두 읽었으므로, 스택의 모든 연산자 제거 후 출력	117.32 83 + 49 *

아래의 코드는 다익스트라의 중위-후위 표기 변환 알고리즘을 구현한 GetPostfix() 함수입니다.

void GetPostfix( char* InfixExpression, char* PostfixExpression ) 
// InfixExpression: 중위 표기식 / PostfixExpression: 후위 표기식
{
    LinkedListStack* Stack;

    char Token[32];
    int  Type = -1;
    unsigned int Position = 0;
    unsigned int Length = strlen( InfixExpression );

    LLS_CreateStack(&Stack);

    while ( Position < Length ) // 중위 표기식을 다 읽을 때까지
    {
        Position += GetNextToken( &InfixExpression[Position], Token, &Type );

        if ( Type == OPERAND ) // 토큰이 피연산자라면 후위 표기식에 출력
        {
            strcat( PostfixExpression, Token );
            strcat( PostfixExpression, " " );
        }
        else if ( Type == RIGHT_PARENTHESIS ) 
        {               
            while ( !LLS_IsEmpty(Stack) ) // 토큰이 오른쪽 괄호라면 왼쪽 괄호가 나타날 때까지 스택의 노드를 제거
            {
                Node* Popped = LLS_Pop( Stack );

                if ( Popped->Data[0] == LEFT_PARENTHESIS )
                {
                    LLS_DestroyNode( Popped );
                    break;
                }
                else // 토큰이 연산자인 경우
                {
                    strcat( PostfixExpression, Popped->Data );          
                    LLS_DestroyNode( Popped );
                }
            }
        }
        else
        {
            while ( !LLS_IsEmpty( Stack ) && 
                    !IsPrior( LLS_Top( Stack )->Data[0], Token[0] ) )
            {
                Node* Popped = LLS_Pop( Stack );

                if ( Popped->Data[0] != LEFT_PARENTHESIS )
                    strcat( PostfixExpression, Popped->Data );

                LLS_DestroyNode( Popped );
            }

            LLS_Push( Stack, LLS_CreateNode( Token ) );
        }
    }

    while ( !LLS_IsEmpty( Stack) ) // 중위 표기식을 다 읽었으니 Stack에 남겨져 있는 모든 연산자를 후위 표기식에 출력
    {
        Node* Popped = LLS_Pop( Stack );

        if ( Popped->Data[0] != LEFT_PARENTHESIS )
            strcat( PostfixExpression, Popped->Data );

        LLS_DestroyNode( Popped );
    }

    LLS_DestroyStack(Stack);
}

사칙 연산 계산기 예제 프로그램

예제는 모두 다섯 개의 파일로 구성되어 있습니다.

LinkedListStack.h와 LinkedListStack.c ▶ 링크드 리스트 기반의 스택이 구현되어 있음
Calculator.h와 Calculator.c ▶ 중위 표기식을 후위 표기식으로 변환하는 알고리즘과 후위 표기식을 계산하는 알고리즘
Test_Calculator.c ▶ 사용자가 중위 표기식을 입력하면 Calculator.h와 Caculator.c에 구현되어 있는 함수를 토대로 결과를 계산하여 출력

LinkedListStack.h 와 LinkedListStack.c 는 아래 링크해둔 포스팅에서 참고하여 사용하시면 됩니다.

링크드 리스트로 구현하는 스택

링크드 리스트로 구현하는 스택 링크드 리스트로 스택을 구현하면 스택의 용량에 제한을 두지 않아도 된다는 장점이 있습니다. 링크드 리스트의 구조를 잘 떠올리며 링크드 스택에 대해 알아보

likewiki.site

Calculator.h

#ifndef CALCULATOR_H
#define CALCULATOR_H

#include <stdlib.h>
#include "LinkedListStack.h"

typedef enum
{
    LEFT_PARENTHESIS  = '(', RIGHT_PARENTHESIS = ')',
    PLUS     = '+', MINUS    = '-',
    MULTIPLY = '*', DIVIDE   = '/',
    SPACE    = ' ', OPERAND
} SYMBOL;

int          IsNumber( char Cipher );
unsigned int GetNextToken( char* Expression, char* Token, int* TYPE );
int          IsPrior( char Operator1, char Operator2 );
void         GetPostfix( char* InfixExpression, char* PostfixExpression );
double       Calculate( char* PostfixExpression );

#endif CALCULATOR_H

Calculator.c

#include "Calculator.h"

char NUMBER[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.' };

int IsNumber( char Cipher )
{
    int i = 0;
    int ArrayLength = sizeof(NUMBER);

    for ( i=0; i<ArrayLength; i++ )
    {
        if ( Cipher == NUMBER[i] )
            return 1;
    }

    return 0;
}

unsigned int GetNextToken( char* Expression, char* Token, int* TYPE )
{
    unsigned int i = 0;

    for ( i=0 ; 0 != Expression[i]; i++ )
    {
        Token[i] = Expression[i];

        if ( IsNumber( Expression[i] ) == 1 )
        {            
            *TYPE = OPERAND;

            if ( IsNumber(Expression[i+1]) != 1 )
                break;
        }
        else
        {
            *TYPE = Expression[i];
            break;            
        }
    }

    Token[++i] = '\0';
    return i;
}

int GetPriority(char Operator, int InStack)
{
    int Priority = -1;

    switch (Operator)
    {
    case LEFT_PARENTHESIS:
        if ( InStack )
            Priority = 3;
        else
            Priority = 0;
        break;

    case MULTIPLY:
    case DIVIDE:
        Priority = 1;
        break;

    case PLUS:
    case MINUS:
        Priority = 2;
        break;
    }

    return Priority;
}

int IsPrior( char OperatorInStack, char OperatorInToken )
{
    return ( GetPriority(OperatorInStack, 1) > GetPriority(OperatorInToken, 0) );
}

void GetPostfix( char* InfixExpression, char* PostfixExpression )
{
    LinkedListStack* Stack;

    char Token[32];
    int  Type = -1;
    unsigned int Position = 0;
    unsigned int Length = strlen( InfixExpression );

    LLS_CreateStack(&Stack);

    while ( Position < Length )
    {
        Position += GetNextToken( &InfixExpression[Position], Token, &Type );

        if ( Type == OPERAND ) 
        {
            strcat( PostfixExpression, Token );
            strcat( PostfixExpression, " " );
        }
        else if ( Type == RIGHT_PARENTHESIS ) 
        {               
            while ( !LLS_IsEmpty(Stack) )
            {
                Node* Popped = LLS_Pop( Stack );

                if ( Popped->Data[0] == LEFT_PARENTHESIS )
                {
                    LLS_DestroyNode( Popped );
                    break;
                }
                else
                {
                    strcat( PostfixExpression, Popped->Data );          
                    LLS_DestroyNode( Popped );
                }
            }
        }
        else
        {
            while ( !LLS_IsEmpty( Stack ) && 
                    !IsPrior( LLS_Top( Stack )->Data[0], Token[0] ) )
            {
                Node* Popped = LLS_Pop( Stack );

                if ( Popped->Data[0] != LEFT_PARENTHESIS )
                    strcat( PostfixExpression, Popped->Data );

                LLS_DestroyNode( Popped );
            }

            LLS_Push( Stack, LLS_CreateNode( Token ) );
        }
    }

    while ( !LLS_IsEmpty( Stack) )
    {
        Node* Popped = LLS_Pop( Stack );

        if ( Popped->Data[0] != LEFT_PARENTHESIS )
            strcat( PostfixExpression, Popped->Data );

        LLS_DestroyNode( Popped );
    }

    LLS_DestroyStack(Stack);
}

double Calculate( char* PostfixExpression )
{
    LinkedListStack* Stack;
    Node*  ResultNode;

    double Result;
    char Token[32];
    int  Type = -1;
    unsigned int Read = 0; 
    unsigned int Length = strlen( PostfixExpression );

    LLS_CreateStack(&Stack);

    while ( Read < Length )
    {
        Read += GetNextToken( &PostfixExpression[Read], Token, &Type );

        if ( Type == SPACE )  
            continue;

        if ( Type == OPERAND ) 
        {
            Node* NewNode = LLS_CreateNode( Token );
            LLS_Push( Stack, NewNode );
        }
        else
        {
            char   ResultString[32];            
            double Operator1, Operator2, TempResult;
            Node* OperatorNode;

            OperatorNode = LLS_Pop( Stack );
            Operator2 = atof( OperatorNode->Data );
            LLS_DestroyNode( OperatorNode );

            OperatorNode = LLS_Pop( Stack );
            Operator1 = atof( OperatorNode->Data );
            LLS_DestroyNode( OperatorNode );

            switch (Type)
            {
            case PLUS:     TempResult = Operator1 + Operator2; break;
            case MINUS:    TempResult = Operator1 - Operator2; break;
            case MULTIPLY: TempResult = Operator1 * Operator2; break;
            case DIVIDE:   TempResult = Operator1 / Operator2; break;
            }

            gcvt( TempResult, 10, ResultString );            
            LLS_Push( Stack, LLS_CreateNode( ResultString ) );
        }
    }

    ResultNode = LLS_Pop( Stack );            
    Result = atof( ResultNode->Data );
    LLS_DestroyNode( ResultNode );

    LLS_DestroyStack( Stack );

    return Result;
}

Test_Calculator.c

#include <stdio.h>
#include <string.h>
#include "Calculator.h"

int main( void )
{
    char InfixExpression[100];
    char PostfixExpression[100];

    double Result = 0.0;

    memset( InfixExpression,   0, sizeof(InfixExpression) );
    memset( PostfixExpression, 0, sizeof(PostfixExpression) );

    printf( "Enter Infix Expression:" );
    scanf( "%s", InfixExpression );

    GetPostfix( InfixExpression, PostfixExpression );

    printf( "Infix:%s\nPostfix:%s\n",
             InfixExpression,
             PostfixExpression );

    Result = Calculate( PostfixExpression );

    printf( "Calculation Result : %f\n", Result );

    return 0;
}

카카오톡 API 메시지 전송 코드

나무고딕 — Sun, 5 Jul 2020 16:44:17 +0900

카카오톡 API 메시지 전송 코드

텍스트 메시지 - TextTemplate

LinkObject link = LinkObject.newBuilder()
        .setWebUrl("https://developers.kakao.com")
        .setMobileWebUrl("https://developers.kakao.com")
        .build();
TemplateParams params = TextTemplate.newBuilder("text\nhello, this is test", link)
        .setButtonTitle("This is button")
        .build();
// 기본 템플릿으로 카카오링크 보내기
KakaoLinkService.getInstance()
        .sendDefault(context, params, new ResponseCallback<KakaoLinkResponse>() {
            @Override
            public void onFailure(ErrorResult errorResult) {
                Log.e("KAKAO_API", "카카오링크 공유 실패: " + errorResult);
                Toast.makeText(context, "카카오링크 공유 실패: " + errorResult, Toast.LENGTH_SHORT).show();
            }
            @Override
            public void onSuccess(KakaoLinkResponse result) {
                Log.i("KAKAO_API", "카카오링크 공유 성공");
                Toast.makeText(context, "카카오링크 공유 성공", Toast.LENGTH_SHORT).show();
                // 카카오링크 보내기에 성공했지만 아래 경고 메시지가 존재할 경우 일부 컨텐츠가 정상 동작하지 않을 수 있습니다.
                Log.w("KAKAO_API", "warning messages: " + result.getWarningMsg());
                Log.w("KAKAO_API", "argument messages: " + result.getArgumentMsg());
                Toast.makeText(context, "Warning messages: " + result.getWarningMsg() + " / Argument message: " + result.getArgumentMsg(), Toast.LENGTH_SHORT).show();
            }
        });

피드 메시지 - FeedTemplate

TemplateParams params = FeedTemplate
        .newBuilder(ContentObject.newBuilder(
                "디저트 사진",
                "http://mud-kage.kakao.co.kr/dn/NTmhS/btqfEUdFAUf/FjKzkZsnoeE4o19klTOVI1/openlink_640x640s.jpg",
                LinkObject.newBuilder()
                        .setWebUrl("https://blog.naver.com/kimhe5623")
                        .setMobileWebUrl("https://blog.naver.com/kimhe5623")
                        .build())
                .setDescrption("아메리카노, 빵, 케익")
                .build())
        .setSocial(SocialObject.newBuilder()
                .setLikeCount(1)
                .setCommentCount(2)
                .setSharedCount(30)
                .setViewCount(40)
                .build())
        .addButton(new ButtonObject(
                "웹에서 보기",
                LinkObject.newBuilder()
                        .setWebUrl("https://blog.naver.com/kimhe5623")
                        .setMobileWebUrl("https://blog.naver.com/kimhe5623")
                        .build()))
        .addButton(new ButtonObject(
                "앱에서 보기",
                LinkObject.newBuilder()
                        .setAndroidExecutionParams("key1=value1")
                        .setIosExecutionParams("key1=value1")
                        .build()))
        .build();
// 기본 템플릿으로 카카오링크 보내기
KakaoLinkService.getInstance()
        .sendDefault(context, params, new ResponseCallback<KakaoLinkResponse>() {
            @Override
            public void onFailure(ErrorResult errorResult) {
                Log.e("KAKAO_API", "카카오링크 공유 실패: " + errorResult);
                Toast.makeText(context, "카카오링크 공유 실패: " + errorResult, Toast.LENGTH_SHORT).show();
            }
            @Override
            public void onSuccess(KakaoLinkResponse result) {
                Log.i("KAKAO_API", "카카오링크 공유 성공");
                Toast.makeText(context, "카카오링크 공유 성공", Toast.LENGTH_SHORT).show();
                // 카카오링크 보내기에 성공했지만 아래 경고 메시지가 존재할 경우 일부 컨텐츠가 정상 동작하지 않을 수 있습니다.
                Log.w("KAKAO_API", "warning messages: " + result.getWarningMsg());
                Log.w("KAKAO_API", "argument messages: " + result.getArgumentMsg());
                Toast.makeText(context, "Warning messages: " + result.getWarningMsg() + " / Argument message: " + result.getArgumentMsg(), Toast.LENGTH_SHORT).show();
            }
        });

리스트 메시지 - ListTemplate

TemplateParams params = ListTemplate.newBuilder(
        "WEEKELY MAGAZINE",
        LinkObject.newBuilder()
                .setWebUrl("https://rb.gy/qvkfhf")
                .setMobileWebUrl("https://rb.gy/qvkfhf")
                .build())
        .addContent(ContentObject.newBuilder(
                "자전거 라이더를 위한 공간",
                "http://mud-kage.kakao.co.kr/dn/QNvGY/btqfD0SKT9m/k4KUlb1m0dKPHxGV8WbIK1/openlink_640x640s.jpg",
                LinkObject.newBuilder()
                        .setWebUrl("https://rb.gy/qvkfhf")
                        .setMobileWebUrl("https://rb.gy/qvkfhf")
                        .build())
                .setDescrption("매거진")
                .build())
        .addContent(ContentObject.newBuilder(
                "비쥬얼이 끝내주는 오레오 카푸치노",
                "http://mud-kage.kakao.co.kr/dn/boVWEm/btqfFGlOpJB/mKsq9z6U2Xpms3NztZgiD1/openlink_640x640s.jpg",
                LinkObject.newBuilder()
                        .setWebUrl("https://rb.gy/qvkfhf")
                        .setMobileWebUrl("https://rb.gy/qvkfhf")
                        .build())
                .setDescrption("매거진")
                .build())
        .addContent(ContentObject.newBuilder(
                "감성이 가득한 분위기",
                "http://mud-kage.kakao.co.kr/dn/NTmhS/btqfEUdFAUf/FjKzkZsnoeE4o19klTOVI1/openlink_640x640s.jpg",
                LinkObject.newBuilder()
                        .setWebUrl("https://rb.gy/qvkfhf")
                        .setMobileWebUrl("https://rb.gy/qvkfhf")
                        .build())
                .setDescrption("매거진")
                .build())
        .addButton(new ButtonObject(
                "웹에서 보기",
                LinkObject.newBuilder()
                        .setMobileWebUrl("https://rb.gy/qvkfhf")
                        .setMobileWebUrl("https://rb.gy/qvkfhf")
                        .build()))
        .addButton(new ButtonObject(
                "앱에서 보기",
                LinkObject.newBuilder()
                        .setAndroidExecutionParams("key1=value1")
                        .setIosExecutionParams("key1=value1")
                        .build()))
        .build();
// 기본 템플릿으로 카카오링크 보내기
KakaoLinkService.getInstance()
        .sendDefault(context, params, new ResponseCallback<KakaoLinkResponse>() {
            @Override
            public void onFailure(ErrorResult errorResult) {
                Log.e("KAKAO_API", "카카오링크 공유 실패: " + errorResult);
                Toast.makeText(context, "카카오링크 공유 실패: " + errorResult, Toast.LENGTH_SHORT).show();
            }
            @Override
            public void onSuccess(KakaoLinkResponse result) {
                Log.i("KAKAO_API", "카카오링크 공유 성공");
                Toast.makeText(context, "카카오링크 공유 성공", Toast.LENGTH_SHORT).show();
                // 카카오링크 보내기에 성공했지만 아래 경고 메시지가 존재할 경우 일부 컨텐츠가 정상 동작하지 않을 수 있습니다.
                Log.w("KAKAO_API", "warning messages: " + result.getWarningMsg());
                Log.w("KAKAO_API", "argument messages: " + result.getArgumentMsg());
                Toast.makeText(context, "Warning messages: " + result.getWarningMsg() + " / Argument message: " + result.getArgumentMsg(), Toast.LENGTH_SHORT).show();
            }
        });

위치 메시지 - LocationTemplate

TemplateParams params = LocationTemplate.newBuilder(
        "성남시 분당구 판교역로 235",
        ContentObject.newBuilder(
                "카카오 판교오피스",
                "http://mud-kage.kakao.co.kr/dn/NTmhS/btqfEUdFAUf/FjKzkZsnoeE4o19klTOVI1/openlink_640x640s.jpg",
                LinkObject.newBuilder()
                        .setWebUrl("https://developers.kakao.com")
                        .setMobileWebUrl("https://developers.kakao.com")
                        .build())
                .setDescrption("카카오 판교오피스 위치입니다.")
                .build())
        .setAddressTitle("카카오 판교오피스 in Kakao Map")
        .build();
// 기본 템플릿으로 카카오링크 보내기
KakaoLinkService.getInstance()
        .sendDefault(context, params, new ResponseCallback<KakaoLinkResponse>() {
            @Override
            public void onFailure(ErrorResult errorResult) {
                Log.e("KAKAO_API", "카카오링크 공유 실패: " + errorResult);
                Toast.makeText(context, "카카오링크 공유 실패: " + errorResult, Toast.LENGTH_SHORT).show();
            }
            @Override
            public void onSuccess(KakaoLinkResponse result) {
                Log.i("KAKAO_API", "카카오링크 공유 성공");
                Toast.makeText(context, "카카오링크 공유 성공", Toast.LENGTH_SHORT).show();
                // 카카오링크 보내기에 성공했지만 아래 경고 메시지가 존재할 경우 일부 컨텐츠가 정상 동작하지 않을 수 있습니다.
                Log.w("KAKAO_API", "warning messages: " + result.getWarningMsg());
                Log.w("KAKAO_API", "argument messages: " + result.getArgumentMsg());
                Toast.makeText(context, "Warning messages: " + result.getWarningMsg() + " / Argument message: " + result.getArgumentMsg(), Toast.LENGTH_SHORT).show();
            }
        });

커머스 메시지 - CommerceTemplate

ContentObject contentObject = ContentObject.newBuilder(
        "Ivory long dress (4 Color)",
        "http://mud-kage.kakao.co.kr/dn/RY8ZN/btqgOGzITp3/uCM1x2xu7GNfr7NS9QvEs0/kakaolink40_original.png",
        LinkObject.newBuilder()
                .setWebUrl("https://rb.gy/qvkfhf")
                .setMobileWebUrl("https://rb.gy/qvkfhf")
                .build())
        .build();
CommerceDetailObject commerceDetailObject = CommerceDetailObject.newBuilder(208800)
        .setDiscountPrice(146160)
        .setDiscountRate(30)
        .build();
ButtonObject firstButtonObject = new ButtonObject(
        "구매하기",
        LinkObject.newBuilder()
                .setWebUrl("https://rb.gy/qvkfhf")
                .setMobileWebUrl("https://rb.gy/qvkfhf")
                .build());
ButtonObject secondButtobObject = new ButtonObject(
        "공유하기",
        LinkObject.newBuilder()
                .setAndroidExecutionParams("share=true")
                .setIosExecutionParams("share=true")
                .build());
TemplateParams params =  CommerceTemplate.newBuilder(contentObject, commerceDetailObject)
        .addButton(firstButtonObject)
        .addButton(secondButtobObject)
        .build();

// 기본 템플릿으로 카카오링크 보내기
KakaoLinkService.getInstance()
        .sendDefault(context, params, new ResponseCallback<KakaoLinkResponse>() {
            @Override
            public void onFailure(ErrorResult errorResult) {
                Log.e("KAKAO_API", "카카오링크 공유 실패: " + errorResult);
                Toast.makeText(context, "카카오링크 공유 실패: " + errorResult, Toast.LENGTH_SHORT).show();
            }
            @Override
            public void onSuccess(KakaoLinkResponse result) {
                Log.i("KAKAO_API", "카카오링크 공유 성공");
                Toast.makeText(context, "카카오링크 공유 성공", Toast.LENGTH_SHORT).show();
                // 카카오링크 보내기에 성공했지만 아래 경고 메시지가 존재할 경우 일부 컨텐츠가 정상 동작하지 않을 수 있습니다.
                Log.w("KAKAO_API", "warning messages: " + result.getWarningMsg());
                Log.w("KAKAO_API", "argument messages: " + result.getArgumentMsg());
                Toast.makeText(context, "Warning messages: " + result.getWarningMsg() + " / Argument message: " + result.getArgumentMsg(), Toast.LENGTH_SHORT).show();
            }
        });

스크랩 메시지

// 공유할 URL
String url = "https://rb.gy/gbij5f";
// 스크랩 템플릿으로 카카오링크 보내기
KakaoLinkService.getInstance()
        .sendScrap(context, url, null, new ResponseCallback<KakaoLinkResponse>() {
            @Override
            public void onFailure(ErrorResult errorResult) {
                Log.e("KAKAO_API", "카카오링크 공유 실패: " + errorResult);
                Toast.makeText(context, "카카오링크 공유 실패: " + errorResult, Toast.LENGTH_SHORT).show();
            }
            @Override
            public void onSuccess(KakaoLinkResponse result) {
                Log.i("KAKAO_API", "카카오링크 공유 성공");
                Toast.makeText(context, "카카오링크 공유 성공", Toast.LENGTH_SHORT).show();
                // 카카오링크 보내기에 성공했지만 아래 경고 메시지가 존재할 경우 일부 컨텐츠가 정상 동작하지 않을 수 있습니다.
                Log.w("KAKAO_API", "warning messages: " + result.getWarningMsg());
                Log.w("KAKAO_API", "argument messages: " + result.getArgumentMsg());
                Toast.makeText(context, "Warning messages: " + result.getWarningMsg() + " / Argument message: " + result.getArgumentMsg(), Toast.LENGTH_SHORT).show();
            }
        });

링크드 리스트로 구현하는 스택

나무고딕 — Wed, 1 Jul 2020 22:03:43 +0900

링크드 리스트로 구현하는 스택

링크드 리스트로 스택을 구현하면 스택의 용량에 제한을 두지 않아도 된다는 장점이 있습니다. 링크드 리스트의 구조를 잘 떠올리며 링크드 스택에 대해 알아보도록 하겠습니다.

스택과 스택의 노드 표현하기

잘 알려진 것처럼, 배열과는 달리 링크드 리스트는 인덱스로 노드에 접근할 수 없습니다 .따라서 링크드 리스트로 스택을 구현하려면 노드는 자신의 위에 위치하는 노드에 대한 포인터를 가지고 있어야 합니다. 이러한 요구 사항을 반영한 노드 구조체는 다음과 같습니다.

typedef struct tagNode
{
    char* Data;
    struct tagNode* NextNode;
}   Node;

배열 스택에서와는 달리 Data 필드가 char* 형으로 선언되어있습니다. 이는 다음 번에 구현할 계산기를 만들 때에 문자열을 처리하는 스택이 필요한데, 비슷한 코드를 두 번 작성할 필요 없이 이를 그대로 사용하기 위함입니다.

그런데 여기에 한 가지 문제가 있습니다. Data 필드의 자료형이 int나 double 같은 기본 자료형이라면 '값의 복사'만으로 데이터를 담을 수 있지만, char* 형은 포인터이기 때문에 문자열이 저장되어 있는 주소만을 담을 수 있어야 합니다. 또한 이 문자열은 자동 메모리가 아닌 자유 저장소에 저장되어야 합니다. 자동 메모리에 담겨있는 데이터는 우리가 필요로 하는 것과는 상관없이 컴파일러가 정해준 수명이 다하면 사라지기 때문입니다.

이번에는 링크드 리스트 스택의 구조체를 보도록 하겠습니다. 링크드 리스트 스택은 배열 기반의 스택과는 달리 '스택의 용량'이나 '최상위 노드의 인덱스'가 없습니다. 있어도 쓸 곳이 없는 것입니다. 대신 링크드 리스트(List 포인터)의 헤드와 테일(Top 포인터)에 대한 포인터가 필요합니다.

typedef struct tagLinkedListStack
{
    Node* List;
    Node* Top;
}    LinkedListStack;

List 포인터는 스택이 기반하고 있는 링크드 리스트에 접근할 수 있게 하고, Top 포인터를 이용하면 4바이트를 소비하는 대신, 테일을 찾기 위해 소요되는 시간을 제거할 수 있습니다.

스택의 기본 연산 구현하기

링크드 리스트 스택의 기본 연산을 C 코드로 구현해보겠습니다. 링크드 리스트로 구현하는 방법은 배열로 하는 것보다는 난이도가 높습니다. 링크드 리스트 중에서도 싱글 링크드 리스트를 이용하여 스택을 구현하려고 합니다. 그리고 구현에 사용할 접두사는 LLS(Linked List Stack) 입니다.

스택의 생성과 소멸

먼저 해야 할 것은 스택을 자유 저장소에 생성하는 함수인 LLS_CreateStack()을 구현하는 것입니다. LLS_CreateStack() 함수는 배열 버전의 AS_CreateStack() 함수와는 달리 Stack의 용량의 결정짓는 매개 변수를 필요로 하지 않습니다. 링크드 리스트를 기반으로 하고 있기 때문에 용량의 제한에서 자유로울 수 있는 것입니다.

LLS_CreateStack() 함수가 하는 일은 다음 코드가 보여주는 것처럼 LinkedListStack 구조체를 자유 저장소에 할당하는 것 뿐입니다.

void  LLS_CreateStack( LinkedListStack** Stack )
{
    /*  스택을 자유저장소에 생성 */
    (*Stack )       = ( LinkedListStack*)malloc(sizeof( LinkedListStack ) );
    (*Stack )->List = NULL;
    (*Stack )->Top  = NULL;
}

자유 저장소에 공간을 할당하는 malloc() 함수와 free() 함수는 함께한다는 것을 잘 알 것입니다. LLS_CreateStack() 함수가 malloc() 함수를 이용하여 LinkedListStack 구조체를 자유 저장소에 할당하도록 구현하였으니 이 메모리를 해제하는 free() 함수를 호출하는 LLS_DestroyStack() 함수를 구현하면 다음과 같습니다.

void LLS_DestroyStack( LinkedListStack* Stack )
{
    while ( !LLS_IsEmpty(Stack ) )
    {
        Node* Popped = LLS_Pop( Stack );
        LLS_DestroyNode(Popped);    
    }

    /*  스택을 자유 저장소에서 해제 */
    free(Stack );
}

LLS_DestroyStack() 함수의 중요한 특징은 LinkedListStack 구조체를 자유저장소에서 해제시키는 것뿐 아니라 그에 앞서 스택 내의 모든 노드들을 제거한다는 것입니다. while 블록의 코드들의 바로 그 일을 합니다. LLS_IsEmpty() 함수는 스택이 비어있는지 여부를 점검하고, LLS_Pop() 함수는 스택의 최상위 노드를 제거합니다. 그리고 LLS_DestroyNode() 함수는 자유 저장소에 할당된 노드를 해제하는 기능을 수행합니다.

스택 노드의 생성과 소멸

링크드 리스트 스택의 노드를 생성하는 LLS_CreateNode()의 구현은 조금 복잡합니다. 앞에서 언급한 바와 같이 노드를 자유 저장소에 생성할 때에 문자열을 저장할 공간 또한 함께 생성해야 하기 때문입니다. 아래의 LLS_CreateNode() 함수 코드를 보면 malloc() 함수가 Node 구조체를 할당하기 위해 한 번, Node 구조체의 Data 필드를 위해 한 번, 모두 두 번 호출됩니다.

Node* LLS_CreateNode( char* NewData )
{
    Node* NewNode = ( Node*)malloc(sizeof( Node ) );
    NewNode->Data = ( char*)malloc(strlen( NewData ) + 1);

    strcpy( NewNode->Data, NewData );  /*  데이터를 저장한다. */

    NewNode->NextNode = NULL; /*  다음 노드에 대한 포인터는 NULL로 초기화 한다. */

    return NewNode;/*  노드의 주소를 반환한다. */
}

다음은 노드를 메모리에서 깨끗이 제거하는 함수인 LLS_DestroyNode() 입니다. 이 함수 내에서도 free() 함수가 두 번 호출됩니다. 한 번은 노드의 Data 필드를 자유 저장소에서 해제하기 위해서이고 나머지 한 번은 노드를 해제하기 위해서입니다.

void  LLS_DestroyNode( Node* _Node )
{
    free(_Node->Data );
    free(_Node );
}

삽입(Push) 연산

링크드 리스트 버전의 삽입(Push) 연산은 링크드 리스트의 추가(Append) 연산과 비슷합니다. 먼저 최상위 노드(테일)를 찾은 다음, 여기에 새 노드를 얹으면 됩니다. 이렇게 하면 새 노드가 최상위 노드가 되는데 이를 LinkedListStack 구조체의 Top 필드에 등록하는 것으로 LLS_Push() 함수의 임무는 완료됩니다.

void LLS_Push( LinkedListStack* Stack, Node* NewNode )
{
    if ( Stack->List == NULL ) 
    {        
        Stack->List = NewNode;
    } 
    else
    {
        /*  최상위 노드를 찾아 NewNode를 연결한다(쌓는다). */
        Node* OldTop = Stack->List;
        while ( OldTop->NextNode != NULL )
        {
            OldTop = OldTop->NextNode;
        }

        OldTop->NextNode = NewNode;
    }

    /*  스택의 Top 필드에 새 노드의 주소를 등록한다. */
    Stack->Top = NewNode;
}

제거(Pop) 연산

링크드 리스트 기반의 스택에서 제거(Pop) 연산은 다음 네 단계로 수행됩니다.

현재 최상위 노드의 주소를 다른 포인터에 복사해둔다.

새로운 최상위 노드, 즉 현재 최상위 노드의 바로 이전(아래) 노드를 찾는다.

LinkedListStack 구조체의 Top 필드에 새로운 최상위 노드의 주소를 등록한다.

1에서 포인터에 저장해둔 옛 최상위 노드의 주소를 반환한다.

다음 코드는 제거 연산을 수행하는 LLS_Pop() 함수의 구현입니다.

Node* LLS_Pop( LinkedListStack* Stack )
{
    /*  LLS_Pop() 함수가 반환할 최상위 노드 */
    Node* TopNode = Stack->Top;

    if ( Stack->List == Stack->Top )
    {
        Stack->List = NULL;
        Stack->Top  = NULL;
    }
    else
    {
        /*  새로운 최상위 노드를 스택의 Top 필드에 등록한다. */
        Node* CurrentTop = Stack->List;
        while ( CurrentTop != NULL && CurrentTop->NextNode != Stack->Top )
        {
            CurrentTop = CurrentTop->NextNode;
        }

        Stack->Top = CurrentTop;
        CurrentTop->NextNode = NULL;
    }

    return TopNode;
}

링크드 리스트로 구현하는 스택 예제 프로그램

이번에는 위의 내용들을 모아 프로그램으로 만들려고 합니다. 이 예제에서는 앞에서 설명한 각 연산들과 더불어 설명하지 않은 몇 가지 간단한 연산들도 포함하고 있습니다. 예를 들어 스택의 최상위 노드를 제거하지는 않은 채로 반환만 하는 LLS_Top() 함수, 스택이 비어있는 지 여부를 점검하는 LLS_IsEmpty() 함수, 스택의 크기를 재는 LLS_GetSize() 함수가 바로 그것들입니다. 이 함수들의 내용은 코드를 작성하면서 익힐 수 있습니다.

예제 프로그램은 세 개의 파일로 구성되어 있습니다. LinkedListStack.h와 LinkedListStack.c는 스택 연산 함수를 선언하고 정으하고 있으며, Test_LinkedListStack.c 에서는 두 개의 파일에서 정의한 함수를 테스트합니다.

/*********************/
/* LinkedListStack.h */
/*********************/

#ifndef LINKEDLIST_STACK_H
#define LINKEDLIST_STACK_H

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef struct tagNode
{
    char* Data;
    struct tagNode* NextNode;
} Node;

typedef struct tagLinkedListStack
{
    Node* List;
    Node* Top;
} LinkedListStack;

void  LLS_CreateStack( LinkedListStack** Stack );
void  LLS_DestroyStack( LinkedListStack* Stack );

Node* LLS_CreateNode( char* Data );
void  LLS_DestroyNode( Node* _Node );

void  LLS_Push( LinkedListStack* Stack, Node* NewNode );
Node* LLS_Pop( LinkedListStack* Stack );

Node* LLS_Top( LinkedListStack* Stack );
int   LLS_GetSize( LinkedListStack* Stack );
int   LLS_IsEmpty( LinkedListStack* Stack );

#endif LINKEDLIST_STACK_H

/*********************/
/* LinkedListStack.c */
/*********************/

#include "LinkedListStack.h"

void  LLS_CreateStack( LinkedListStack** Stack )
{
    /*  스택을 자유저장소에 생성 */
    (*Stack )       = ( LinkedListStack*)malloc(sizeof( LinkedListStack ) );
    (*Stack )->List = NULL;
    (*Stack )->Top  = NULL;
}

void LLS_DestroyStack( LinkedListStack* Stack )
{
    while ( !LLS_IsEmpty(Stack ) )
    {
        Node* Popped = LLS_Pop( Stack );
        LLS_DestroyNode(Popped);    
    }

    /*  스택을 자유 저장소에서 해제 */
    free(Stack );
}

Node* LLS_CreateNode( char* NewData )
{
    Node* NewNode = ( Node*)malloc(sizeof( Node ) );
    NewNode->Data = ( char*)malloc(strlen( NewData ) + 1);

    strcpy( NewNode->Data, NewData );  /*  데이터를 저장한다. */

    NewNode->NextNode = NULL; /*  다음 노드에 대한 포인터는 NULL로 초기화 한다. */

    return NewNode;/*  노드의 주소를 반환한다. */
}

void  LLS_DestroyNode( Node* _Node )
{
    free(_Node->Data );
    free(_Node );
}

void LLS_Push( LinkedListStack* Stack, Node* NewNode )
{
    if ( Stack->List == NULL ) 
    {        
        Stack->List = NewNode;
    } 
    else
    {
        /*  최상위 노드를 찾아 NewNode를 연결한다(쌓는다). */
        Node* OldTop = Stack->List;
        while ( OldTop->NextNode != NULL )
        {
            OldTop = OldTop->NextNode;
        }

        OldTop->NextNode = NewNode;
    }

    /*  스택의 Top 필드에 새 노드의 주소를 등록한다. */
    Stack->Top = NewNode;
}

Node* LLS_Pop( LinkedListStack* Stack )
{
    /*  LLS_Pop() 함수가 반환할 최상위 노드 */
    Node* TopNode = Stack->Top;

    if ( Stack->List == Stack->Top )
    {
        Stack->List = NULL;
        Stack->Top  = NULL;
    }
    else
    {
        /*  새로운 최상위 노드를 스택의 Top 필드에 등록한다. */
        Node* CurrentTop = Stack->List;
        while ( CurrentTop != NULL && CurrentTop->NextNode != Stack->Top )
        {
            CurrentTop = CurrentTop->NextNode;
        }

        Stack->Top = CurrentTop;
        CurrentTop->NextNode = NULL;
    }

    return TopNode;
}

Node* LLS_Top( LinkedListStack* Stack )
{
    return Stack->Top;
}

int LLS_GetSize( LinkedListStack* Stack )
{
    int    Count = 0;
    Node*  Current = Stack->List;

    while ( Current != NULL )
    {
        Current = Current->NextNode;
        Count++;
    }

    return Count;
}

int LLS_IsEmpty( LinkedListStack* Stack )
{
    return (Stack->List == NULL);
}

/**************************/
/* Test_LinkedListStack.c */
/**************************/

#include "LinkedListStack.h"

int main( void )
{
    int i= 0;
    int Count = 0;
    Node* Popped;

    LinkedListStack* Stack;

    LLS_CreateStack(&Stack);

    LLS_Push( Stack, LLS_CreateNode("abc") );
    LLS_Push( Stack, LLS_CreateNode("def") );
    LLS_Push( Stack, LLS_CreateNode("efg") );
    LLS_Push( Stack, LLS_CreateNode("hij") );

    Count = LLS_GetSize(Stack);
    printf( "Size: %d, Top: %s\n\n", 
        Count, LLS_Top(Stack)->Data );

    for ( i=0; i<Count; i++ )
    {
        if ( LLS_IsEmpty(Stack) )
            break;

        Popped = LLS_Pop( Stack );

        printf( "Popped: %s, ", Popped->Data );

        LLS_DestroyNode(Popped);

        if ( ! LLS_IsEmpty(Stack) ) 
        {
            printf( "Current Top: %s\n", LLS_Top(Stack)->Data );
        }
        else
        {
            printf( "Stack Is Empty.\n");
        }
    }

    LLS_DestroyStack(Stack);

    return 0;
}

스택(Stack)의 개념 및 배열로 구현하는 스택

나무고딕 — Fri, 26 Jun 2020 12:29:55 +0900

스택(Stack)의 개념 및 배열로 구현하는 스택

스택 주차장

주차장 내 차

차를 몰고 여기저기 돌아다니다가 식사를 위해 주차장에 주차를 한 뒤 식당에 들어갔습니다. 식당에 들어갈 때에는 손님이 거의 없었지만 식사를 마치고 나올 쯤에는 손님들로 식당이 꽤 붐볐습니다.

이 때문에 주차한 차를 빼는 데에 문제가 생겼습니다. 식당의 주차장이 독특하게 생긴데다 열악했기 때문인데요. 폭이 좁고 긴 공터를 주차장으로 사용하고 있었기 때문입니다.

손님이 없을 때에 주차를 했기 때문에 가장 안쪽에 주차한 것이 화근이었습니다. 제 차 앞에 세 대의 차가 더 주차되어 있었기 때문이었습니다. 식사 중인 손님들을 방해하고 싶지는 않았지만 식당의 지배인을 통해 차 주인들을 모두 불러 앞의 차들을 모두 빼낸 다음에야 차를 빼고 나설 수 있었습니다.

이 식당의 주차장은 '가장 먼저 들어간 차가 가장 마지막에 나오는 구조'로 되어 있었는데, 스택(Stack)이 바로 이런 형태의 자료구조입니다. 스택은 영어로 뭔가를 쌓아놓은 더미를 뜻합니다. 예를 들어 건초더미, 서류더미와 같은 것 말입니다.

스택은 앞에서 말한 예시처럼 처음에 들어간 것이 가장 마지막에 나오도록 되어있는 구조를 가지고 있습니다. 이러한 구조를 FILO(First In, Last Out) 또는 LIFO(Last In, First Out)라고 부르는데, 이는 데이터의 삽입과 삭제가 자료구조의 한쪽 끝에서만 이루어지는 것이 특징입니다.

스택은 큐와 함께 소프트웨어 분야에서 굉장히 중요한 역할을 담당하고 있습니다. 자동 메모리가 스택을 기반으로 동작하고, 대부분의 네트워크 프로토콜 또한 스택을 기반으로 구성되어 있습니다. 각종 텍스트 분석 프로그램도 마찬가지로 스택을 이용하고 있습니다.

스택의 주요 기능: 삽입과 제거

스택의 주요기능은 '삽입(Push)'과 '제거(Pop)' 두 가지입니다. 그 이외의 기능들은 이 두 개의 연산을 위한 보조 연산일 뿐입니다.

삽입 연산은 스택 위에 새로운 노드(또는 요소)를 '쌓는' 작업입니다. 다음의 그림처럼 말입니다.

스택 삽입

반면에 제거 연산은 스택에서 최상위 노드를 '걷어내는' 작업입니다.

스택 삭제

배열로 구현하는 스택

스택을 구현하는 방법으로는 배열을 이용하거나 링크드 리스트를 이용하는 두 가지 방법이 대표적입니다. 그 중 해당 포스팅에서는 배열을 이용하는 방법에 대해 설명하려고 합니다.

먼저, 배열을 이용한 구현은 동적으로 스택의 용량을 조절하기가 어렵다는 단점이 있지만 구현이 간단하다는 장점이 있습니다. 배열 기반의 스택은 각 노드를 동적으로 생성하고 제거하는 대신 스택 생성 초기에 사용자(프로그래머)가 부여한 용량만큼의 노드를 한꺼번에 생성합니다. 그리고 최상위 노드의 위치를 나타내는 변수를 이용하여 삽입과 제거 연산을 수행합니다.

스택과 스택의 노드 표현하기

먼저 스택의 각 층을 구성하는 노드의 모습은 어떨까요? 배열을 기반으로 구현되는 스택의 노드는 다음과 같이 데이터만 담는 구조체로 표현됩니다. 노드가 존재하는 위치는 배열의 인덱스로 알 수 있기 때문에 링크드 리스트처럼 앞이나 뒷 노드에 대한 포인터는 필요 없습니다.

typedef int ElementType;

typedef struct tagNode
{
    ElementType Data;
    Node;
}

이번에는 스택 구조체를 보도록 하겠습니다. 배열 기반의 스택은 다음 세 가지 필드를 가지고 있어야 합니다.

용량
최상위 노드의 위치
노드 배열

위 세 가지 중에 용량은 스택이 얼마만큼의 노드를 가질 수 있는지에 대한 한계를 알기 위해 사용됩니다. 최상위 노드의 위치는 삽입/제거 시에 최상위 노드에 접근할 수 있게 돕습니다. 그리고 노드 배열은 스택에 쌓이는 노드를 보관하는 데에 사용됩니다. 다음의 ArrayStack 구조체는 이러한 필드의 요구사항을 반영하여 선언되었습니다.

typedef struct tagArrayStack
{
    int        Capacity;    /* 용량 */
    int        top;        /* 최상위 노드의 위치 */
    Node*    Nodes;        /* 노드 배열 */
}    ArrayStack;

노드 배열 필드인 Nodes를 보면 포인터로 선언되어 있습니다. 이는 포인터를 배열로 사용할 수 있는 C 언어의 특성 때문에 가능한 것입니다. 노드 배열을 자유 저장소에 할당하고 Nodes 포인터는 아래 그림과 같이 자유 저장소에 할당된 배열을 가리키는 데 사용될 것입니다.

Nodes 포인터와 자유저장소

스택의 기본 연산 구현하기

스택은 가장 위에 있는 노드 위에 새로운 노드를 얹는 '삽입'과 '삭제' 연산을 반드시 수행해야 합니다.

스택의 생성과 소멸

스택을 생성하고 노드를 받아들일 수 있게 준비하는 AS_CreateStack() 함수는 다음과 같이 구현합니다. 여기서 AS_라는 접두사는 ArrayStack의 약자입니다.

void  AS_CreateStack(ArrayStack** Stack, int Capacity)
{
    /*  스택을 자유저장소에 생성 */
    (*Stack)           = (ArrayStack*)malloc(sizeof(ArrayStack));

    /*  입력된 Capacity만큼의 노드를 자유저장소에 생성 */
    (*Stack)->Nodes    = (Node*)malloc(sizeof(Node)*Capacity);

    /*  Capacity 및 Top 초기화 */
    (*Stack)->Capacity = Capacity;
    (*Stack)->Top = 0;
}

AS_CreateStack() 함수의 매개 변수는 두 개입니다. 첫 번째는 ArrayStack 구조체고 두 번째는 스택의 용량을 결정하는 수입니다. 함수 내부로 들어가서 보면 malloc() 함수가 두 번이나 호출 된 것을 볼 수 있습니다. 처음에 호출된 malloc()은 ArrayStack을 자유저장소에 올리기 위해 사용되었고 그 다음에는 스택 내에 있는 노드를 매개 변수로 입력된 용량만큼 자유 저장소에 생성하는 데 사용됐습니다.

한편, ArrayStack의 Capacity에는 배열의 용량을 저장하고 최상위 노드의 위치를 가리키는 Top은 0으로 초기화합니다. Top은 노드가 쌓일 때마다 1씩 증가하고 노드가 제거될 때마다 1씩 감소할 것입니다. 현재는 노드가 없기 때문에 0 입니다.

자유 저장소 메모리에 무언가를 얹어놓으면 사용이 끝난 후에는 반드시 제거해야 합니다. 다음에서 AS_DestroyStack() 함수는 스택 내의 노드와 스택을 제거하는 임무를 수행합니다.

void AS_DestroyStack(ArrayStack* Stack)
{
    /*  노드를 자유 저장소에서 해제 */
    free(Stack->Nodes);

    /*  스택을 자유 저장소에서 해제 */
    free(Stack);
}

삽입(Push) 연산

사실 삽입과 삭제 연산을 구현하는 일은 그리 복잡하지 않습니다. 특히 배열 기반의 스택에서 삽입 연산은 최상위 노드의 위치(Top)에 1을 더한 곳에 새 노드를 놓기만 하면 됩니다. 단, C 언어에서는 수가 0부터 시작하기 때문에 코드에서는 Top의 값 그대로를 새 노드의 인덱스로 사용하고 새 노드를 스택에 올린 후에 Top의 값을 1만큼 증가시켜줍니다.

삽입 연산을 담당하는 AS_Push() 함수는 다음과 같습니다.

void AS_Push(ArrayStack* Stack, ElementType Data)
{
    int Position = Stack->Top;

    Stack->Nodes[Position].Data = Data;
    Stack->Top++;
}

제거(Pop) 연산

삽입에서 최상위 노드의 인덱스(Top)의 값을 1만큼 올렸던 것과는 반대로, 제거 연산에서는 이 값을 하나 낮추면 됩니다. 한 가지 잊지 않아야 할 것은 제거 연산의 경우 최상위 노드의 데이터를 호출자에게 반환해야 한다는 것입니다.

제거 연산을 수행하는 AS_Pop() 함수는 다음과 같습니다.

ElementType AS_Pop(ArrayStack* Stack)
{
    int Position = --( Stack->Top );

    return Stack->Nodes[Position].Data;
}

위 코드에서 기억해야 할 점은 Top이 가지고 있는 값은 실제 최상위 노드가 배열 내에서 위치하는 인덱스 값보다 1만큼 더 크다는 것입니다. 따라서 "최상위 노드의 인덱스 == Top-1" 입니다.

배열로 구현하는 스택 예제 프로그램

이 예제에서는 앞에서 설명하지 않은 몇 가지 함수가 더 포함되어 있습니다. 예를 들어 제거는 하지 않고 최상위 노드의 데이터만 반환하는 Top() 함수, 스택이 비어 있는지 여부를 검사하는 IsEmpty() 함수 등입니다. 이 함수들은 구현이 간단하여 개별적으로 설명이 없지만 아래 소스 코드를 보면 충분히 이해할 수 있을 것입니다.

프로그램을 구성하는 소스 코드 파일은 총 세 개입니다. 그 중 둘은 스택 연산을 구현하는 ArrayStack.h와 ArrayStack.c, 나머지 하나는 이들을 테스트하는 Test_ArrayStack.c 입니다.

/****************/
/* ArrayStack.h */
/****************/

#ifndef ARRAYSTACK_H
#define ARRAYSTACK_H

#include <stdio.h>
#include <stdlib.h>

typedef int ElementType;

typedef struct tagNode
{
    ElementType Data;
} Node;

typedef struct tagArrayStack
{
    int   Capacity;
    int   Top;
    Node* Nodes;
} ArrayStack;

void        AS_CreateStack(ArrayStack** Stack, int Capacity);
void        AS_DestroyStack(ArrayStack* Stack);
void        AS_Push(ArrayStack* Stack, ElementType Data);
ElementType AS_Pop(ArrayStack* Stack);
ElementType AS_Top(ArrayStack* Stack);
int         AS_GetSize(ArrayStack* Stack);
int         AS_IsEmpty(ArrayStack* Stack);

#endif ARRAYSTACK_H

/****************/
/* ArrayStack.c */
/****************/

#include "ArrayStack.h"

void  AS_CreateStack(ArrayStack** Stack, int Capacity)
{
    /*  스택을 자유저장소에 생성 */
    (*Stack)           = (ArrayStack*)malloc(sizeof(ArrayStack));

    /*  입력된 Capacity만큼의 노드를 자유저장소에 생성 */
    (*Stack)->Nodes    = (Node*)malloc(sizeof(Node)*Capacity);

    /*  Capacity 및 Top 초기화 */
    (*Stack)->Capacity = Capacity;
    (*Stack)->Top = 0;
}

void AS_DestroyStack(ArrayStack* Stack)
{
    /*  노드를 자유 저장소에서 해제 */
    free(Stack->Nodes);

    /*  스택을 자유 저장소에서 해제 */
    free(Stack);
}

void AS_Push(ArrayStack* Stack, ElementType Data)
{
    int Position = Stack->Top;

    Stack->Nodes[Position].Data = Data;
    Stack->Top++;
}

ElementType AS_Pop(ArrayStack* Stack)
{
    int Position = --( Stack->Top );

    return Stack->Nodes[Position].Data;
}

ElementType AS_Top(ArrayStack* Stack)
{
    int Position = Stack->Top - 1;

    return Stack->Nodes[Position].Data;
}

int AS_GetSize(ArrayStack* Stack)
{
    return Stack->Top;
}

int AS_IsEmpty(ArrayStack* Stack)
{
    return (Stack->Top == 0);
}

/*********************/
/* Test_ArrayStack.c */
/*********************/

#include "ArrayStack.h"

int main( void )
{
    int i= 0;
    ArrayStack* Stack = NULL;

    AS_CreateStack(&Stack, 10);

    AS_Push(Stack, 3);
    AS_Push(Stack, 37);
    AS_Push(Stack, 11);
    AS_Push(Stack, 12);

    printf( "Capacity: %d, Size: %d, Top: %d\n\n", 
        Stack->Capacity, AS_GetSize(Stack), AS_Top(Stack) );

    for ( i=0; i<4; i++ )
    {
        if ( AS_IsEmpty(Stack) )
            break;

        printf( "Popped: %d, ", AS_Pop(Stack) );

        if ( ! AS_IsEmpty(Stack) )
            printf( "Current Top: %d\n", AS_Top(Stack) );
        else
            printf( "Stack Is Empty.\n" );
    }

    AS_DestroyStack(Stack);

    return 0;
}