Programming (40) ์ธ๋ค์ผํ ๋ฆฌ์คํธํ #5_๋ฆฌ์คํธ ๋ฌธ์ 2(๋คํญ์, ๋ถ๋ถ์งํฉ, ํฉ์งํฉ, ๊ต์งํฉ) ๋คํญ์ ๋ง์ - ๋คํญ์์ ํค๋ ๋จ์ผ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ก ๊ตฌํ #include #include typedef struct node { int coef; int exp; struct node* next; }node; typedef struct { node* H; }list; node* getnode (node* p) { if (p == NULL) { p = (node*)malloc(sizeof(node)); p->next = NULL; } return p; } node* appendTerm (node* k, int c, int e) { node* t = NULL; t = getnode(t); t->coef = c; t->exp = e; t->next = NULL; k->next = t; k = t; return k;.. #4_ ๋ฆฌ์คํธ ๋ฌธ์ - node ์ ์ typedef struct node { char elem; struct node* next; }node; - list ์ ์ typedef struct { struct node* H; }list; - node ์์ฑ node* getnode (node* p) { if (p == NULL) { p = (node*)malloc(sizeof(node)); //nodeํ ๋น p->next = NULL; } return p; } - traverse : ์ํ void traverse (list* L) { node* p = L->H; while (p->next != NULL) { printf("%c\n", p->elem); p = p->next; } } - isEmpty int isEmpty (list*.. #4. ๋ฆฌ์คํธ : ๋ฐ์ดํฐ๊ตฌ์กฐ์ ์ถ์ํ(ADT) : ์ฐ์์ ์ธ ์์ ๊ฐ์ฒด๋ค์ ๋ชจ๋ธ๋ง - element์ ๋ํ ์ ๊ทผ ๋๊ตฌ - boolean isEmpty() - int size() - iterator elements() - element get(r) - element set(r,e) - add(r,e) - addFirst(e) - addLast(e) - element remove(r) - element removeFirst() - element removeLast() - invalidRankException() : ์๋ชป๋ list์ ์ ๊ทผํ๋ คํ์ ๋ - fullListException() : list ์์๊ฐ ๋ค ์ฐผ์์ ๋ - emptyListException() : list๊ฐ ๋น์ด์์ ๋ - get() - set(r,e) -.. #3_๋ฐฐ์ด๋ฌธ์ [1] ๋ฐฐ์ด์ ํฌ๊ธฐ์ ๋ฐฐ์ด์ ์ ์๋ฅผ ์ ๋ ฅํ๊ณ ๋ค์ง์ ๋ฐฐ์ด์ ํฌ๊ธฐ์ ๋ค์ง์ ๋ฐฐ์ด ์ธ๋ฑ์ค๋ฅผ ์ ๋ ฅ๋ฐ๊ณ ๋ค์ง๊ธฐ๋ฅผ ํ๊ณ ์ถ๋ ฅ #include void change (int x[], int start, int end) { int tmp; int dis = end - start; int N; if (dis%2 == 0) { N = (end - start)/2; } else { N = (end - start)/2 + 1; } for (int i = start; i < start + N; i++) { tmp = x[i]; x[i] = x[end + start - i]; x[end + start - i] = tmp; } } int main () { int n, x[100]; int cn, cx[100]; scanf("%d.. #2_๋ฌธ์ [1] 1๋ถํฐ n๊น์ง ํฉ ๊ตฌํ๊ธฐ #include int Sum (int n) { if (n == 1) return 1; else return n + Sum (n - 1); } int main () { int n; scanf("%d", &n); printf("%d\n", Sum(n)); return 0; } [2] ๊ฐ ์๋ฆฟ์ ๋์์๋ฆฌ๋ถํฐ ์ถ๋ ฅ #include void digit (int n) { if (n < 10) { printf("%d\n", n); } else { digit(n/10); printf("%d\n", n%10); } } int main () { int n; scanf("%d", &n); digit(n); return 0; } [3]๊ฐ ์๋ฆฟ์ ๋ฎ์์๋ฆฌ๋ถํฐ ์ถ๋ ฅ #include void di.. #2. ์ฌ๊ท - ์ฌ๊ท์ (recursive) : ์๊ณ ๋ฆฌ์ฆ ์์ ์ ์ฌ์ฉํ์ฌ ์ ์๋ ์๊ณ ๋ฆฌ์ฆ - ๋น์ฌ๊ท์ (nonrecursive) : ์ฌ๊ท์ ์ ๋ฐ๋ - ์ฌ๊ท ์ผ์ด์ค(recursion) : ๋ค์ ์ฌ๊ทํธ์ถ์ ํ๋ ๋ถ๋ถ์ผ๋ก ์์์ง subproblem์ ๋์์ผ๋ก ์์ฑ - ๋ฒ ์ด์ค ์ผ์ด์ค(base case) : ์ข ๋ฃ์กฐ๊ฑด. subproblem์ด ์ถฉ๋ถํ ์์์ง๋ฉด ์ง์ ํด๊ฒฐ n๋ถํฐ 1๊น์ง ํฉ์ ๊ตฌํ๋ Sum ํจ์์ ์์ฌ์ฝ๋๋ฅผ ์์๋ก ๋ณด๋ฉด, n = 3์ผ ๋ ์๋์๋ฆฌ๋ฅผ ์ดํด๋ณด๋ฉด, - ๋ฒ ์ด์ค ์ผ์ด์ค : ์ฌ๊ทํจ์์์ ํญ์ ๊ฐ์ ธ์ผ ํ๋ ๋ถ๋ถ์ผ๋ก ์ด ๋ถ๋ถ์ ์ฌ๊ท ์์ด ์ง์ ํด๊ฒฐ - ์งํ ๋ฐฉํฅ : ์ฌ๊ทํธ์ถ์ ํญ์ ๋ฒ ์ด์ค ์ผ์ด์ค๋ฅผ ํฅํ๋ ๋ฐฉํฅ์ผ๋ก ์งํ - ์ ์์๋ ๊ฐ์ : ๋ชจ๋ ์ฌ๊ทํธ์ถ์ด ์ ์ ์๋ํ๋ค๊ณ ๊ฐ์ - ์ ์ ํ ์ฌ์ฉ : ์ฑ๋ฅ์ ํ ๋๋ฌธ์ ๊ผญ ํ.. #1_๋ฌธ์ 1. ๋๋จธ์ง ์ฐ์ฐ +,-๋ง ์ฌ์ฉํ์ฌ ๋๋จธ์ง ์ฐ์ฐ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๋ modulo()ํจ์๋ฅผ ๋ง๋ค๊ธฐ #include int modulo (int a, int b) { int div = 0; while (a>=b) { a -= b; } return a; } int main () { int a,b; int answer; scanf("%d %d", &a, &b); answer = modulo(a,b); printf("%d\n", answer); return 0; } 2. ์ต๋ 1ํ ๊ตฌํ๊ธฐ ๋นํธํ๋ ฌ์์ 1์ ๊ฐ์ฅ ๋ง์ด ํฌํจํ๊ณ ์๋ ํ๋ ฌ์ ์ธ๋ฑ์ค๋ฅผ ๋ฐํํ๋ mostOnes() ๋ง๋ค๊ธฐ #include int mostOnes (int A[][100], int n) { int row = 0, jmax = 0; for (in.. #1. ์๊ณ ๋ฆฌ์ฆ ๋ถ์ ์๊ณ ๋ฆฌ์ฆ(algorithm) : ์ฃผ์ด์ง ๋ฌธ์ ๋ฅผ ์ ํํ ์๊ฐ ๋ด์ ํด๊ฒฐํ๋ ๋จ๊ณ์ ์ ์ฐจ ๋ฐ์ดํฐ ๊ตฌ์กฐ(data structure) : ๋ฐ์ดํฐ๋ฅผ ์กฐ์งํ๊ณ ์ ๊ทผํ๋ ์ฒด๊ณ์ ๋ฐฉ์ ๐์ข์ ์๊ณ ๋ฆฌ์ฆ์ด๋? - ์์ ์ ์์๋๋ ์คํ์๊ฐ(์๊ฐ๋ณต์ก๋) - ๊ธฐ์ต์ฅ์ ์ฌ์ฉ๋(๊ณต๊ฐ๋ณต์ก๋) - ์คํ์๊ฐ์ Input size์ ํจ๊ป ์ฑ์ฅ - ์ต์ ์คํ์๊ฐ(worst running time)์ ์ง์ค โ ์คํ์๊ฐ ๊ตฌํ๋ ๋ฐฉ๋ฒ 1. ์คํ์ ๋ฐฉ๋ฒ - ์์คํ ์ฝ์ ์ฌ์ฉํ์ฌ ์ค์ ์คํ์๊ฐ ์ ํํ ์ธก์ - ์คํ์ ํฌํจ๋์ง ์์ ์ ๋ ฅ์ ๋ํ ์คํ์๊ฐ์ด ์ ๋๋ก ๋ฐ์๋์ง ์์ ์ ์๋ค - ๋์ผํ ์ํํธ์จ์ด์ ํ๋์จ์ด ํ๊ฒฝ์์ ์คํ์ ์งํํด์ผํ๋ค 2. ์ด๋ก ์ ๋ฐฉ๋ฒ - ๋ชจ๋ ์ ๋ ฅ ๊ฐ๋ฅ์ฑ์ ๊ณ ๋ คํ๋ค - ํ๋์จ์ด๋ ์ํํธ์จ์ด์ ๋ฌด๊ดํ๊ฒ ์๊ณ ๋ฆฌ์ฆ์ ์๋ ํ๊ฐํ .. ์ด์ 1 2 3 4 5 ๋ค์