Today, What I learned?
์๊ณ ๋ฆฌ์ฆ ๊พธ์คํ ์์๊ฐ๊ธฐ ๐ช ... ๋ฅผ ๊ณ์ํ๋ฉฐ ์ค๋์ ์ธ ๊ฐ์ง์ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ๋ํด js๋ก ๊ตฌํํด๋ณด์๋ค.
์ถ๊ฐ์ ์ผ๋ก ๋ค์ด๋ฒ ๋ฉ์ธํ์ด์ง ์ฝ๋๋ฅผ ๋ถ์ํ๋ค๊ฐ ์๊ฒ ๋ display: table์ ๋ํด์ ์ ๋ฆฌํด๋ณธ๋ค.
์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ
์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ๋ชจ๋ ์์๊ฐ ์ ๋ ฌ๋์ด์ผ ํ๊ณ , ๊ทธ ์์์ ๊ฐ ์์๋ณ๋ก ์์ฐจ์ ์ผ๋ก ๋น๊ต๋๊ธฐ ๋๋ฌธ์ ์ด์ค for๋ฌธ์ ์ด์ฉํ๋ค.
๋ฐ๋ผ์ ์๊ฐ ๋ณต์ก๋๋ ๋ชจ๋ O(n^2)๋ฅผ ๊ฐ์ง๋ค.
๋ฒ๋ธ ์ ๋ ฌ
๋ฒ๋ธ ์ ๋ ฌ์ ๋ชจ๋ ์์๋ค์ ๋์์ผ๋ก, ์ธ์ ํ ๋ ๊ฐ์ ๋น๊ตํด์ ์ผ์ชฝ์ ๊ฐ์ด ๋ ํฌ๋ค๋ฉด ์๋ฆฌ๋ฅผ ๋ฐ๊พธ๋ ๊ณผ์ ์ ๋ฐ๋ณตํด์ ์ ๋ ฌํ๋ ๋ฐฉ์์ด๋ค.
์๋ ์ด๋ฏธ์ง๋ฅผ ์ฐธ๊ณ ํ๋ฉด ์ดํด๊ฐ ์ข ๋ ํธํ๋ค!
js๋ก ๊ตฌํํ๊ธฐ
function bubble_sort(arr) {
let answer = [...arr];
for (let i = 0; i < answer.length; i++) {
for (let j = 0; j < answer.length - i; j++) {
if (answer[j] > answer[j + 1]) {
[answer[j + 1], answer[j]] = [answer[j], answer[j + 1]];
}
}
}
return answer;
}
๋ ๋ฒ์งธ for๋ฌธ์ ๋ง์ง๋ง ์ธ๋ฑ์ค ์ ๊น์ง๋ง ๋์์ผ ํ๊ธฐ ๋๋ฌธ์ (๋ง์ง๋ง ์ธ๋ฑ์ค ๋ค์ ๊ฐ์ ์์ผ๋!) answer.length-i
๋งํผ ๋๋ค.
๋ ์๋ฅผ ๋น๊ตํ๋ฉฐ ์์ ์์๊ฐ ๋ค์ ์์๋ณด๋ค ํฌ๋ค๋ฉด ๋ ๊ฐ์ ๊ตํํ๋ค.
์ ํ ์ ๋ ฌ
์ ํ ์ ๋ ฌ์ ์ฃผ์ด์ง ๋ฐ์ดํฐ๋ฅผ ์ํํ๋ฉฐ ๊ฐ์ฅ ์์ ๊ฐ๋ถํฐ ์ฐจ๋ก๋๋ก ์ ํํด์ ๋์ดํ๋ ๋ฐฉ์์ด๋ค.
์ ๋ ฌ๋์ง ์์ ๋ฐ์ดํฐ ์ค์์ ๊ฐ์ฅ ์์ ๊ฐ์ ์ ํํด์, ์ ํ ๊ฐ๊ณผ ์ ๋ ฌ๋์ง ์์ ๋ฐ์ดํฐ ์ค ์ฒซ ๋ฒ์งธ ์์์ ๊ตํํ๋ค.
js๋ก ๊ตฌํํ๊ธฐ
function selection_sort(arr) {
let answer = [...arr];
for (let i = 0; i < answer.length; i++) {
let target = i;
for (let j = i + 1; j < answer.length; j++) {
if (answer[j] < answer[target]) {
target = j;
}
}
[answer[i], answer[target]] = [answer[target], answer[i]];
}
return answer;
}
๋์ ๊ฒฝ์ฐ์๋ ์ ํ๊ฐ์ ์ธ๋ฑ์ค๋ก ์ฐพ์๋ค.
๋ค์ ๊ฐ์ด ์ ํ๊ฐ๋ณด๋ค ์์ ๊ฒฝ์ฐ, ์ธ๋ฑ์ค๋ฅผ ํด๋น ์ธ๋ฑ์ค๋ก ๊ต์ฒดํด์ ๊ฐ๋ค์ด ๊ตํ๋๋๋ก ํ๋ค.
์ฝ์ ์ ๋ ฌ
์ฝ์ ์ ๋ ฌ์ ์ฐ์ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฌ๋ ๋ถ๋ถ๊ณผ ์ ๋ ฌ๋์ง ์์ ๋ถ๋ถ์ผ๋ก ๊ตฌ๋ณํ๋ค.
์ ๋ ฌ๋์ง ์์ ๋ถ๋ถ์์ ์ฒซ ๋ฒ์งธ ๋ฐ์ดํฐ๋ฅผ ๋ฝ์์ ์ ๋ ฌ ๋ฐ์ดํฐ ์ค ๋ฝ์ ๋ฐ์ดํฐ๊ฐ ์์ด์ผ ํ ์ ์๋ฆฌ๋ฅผ ์ฐพ์ ๋ฃ๋ ๊ณผ์ ์ ๋ฐ๋ณตํ๋ค.
์ด ์๊ณ ๋ฆฌ์ฆ์ ์ ๋ ฅ์ด ๊ฑฐ์ ์ ๋ ฌ๋ ๊ฒฝ์ฐ, ๋ค๋ฅธ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ๋ณด๋ค ๋น ๋ฅด๊ฒ ์ํ๋๊ธฐ ๋๋ฌธ์ O(n)์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ์ง ์๋ ์๋ค.
ํ์ํ ๋๋ง ์์น๋ฅผ ๋ฐ๊พธ๊ธฐ ๋๋ฌธ์ ํจ์จ์ ์ด๋ผ๊ณ ๋ ๋ณผ ์ ์์ง๋ง, ์ฝ์ ๋ ์์น๋ฅผ ์ฐพ๊ธฐ ์ํด ํ ๋ฒ์ ํ ์๋ฆฌ์ฉ๋ง ์ด๋ํ๊ธฐ ๋๋ฌธ์ ๋ฐ์ดํฐ๊ฐ ์ฌ๋ฌ ๋ฒ ์ด๋ํด์ผ ํ๋ค๋ ๋จ์ ์ด ์๋ค.
js๋ก ๊ตฌํํ๊ธฐ
function insertion_sort(arr) {
let answer = [...arr];
// i+1๋ถํฐ ์์ ์๋ณด๋ค ์๋ค๋ฉด? j=0๊น์ง ๋์๊ฐ๋ฉฐ ๋ง๋ ์๋ฆฌ๋ก ๊ต์ฒด
for (let i = 1; i < answer.length; i++) {
let target = i;
for (let j = i; j >= 0; j--) {
if (answer[target] < answer[j]) {
[answer[target], answer[j]] = [answer[j], answer[target]];
target--;
}
}
}
return answer;
}
์ ํ์ ๋ ฌ๊ณผ ๋น์ทํ๊ฒ ์ด๋ฒ์๋ ์ธ๋ฑ์ค๋ฅผ ์ด์ฉํ๋ค.
์ ํ ๊ฐ์์ ๊ฑฐ๊พธ๋ก ๋์๊ฐ๋ฉฐ ์๊ธฐ ์๋ฆฌ์ ํด๋นํ๋ ์ธ๋ฑ์ค๋ฅผ ์ฐพ์์ ๊ฐ์ ๊ตํํ๋ ๋ฐฉ์!
display: table
css์ display ์์ฑ ๊ฐ์ผ๋ก๋ ๋ํ์ ์ผ๋ก block, inline-block, none, flex, grid.. ๊ฐ์ ๊ฒ๋ค์ด ์๋๋ฐ,
ํ์ฒ๋ผ ํํํ ์ ์๋ ์์ฑ ๊ฐ๋ค๋ ์๋ค.
์ด๊ฒ์ ์๊ฒ ๋์์ ๋, table ํ๊ทธ๋ ์ด๋ฏธ ์๋๋ฐ display ์์ฑ ๊ฐ์ table ๊ด๋ จ ์์ฑ๋ค์ด ๋ง์ ์ด์ ๊ฐ ๋ญ์ง??... ๐ค ํ๋ ์๋ฌธ์ด ๋ค์๋๋ฐ,
์ด ์์ฑ์ ๋ง ๊ทธ๋๋ก css ์์ฑ์ด๊ธฐ ๋๋ฌธ์, ํ ๊ฐ์ ๋ ์ด์์์ ๊ตฌ์ฑํ๊ณ ์ถ์ ๋ ์ฌ์ฉํ๋ค๋ ๊ฒ์ด๋ค!..
์๊ฐ๋ณด๋ค ์ข ๋ฅ๊ฐ ๋ ๋ง์์ง๋ง ๋๋ต์ ์ผ๋ก ์ด ์ ๋๋ง ์์๋ ๊ด์ฐฎ๊ฒ ๋ค ์ถ๋ค.
- table : <table> ํ๊ทธ์ฒ๋ผ ์ฌ์ฉ
- table-cell : display:table ์ด ์ ์ธ๋ ๋ถ๋ชจ ์์ ์๋์ <td> ํ๊ทธ์ฒ๋ผ ์ฌ์ฉ.
- table-row : display:table ์ด ์ ์ธ๋ ๋ถ๋ชจ ์์ ์๋์ <tr> ํ๊ทธ์ฒ๋ผ ์ฌ์ฉ.
table-cell
์ง์ ์์๋ ๊ฐ์ ๋๋น๋ก ๊ฐ๋ก ์ ๋ ฌ๋๋ ๊ฒ์, table-row
์ง์ ์์๋ ๊ฐ์ ์ธ๋ก ๋์ด๋ก ์ธ๋ก ์ ๋ ฌ๋๋ ๊ฒ์ ๋ณผ ์ ์๋ค.
์ด๋ป๊ฒ ์ฐ์ด๋?
๋ํ์ ์ผ๋ก ๋ค์ด๋ฒ ๋ฉ์ธ ํ์ด์ง์์ gnb ํญ์ ๋๋ณด๊ธฐ๋ฅผ ๋๋ฅด๋ฉด ๋์ค๋ ๋๋กญ๋ค์ด ๋ฉ๋ด๊ฐ ์๋ค.
๋ค์ด๋ฒ์์ ์ ๊ณตํ๋ ๋ชจ๋ ์๋น์ค๋ฅผ ๋ณผ ์ ์๋ ๋ฉ๋ด์ธ๋ฐ, ์ ์ฒด๊ฐ display:table
๋ก ์ง์ ์ด ๋์ด์๋ค.
๊ทธ๋ฆฌ๊ณ ํ๋จ ์์ ์์๋ค์ table-cell
์ด๋ผ๋ ์์ฑ์ ๊ฐ๊ณ ์์ด์ ์์ฐ์ค๋ฝ๊ฒ ๊ฐ๋ก ์ ๋ ฌ๋๋ฉฐ ๋์ผํ ๋๋น๋ค์ ๊ฐ๋๋ค.
๋์ผํ ๋๋น๋ฅผ ๊ฐ์ง๋ค๋ ๊ฒ๋ง์ผ๋ก๋ ์ด ์์ฑ์ ์ด๋ ๊ฒ ๋ง์ ํค์๋๊ฐ ์๋ ๋๋กญ๋ค์ด ๋ฉ๋ด์์ ์จ๋ณผ ์ด์ ๊ฐ ์ถฉ๋ถํ์ง ์์๊น!..
ํธํ์ฑ์ ์ด๋ค์ง?
Can I use ์์ ์ฐพ์๋ณธ ํธํ์ฑ...
๋๋ฆ ์ต๊ทผ์ IE์์๋ ์ง์์ ํด์ฃผ๋!... ์๊ฐ๋ณด๋ค ๊ด์ฐฎ์ ํธํ์ฑ์ ๊ฐ์ง๊ณ ์๋ค. ๐
ํ์๋ค๊ณผ ๋ชจ๋ ๊น ํ์
์ฐ์ต์ ํ๊ธฐ๋ก ํ๋ค.
๊น์ ๋ ์ต์ํด์ ธ๋ณด์~ ๐
'๐ Studying > ๐ TIL' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
ํ์ด์ด๋ฒ ์ด์ค (0) | 2022.11.17 |
---|---|
์๋ฐ์คํฌ๋ฆฝํธ๋ง์ผ๋ก SPA ๊ตฌํ (0) | 2022.11.16 |
TIL : CPU, ์ด์งํ์, ์ฌ๊ทํจ์ (0) | 2022.11.11 |
[JavaScript] ์ฐ๊ฒฐ๋ฆฌ์คํธ Linked List in JS (0) | 2022.11.10 |
TIL : ๋ฌธ์ฅ ๋ด ์ํ๋ฒณ ์ต๋ ๋น๋์ ๊ตฌํ๊ธฐ (1) | 2022.11.09 |
Comment