- DATABASE
- spring ์์ ๋ก๊ทธ์ธ
- Java
- docker
- ๋ฆฌ๋ ์ค ๋ช ๋ น์ด
- Rp2๊ธฐ
- java error
- mysql
- Data Structure
- node js
- @CreatedDate
- SSL
- GIT
- RP 2๊ธฐ
- C++
- ์์คํ ์ํํธ์จ์ด
- aligoapi
- OpenAPI
- spring์ผ๋ก https ์ ์ฉ
- spring ๊ตฌ๊ธ ์์ ๋ก๊ทธ์ธ
- Unity
- ๊ตฌ๊ธ ์์ ๋ก๊ทธ์ธ
- Spring
- merge sort
- ํจ์คํธ์บ ํผ์คX์ผ๋์
- SQL
- MAKE US
- datagrip
- MethodArgumentNotValidException
- Quick Sort
๋ชฉ๋ก์ ์ฒด ๊ธ (132)
YS's develop story

๐ฉโ๐ป ๋๋น ์ฐ์ ํ์ (BFS), ๊น์ด ์ฐ์ ํ์ (DFS) ์ ๋ฆฌ with Python ๐ฅ ๋๋น ์ฐ์ ํ์ (Breadth-First-Search) Node ๊ฐ์ ๋ ๋ฒจ์ ์๋ Node๋ค (ํ์ Node๋ค)์ ๋จผ์ ํ์ํ๋ ๋ฐฉ์์ ๋๋ค. ํ์ด์ฌ์ ์ด์ฉํ ๊ทธ๋ํ ํํ ์ฝ๋ graph = dict() graph['A'] = ['B', 'C'] graph['B'] = ['A', 'D'] graph['C'] = ['A', 'G', 'H', 'I'] graph['D'] = ['B', 'E', 'F'] graph['E'] = ['D'] graph['F'] = ['D'] graph['G'] = ['C'] graph['H'] = ['C'] graph['I'] = ['C', 'J'] graph['J'] = ['I'] ๋๋น..

๐ฉโ๐ป ์์ฐจ ํ์(Sequential Search)๊ณผ ์ด์ง ํ์(Binary Search) ์ ๋ฆฌ ๐ฅ ์์ฐจ ํ์(Sequential Search) ๋ฐ์ดํฐ๊ฐ ๋ด๊ฒจ์๋ ๋ฆฌ์คํธ๋ฅผ ์์์๋ถํฐ ํ๋์ฉ ์ดํด๋ณด์์ ์ํ๋ ๋ฐ์ดํฐ๋ฅผ ์ฐพ๋ ๋ฐฉ๋ฒ์ ๋๋ค. ๐ ์์ฐจ ํ์ ์ฝ๋ def sequentialSearch(list, search): for index in range(len(list)): if list[index] == search: return True return False โ๏ธ ์์ฐจ ํ์ ์๊ฐ ๋ณต์ก๋ ์ฐพ๊ณ ์ ํ๋ ๊ฐ์ด ๋ฆฌ์คํธ์ ๋งจ ๋ง์ง๋ง์ ์์ ๋, ๋ฆฌ์คํธ์ ๊ธธ์ด๋งํผ ๋ฐ์ดํฐ๋ฅผ ๋น๊ตํด์ผ ํฉ๋๋ค. ๋ฐ๋ผ์ ์๊ฐ ๋ณต์ก๋๋ O(n)์ ๋๋ค. ๐ณ ์ด์ง ํ์ (Binary Search) ํ์ํ ๋ฐ์ดํฐ๋ฅผ ์ ํํ ๋ฐ์ผ๋ก ๋๋์ด ํ์ชฝ์..

๐ฉโ๐ป ํต ์ ๋ ฌ (Quick Sort) ์ ๋ฆฌ with Python ๐ฅ ํต ์ ๋ ฌ (Quick Sort)์ด๋? ๐ธ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ๊ฝ, Quick Sort ๊ธฐ์ค์ (Pivot)์ ์ ํด์, ๊ธฐ์ค์ ๋ณด๋ค ์์ ๋ฐ์ดํฐ๋ ์ผ์ชฝ, ํฐ ๋ฐ์ดํฐ๋ ์ค๋ฅธ์ชฝ์ผ๋ก ๋ชจ์ผ๋ ํจ์๋ฅผ ์์ฑํฉ๋๋ค. ๋๋์ด์ง ์ผ์ชฝ, ์ค๋ฅธ์ชฝ ๋ฐ์ดํฐ๋ฅผ ์ฌ๊ท ์ฉ๋ฒ์ ์ฌ์ฉํด์ ๋ค์ ๋์ผ ํจ์๋ฅผ ํธ์ถํ์ฌ ์ ์์ ์ ๋ฐ๋ณตํฉ๋๋ค. ํจ์๋ ์ผ์ชฝ, Pivot, ์ค๋ฅธ์ชฝ์ ๋ฆฌํดํ๊ฒ ๋ฉ๋๋ค. Divde And Conquer ๊ธฐ๋ฒ์ ์ฌ์ฉํ๋ ๋ํ ์๊ณ ๋ฆฌ์ฆ ์ค ํ๋์ ๋๋ค. ๐ณ ํต ์ ๋ ฌ ๊ตฌํ with Python # QuickSort def quickSort(list): if len(list) = pivot] return quickSort(left) + [pivot] + quick..

๐ฉโ๐ป ๋ณํฉ ์ ๋ ฌ (Merge Sort) ์ ๋ฆฌ with Python ๐ณ ๋ณํฉ ์ ๋ ฌ (Merge Sort)์ด๋? ์ฌ๊ท ์ฉ๋ฒ์ ํ์ฉํ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค. ๋ฆฌ์คํธ๋ฅผ ์ ๋ฐ์ผ๋ก ์๋ผ ๋น์ทํ ํฌ๊ธฐ์ ๋ ๋ฆฌ์คํธ๋ก ๋๋๋๋ค. ๊ฐ ๋ถ๋ถ ๋ฆฌ์คํธ๋ฅผ ์ฌ๊ท์ ์ผ๋ก ๋ณํฉ ์ ๋ ฌ์ ์ด์ฉํด ์ ๋ ฌํฉ๋๋ค. ๋ ๋ถ๋ถ ๋ฆฌ์คํธ๋ฅผ ๋ค์ ํ๋์ ์ ๋ ฌ๋ ๋ฆฌ์คํธ๋ก ๋ณํฉํฉ๋๋ค. Merge Sort๋ Divide And Conquer์ ๋ํ์ ์ธ ์์ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค. ๐ฅ ๋ณํฉ ์ ๋ ฌ ๊ตฌํ with Python def mergeSort(data): if len(data) leftPoint and len(right) > rightPoint: if left[leftPoint] > right[rightPoint]: merged.append(right[rightPo..

๐ฉโ๐ป ๋์ ๊ณํ๋ฒ๊ณผ ๋ถํ ์ ๋ณต ์ ๋ฆฌ with Python ๐ฅ ๋์ ๊ณํ๋ฒ (Dynamic Programming) ๋์ ๊ณํ๋ฒ, Dynamic Programming์ด๋? ์ ๋ ฅ ํฌ๊ธฐ๊ฐ ์์ ๋ถ๋ถ ๋ฌธ์ ๋ค์ ํด๊ฒฐํ ํ, ํด๋น ๋ถ๋ถ ๋ฌธ์ ์ ํด๋ฅผ ํ์ฉํด์, ํฐ ๋ถ๋ถ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ณ ์ต์ข ์ ์ผ๋ก ์ ์ฒด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ์๊ณ ๋ฆฌ์ฆ ๊ธฐ๋ฒ์ ๋๋ค. ์ํฅ์ ์ ๊ทผ๋ฒ์ผ๋ก ๊ฐ์ฅ ์ตํ์ ํด๋ต์ ๊ตฌํ ํ ์ด๋ฅผ ์ ์ฅํ๊ณ , ํด๋น ๊ฒฐ๊ด๊ฐ์ ์ด์ฉํด ์์ ๋ฌธ์ ๋ฅผ ํ์ด๊ฐ๋ ๋ฐฉ์์ ํ์ฉํฉ๋๋ค. Memoization ๊ธฐ๋ฒ์ ํ์ฉํฉ๋๋ค. Memoization (๋ฉ๋ชจ์ด์ ์ด์ ) : ํ๋ก๊ทธ๋จ ์คํ ์ ์ด์ ์ ๊ณ์ฐํ ๊ฐ์ ์ ์ฅํ๋ฉฐ, ๋ค์ ๊ณ์ฐํ์ง ์๋๋ก ํ์ฌ ์ ์ฒด ์คํ ์๋๋ฅผ ๋น ๋ฅด๊ฒ ํ๋ ๊ธฐ์ ์ ๋๋ค. ๋ฌธ์ ๋ฅผ ์๊ฒ ์ชผ๊ฐค ๋, ๋ถ๋ถ ๋ฌธ์ ๋ ์ค๋ณต๋์ด ์ฌํ์ฉ๋ฉ๋๋ค. ..

๐ฉโ๐ป ๋ฒ๋ธ ์ ๋ ฌ, ์ ํ ์ ๋ ฌ, ์ฝ์ ์ ๋ ฌ ์ ๋ฆฌ with Python ๐ฅ ๋ฒ๋ธ ์ ๋ ฌ ๋ฒ๋ธ ์ ๋ ฌ์ด๋? ์ธ์ ํ ๋ ๋ฐ์ดํฐ๋ฅผ ๋น๊ตํด์ ์์ ์๋ ๋ฐ์ดํฐ๊ฐ ๋ค์ ์๋ ๋ฐ์ดํฐ๋ณด๋ค ํฌ๋ฉด, ์๋ฆฌ๋ฅผ ๋ฐ๊พธ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค. Python ์ฝ๋ def bubbleSort(list): swaped = False for index in range(len(list) - 1): for index2 in range(len(list) - index - 1): if list[index2] > list[index2 + 1]: list[index2], list[index2 + 1] = list[index2 + 1], list[index2] swaped = True if swaped == False: break return list ์๊ฐ ๋ณต..

๐จ๐ผโ๐ป Graph (๊ทธ๋ํ) ์ ๋ฆฌ With Python ๐ฅ Graph ๋? ์ค์ ์ธ๊ณ์ ํ์์ด๋ ์ฌ๋ฌผ์ Vertex(์ ์ )์ Edge(๊ฐ์ )๋ก ํํํ๊ธฐ ์ํด ์ฌ์ฉํฉ๋๋ค. Vertex : ์์น๋ฅผ ๋งํฉ๋๋ค. Node๋ผ๊ณ ํ๊ธฐ๋ ํฉ๋๋ค. Edge : ์์น ๊ฐ์ ๊ด๊ณ๋ฅผ ํ์ํ ์ ์ ๋๋ค. Degree : ๋ฐฉํฅ์ด ์๋ ๊ทธ๋ํ์์ ํ๋์ ์ ์ ์ ์ธ์ ํ ์ ์ ์ ์์ ๋๋ค. Simple Path : ์ฒ์ ์ ์ ๊ณผ ๋ ์ ์ ์ ์ ์ธํ๊ณ ์ค๋ณต๋ ์ ์ ์ด ์๋ ๊ฒฝ๋ก์ ๋๋ค. (A-B-C๋ Simple Path) Cycle : Simple Path์ ์์ ์ ์ ๊ณผ ์ข ๋ฃ ์ ์ ์ด ๋์ผํ ๊ฒฝ์ฐ์ ๋๋ค. ๐ ๊ทธ๋ํ์ ์ข ๋ฅ Undirected Graph ๋ฐฉํฅ์ด ์๋ ๊ทธ๋ํ์ ๋๋ค. Edge๋ฅผ ํตํด Vertex ์ ๋ฐฉํฅ์ผ๋ก ๊ฐ ์ ์์ต๋๋ค. Dire..