- C++
- ์์คํ ์ํํธ์จ์ด
- SQL
- Spring
- datagrip
- spring ์์ ๋ก๊ทธ์ธ
- aligoapi
- RP 2๊ธฐ
- Rp2๊ธฐ
- DATABASE
- spring์ผ๋ก https ์ ์ฉ
- Unity
- ๋ฆฌ๋ ์ค ๋ช ๋ น์ด
- ํจ์คํธ์บ ํผ์คX์ผ๋์
- java error
- merge sort
- OpenAPI
- docker
- ๊ตฌ๊ธ ์์ ๋ก๊ทธ์ธ
- Quick Sort
- @CreatedDate
- Java
- SSL
- mysql
- MethodArgumentNotValidException
- MAKE US
- spring ๊ตฌ๊ธ ์์ ๋ก๊ทธ์ธ
- Data Structure
- node js
- GIT
๋ชฉ๋ก์ ์ฒด ๊ธ (132)
YS's develop story
๐จ๐ผ๐ป Heap (ํ) ์ ๋ฆฌ With Python ๐ฅ Heap ์ด๋? ๋ฐ์ดํฐ์์ ์ต๋๊ฐ๊ณผ ์ต์๊ฐ์ ๋น ๋ฅด๊ฒ ์ฐพ๊ธฐ ์ํด ๊ณ ์๋ ์์ ์ด์งํธ๋ฆฌ(Complete Binary Tree)์ ๋๋ค. ์์ ์ด์งํธ๋ฆฌ? Node๋ฅผ ์ฝ์ ํ ๋ ์ตํ๋จ ์ผ์ชฝ Node๋ถํฐ ์ฐจ๋ก๋๋ก ์ฝ์ ํ๋ Tree ๋ฐฐ์ด์ ๋ฐ์ดํฐ๋ฅผ ๋ฃ๊ณ , ์ต๋๊ฐ๊ณผ ์ต์๊ฐ์ ์ฐพ์ผ๋ ค๋ฉด O(n) ์ด ๊ฑธ๋ฆฌ์ง๋ง ํ์ ๋ฐ์ดํฐ๋ฅผ ๋ฃ๊ณ , ์ต๋๊ฐ๊ณผ ์ต์๊ฐ์ ์ฐพ์ผ๋ฉด O(logn) ์ด ๊ฑธ๋ฆฌ๊ธฐ ๋๋ฌธ์ ์ต๋๊ฐ, ์ต์๊ฐ์ ๋น ๋ฅด๊ฒ ์ฐพ์์ผ ํ๋ ์๋ฃ๊ตฌ์กฐ ๋ฐ ์๊ณ ๋ฆฌ์ฆ์ ํ์ฉ๋ฉ๋๋ค. ํ์ ์๋์ ๋ ๊ฐ์ง ์กฐ๊ฑด์ ๊ฐ์ง๊ณ ์์ด์ผ ํฉ๋๋ค. ๊ฐ ๋ ธ๋์ ๊ฐ์ ํด๋น ๋ ธ๋์ ์์ ๋ ธ๋๊ฐ ๊ฐ์ง ๊ฐ๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ต๋๋ค. ์์ ์ด์งํธ๋ฆฌ ํํ๋ฅผ ๊ฐ์ง๋๋ค. ๐ Heap VS Binary Search Tree ๊ณตํต์ ..
๐จ๐ผ๐ป Tree (ํธ๋ฆฌ) ์ ๋ฆฌ With Python ๐ฅ Tree๋? Node์ Branch๋ฅผ ์ด์ฉํด์ Cycle์ ์ด๋ฃจ์ง ์๋๋ก ๊ตฌ์ฑํ ๋ฐ์ดํฐ ๊ตฌ์กฐ์ ๋๋ค. ๐ ๊ด๋ จ ์ฉ์ด Node : ํธ๋ฆฌ์์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ๊ธฐ๋ณธ ์์ Root Node : ํธ๋ฆฌ์ ์ต์์ ๋ ธ๋ Level : ์ต์์ ๋ ธ๋๋ฅผ Level 0์ด๋ผ๊ณ ํ์ ๋, ํ์ Branch๋ก ์ฐ๊ฒฐ๋ ๋ ธ๋์ ๊น์ด๋ฅผ ๋ํ๋ ๋๋ค. Parent Node : ์ด๋ค ๋ ธ๋์ ๋ถ๋ชจ ๋ ธ๋ Child Node : ์ด๋ค ๋ ธ๋์ ์์ ๋ ธ๋ Leaf Node : Child Node๊ฐ ํ๋๋ ์๋ ๋ ธ๋ Sibling : ๋์ผํ Parent Node๋ฅผ ๊ฐ์ง๋ ๋ ธ๋ Depth : ํธ๋ฆฌ์์ Node๊ฐ ๊ฐ์ง ์ ์๋ ์ต๋ Level (์ ์ฌ์ง์์์ Depth๋ 2) ๐ ์ด์ง ํ์ ํธ๋ฆฌ ์ด..
๐จ๐ผ๐ป Hash Table (ํด์ ํ ์ด๋ธ) ์ ๋ฆฌ With Python ๐ฅ Hash Table์ด๋? ํค(key)์ ๋ฐ์ดํฐ(Value)๋ฅผ ์ ์ฅํ๋ ๋ฐ์ดํฐ ๊ตฌ์กฐ์ ๋๋ค. Key๋ฅผ ํตํด ๋ฐ๋ก ๋ฐ์ดํฐ๋ฅผ ๋ฐ์ ์ ์์ผ๋ฏ๋ก, ์๋๊ฐ ๋งค์ฐ ๋น ๋ฆ ๋๋ค. ํ์ด์ฌ์์๋ ๋์ ๋๋ฆฌ ํ์ ์ ์ฌ์ฉํ๋ฉด ๋ฉ๋๋ค. ๐ ๊ฐ๋จํ ํด์ ์์ hashTable = [0 for i in range(20)] def hashFunction(key): return key % 8 def insertToHashTable(data, value): key = ord(data[0]) hashAddress = hashFunction(key) hashTable[hashAddress] = value def getFromHashTable(data): key = ord..
๐จ๐ผ๐ป Linked List (๋งํฌ๋ ๋ฆฌ์คํธ) ์ ๋ฆฌ With Python ๐ฅ Linked List๋? ๐ Linked List ๊ตฌ์กฐ Linked List์ ๊ธฐ๋ณธ ๊ตฌ์กฐ๋ ์ ์ ๊ฐ์ต๋๋ค. ๋ ธ๋ : ๋ฐ์ดํฐ์ ์ ์ฅ ๋จ์, ๋ ธ๋๋ ๋ฐ์ดํฐ์ ํฌ์ธํฐ๋ก ๊ตฌ์ฑ๋์ด ์์ต๋๋ค. ํฌ์ธํฐ : ๊ฐ ๋ ธ๋ ์์์ ๋ค์์ด๋ ์ด์ ์ ๋ ธ๋์์ ์ฐ๊ฒฐ ์ ๋ณด๋ฅผ ๊ฐ์ง๊ณ ์๋ ๊ณต๊ฐ์ ๋๋ค. ๋ฐฐ์ด์ด ๊ฐ์ง ์๋ฃ๊ตฌ์กฐ์ ๋จ์ ์ ๋ณด์ํ๊ธฐ ์ํ ์๋ฃ๊ตฌ์กฐ๊ฐ Linked List์ ๋๋ค. ๐ Linked List ์ฅ๋จ์ Linked List์ ํน์ ๊ฐ์ ์ญ์ ํ๊ฑฐ๋ ์ถ๊ฐํ ๋ ์์ ๊ฐ์ด ๋ณ๋์ ์์ ์ ํด์ฃผ๋ ๋ก์ง์ด ํ์๋ก ํฉ๋๋ค. ๐ Linked List ๊ตฌํ (with Python) class Node: def __init__(self, data): self...
๐จ๐ผ๐ป Stack (์คํ) ์ ๋ฆฌ With Python ๐ฅ Stack์ด๋? ํ์ชฝ ๋์์๋ง ์๋ฃ๋ฅผ ๋ฃ๊ฑฐ๋ ๋บ ์ ์๋ ๋ฐ์ดํฐ๋ฅผ ์ ํ์ ์ผ๋ก ์ ๊ทผํ ์ ์๋ ๊ตฌ์กฐ ๊ฐ์ฅ ๋์ค์ ๋ฃ์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ฅ ๋จผ์ ๋นผ๋ผ ์ ์๋ ๊ตฌ์กฐ LIFO (Last In First Out) ๊ตฌ์กฐ ๐ Process์ Stack def recursive(data): if data ๊ตฌ์กฐ๊ฐ ๋จ์ํด์ ๋ฐ์ดํฐ์ ์ฝ๊ธฐ, ์ ์ฅ ์๋..
๐จ๐ผ๐ป Queue (ํ) ์ ๋ฆฌ With Python ๐ฅ Queue๋? ๊ฐ์ฅ ๋จผ์ ๋ฃ์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ฅ ๋จผ์ ๊บผ๋ผ ์ ์๋ ๊ตฌ์กฐ FIFO (First In First Out ) ๊ตฌ์กฐ ํน๋ณํ Queue LifoQueue : ๋์ค์ ์ ๋ ฅ๋ ๋ฐ์ดํฐ๊ฐ ๋จผ์ ์ถ๋ ฅ๋๋ Queue PrioiryQueue : ๋ฐ์ดํฐ๋ง๋ค ์ฐ์ ์์๋ฅผ ๋ฃ์ด์ ์ฐ์ ์์๊ฐ ๋์ ์์ผ๋ก ์ถ๋ ฅ๋๋ Queue ๐ Queue ๊ด๋ จ ํจ์ import queue queue = queue.Queue() queue ์์ฑ ํ๊ธฐ queue.put("๋ฐ๊ตฌ๋ฆฌ") queue.put("์๋ฌด") enqueue (๋ฐ์ดํฐ ๋ฃ๊ธฐ) print(queue.get()) dequeue (๋ฐ์ดํฐ ์ถ์ถ) -> "๋ฐ๊ตฌ๋ฆฌ" ์ถ๋ ฅ print(queue.qsize()) queue ์ฌ์ด์ฆ ๊ณ์ฐ ..
๐ Open API ํ์ฉํ์ฌ ๊ณตํด์ผ ์ ๋ณด ์ ์ฅ ๋ฐ ๋ถ๋ฌ์ค๊ธฐ with request module โ Problem ์ฌ์ฉ์์๊ฒ ์์ฝ ๊ด๋ จ ์๋น์ค๋ฅผ ์ ๊ณตํ๋ ค๊ณ ํ ๋, ๋ชจ๋ ๊ณตํด์ผ ๋ ์ง๋ฅผ ์๊ณ ์์ด์ผ๋ง ๊ณตํด์ผ์ ์์ฝ์ด ๋ถ๊ฐ๋ฅํ๋๋ก ์ค์ ํ ์ ์์ ๊ฒ์ ๋๋ค. ์ด๋ป๊ฒ ํ๋ฉด ๋ชจ๋ ๊ณตํด์ผ ๋ ์ง๋ฅผ DB์ ์ ์ฅํ๊ณ ์ด๋ฅผ ํ์ฉํ ์ ์์๊น์? ์ธํฐ๋ท์์ ๋ชจ๋ ๊ณตํด์ผ์ ์ฐพ์์ DB์ ํ๋์ฉ ์ ๋ ฅํ๋ฉด ๋ ๊น์? ๋ฌผ๋ก ๊ทธ๋ ๊ฒ ํ ์ ์๊ฒ ์ง๋ง ๋๋ฌด ๋ณ๋ก์ธ ๊ฑฐ ๊ฐ์์.. ๐ ๋ฐฉ๋ฒ์ ์ฐพ์๋ณด์์ต๋๋ค. ๐ Solution ํ๊ตญ์ฒ๋ฌธ์ฐ๊ตฌ์_ํน์ผ ์ ๋ณด (์ฒ๋ฌธ์ฐ์ฃผ์ ๋ณด)๊ตญ๊ฒฝ์ผ์ ๋ณด, ๊ณตํด์ผ์ ๋ณด, ๊ธฐ๋ ์ผ์ ๋ณด, 24์ ๊ธฐ์ ๋ณด, ์ก์ ์ ๋ณด๋ฅผ ์กฐํํ๋ ์๋น์ค ์ ๋๋ค. www.data.go.kr ๊ฒ์ ์ค ๊ณตํด์ผ ๊ด๋ จ ์คํ API๊ฐ ์์์ ์ฐพ๊ฒ ๋์๊ณ ์ ๋งํฌ์..