ch06 - 배열, 동적배열, 정렬...

Advanced Networking Tech. Lab.Yeungnam University (yuANTL)

Programming LanguageProf. Young-Tak Kim6 - 35

동적배열

배열을위한메모리할당방법 지역 변수로 자동 할당

int score[100];score[10] = 123;

지역 변수로 배열을 생성하는 경우, 크기에 제한이 있음

동적배열 동적 메모리 할당

int *score;score = (int *) malloc(100*sizeof(int));score[10] = 123;

동적 메모리 할당으로 배열을 생성하는 경우, 더 큰 배열을 사용할수 있음



동적 (dynamic) 메모리할당, 동적배열생성

동적메모리할당 실행 도중에 동적으로 메모리를

할당받는 것 사용이 끝나면 시스템에 메모리를

반납 int score[100]; //정적 배열 대신,

score = (int *) malloc(100*sizeof(int)); 로 동적으로 메모리를 할당하여, 배열로 사용 할 수 있음

필요한 만큼만 할당을 받고메모리를 매우 효율적으로 사용

malloc() 계열의 라이브러리함수를 사용

할당요구

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

int main(void){int *p;p = (int *)malloc( sizeof(int) );...}

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

int main(void){int *p;p = (int *)malloc( sizeof(int) );...}

프로그램

운영체제



동적메모리할당예제

#include <stdio.h>#include <stdlib.h>int main(void) {

int *score; int i;score = (int *)malloc( 100*sizeof(int) ); if( p == NULL ) // 반환값이 NULL인지 검사{

printf("동적 메모리 할당 오류\n");exit(1);

}for(i=0 ; i<100 ; i++)

score[i] = 0;free(p); return 0;

}

동적 메모리 할당

동적 메모리 해제



동적메모리할당

void *malloc(size_t size) size는 바이트의 수 malloc()함수는 메모리 블럭의 첫 번째 바이트에 대한 주소를 반환 만약 요청한 메모리 공간을 할당할 수 없는 경우에는 NULL값을

반환

int *score;score = (int *)malloc(100*sizeof(int));if( score == NULL ){

... // 오류 처리}

score?????

…



동적메모리반납

void free(void *ptr) free()는 동적으로 할당되었던 메모리 블록을 시스템에 반납 ptr은 malloc()을 이용하여 동적 할당된 메모리를 가리키는 포인터

int *score;score = (int*)malloc(100*sizeof(int));…free(score);

score?????

…



정렬 (sorting) 이란?

정렬은물건을크기순으로오름차순이나내림차순으로나열하는것

정렬은컴퓨터공학분야에서가장기본적이고중요한알고리즘중의하나



정렬이란?

정렬은자료탐색에있어서필수적이다. (예) 만약사전에서단어들이정렬이안되어있다면?



선택정렬(selection sort)

선택정렬(selection sort): 정렬이안된숫자들중에서최소값을선택하여배열의첫번째요소와교환



선택정렬(selection sort)

선택정렬(selection sort): 정렬이안된숫자들중에서최소값을선택하여배열의첫번째요소와교환

몇개의단계만살펴보자.

5 3 8 1 2 7



선택정렬#include <stdio.h>#define SIZE 10

int main(void){

int list[SIZE] = { 3, 2, 9, 7, 1, 4, 8, 0, 6, 5 };int i, j, temp, least;

for(i = 0; i < SIZE-1; i++){

least = i; for(j = i + 1; j < SIZE; j++)

if(list[j] < list[least])least = j;

temp = list[i]; list[i] = list[least];list[least] = temp;

}

for(i = 0;i < SIZE; i++)printf("%d ", list[i]);

printf("\n");return 0;

}

0 1 2 3 4 5 6 7 8 9

내부 for 루프로서 (i+1)번째 원소부터 배열의 마지막 원소 중에서 최소값을 찾는다. 현재의 최소값과 비교하여 더 작은 정수가 발견되면 그 정수가들어 있는인덱스를 least에저장한다.

list[i]와 list[least]를 서로 교환



변수의값을서로교환할때

다음과 같이 하면 안됨 grade[i] = grade[least]; // grade[i]의 기존값은 파괴된다! grade[least] = grade[i];

올바른 방법 temp = list[i]; list[i] = list[least]; list[least] = temp;



Quick Sorting

Divide and Conquer Quicksort is a divide and conquer algorithm. Quicksort first

divides a large list into two smaller sub-lists: the low elements and the high elements. Quicksort can then recursively sort the sub-lists.

Steps in Quick Sort Pick an element, called a pivot, from the list. Reorder the list so that all elements with values less than the

pivot come before the pivot, while all elements with values greater than the pivot come after it (equal values can go either way). After this partitioning, the pivot is in its final position. This is called the partition operation.

Recursively sort the sub-list of lesser elements and the sub-list of greater elements.



In-place version of QuickSorting// left is the index of the leftmost element of the array// right is the index of the rightmost element of the array// (inclusive) number of elements in subarray: right-left+1

int partition(array[], left, right, pivotIndex){

pivotValue = array[pivotIndex];swap array[pivotIndex] and array[right] // Move pivot to endstoreIndex = left;for (i = left; i<= right – 1; i++) // left ≤ i < right{

if (array[i] ≤ pivotValue) {swap array[i] and array[storeIndex];storeIndex = storeIndex + 1;

}}swap array[storeIndex] and array[right];// Move pivot to its final placereturn storeIndex;

}



function quicksort(array, left, right){

if (left >= right)return;

else if (left < right) // subarray of 0 or 1 elements already sortedselect a pI (pivotIndex) in the range left ≤ pI ≤ right// e.g.) (left + right)/2

newPI = partition(array, left, right, pI);// element at newPivotIndex (newPI) is now at its final position

if (left < (newPI-1))quicksort(array, left, newPI - 1);

// recursively sort elements on the left of pivotNewIndexif ((newPI+1) < right)

quicksort(array, newPI + 1, right);// recursively sort elements on the right of pivotNewIndex

}



Quick Sort Algorithm (1)

Level 0

In partition function pi (pivot index ) = 6 pivotValue(pV) = 6 Swap a[pi=6], a[right=12] si (storeIndex) = 0

13 7 5 8 12 10 6 9 2 4 11 1 3

13 7 5 8 12 10 6 9 2 4 11 1 3

13 7 5 8 12 10 69 2 4 11 13

right (=12)left (=0) pi(pivotIndex) =6

3




Level 0 (pV = 6)

If (a[i] <= pV) {swap a[i] and a[si];si += 1;

}

13 7 5 8 12 10 69 2 4 11 13

13 7 5 8 12 10 69 2 4 11 13

right (=12)left (=0)

si (=0) i (=0)

i (=2)i (=1)si (=0)




Level 0

5 3 13 8 12 10 69 2 4 11 17

5 7 13 8 12 10 69 2 4 11 13

5 3 2 8 12 10 69 13 4 11 17

si (=1) i (=6)

i (=8)si (=2)

si (=3) i (=9)

i (=2) i (=3)i (=4) i (=5)

i (=7)




Level 0 sI = 4, i = 9

si = 5, i = 11, swap(a[5], a[right])

return storeIndex (si = 5)

5 3 2 4 12 10 69 13 8 11 17

5 3 2 4 1 10 69 13 8 11 127

5 3 2 4 1 6 109 13 8 11 127



Overall Process (1)

0 1 2 3 4 5 6 7 8 9 10 11 12

13 7 5 8 12 10 6 9 2 4 11 1 3QS(A[], 0, 12)pI = (0+12)/2 = 6

partition(A[], 0, 12, 6)newPI = 5

0 1 2 3 4 5 6 7 8 9 10 11 12

5 3 2 4 1 6 7 9 13 8 11 12 10

QS(A[], 0, 4)pI = (0+4)/2 = 2

0 1 2 3 4 5 6 7 8 9 10 11 12

5 3 2 4 1 6 7 9 13 8 11 12 10


0 1 2 3 4 5 6 7 8 9 10 11 12

1 2 5 4 3 6 7 9 13 8 11 12 10

QS(A[], 2, 4)pI = (2+4)/2 = 3

0 1 2 3 4 5 6 7 8 9 10 11 12

1 2 5 4 3 6 7 9 13 8 11 12 10


0 1 2 3 4 5 6 7 8 9 10 11 12

1 2 3 4 5 6 7 9 13 8 11 12 10



Overall Process (2)

QS(A[], 6, 12)pI = (6+12)/2 = 9

0 1 2 3 4 5 6 7 8 9 10 11 12

1 2 3 4 5 6 7 9 13 8 11 12 10


0 1 2 3 4 5 6 7 8 9 10 11 12

1 2 3 4 5 6 7 8 13 10 11 12 9

QS(A[], 8, 12)pI = (8+12)/2=10

0 1 2 3 4 5 6 7 8 9 10 11 12

1 2 3 4 5 6 7 8 13 10 11 12 9


0 1 2 3 4 5 6 7 8 9 10 11 12

1 2 3 4 5 6 7 8 10 9 11 12 13

0 1 2 3 4 5 6 7 8 9 10 11 12

1 2 3 4 5 6 7 8 10 9 11 12 13QS(A[], 8, 9)pI = (8+9)/2 = 8


0 1 2 3 4 5 6 7 8 9 10 11 12

1 2 3 4 5 6 7 8 9 10 11 12 13



Overall Process (3)

0 1 2 3 4 5 6 7 8 9 10 11 12

1 2 3 4 5 6 7 8 9 10 11 12 13


0 1 2 3 4 5 6 7 8 9 10 11 12

1 2 3 4 5 6 7 8 9 10 11 12 13

QS(A[], 11, 12)pI = (11+12)/2 = 11



Comparisons of Sorting Algorithms

Selection sorting comparisons to find the maximum or minimum element at each

inner loop only 1 swap in each inner loop no more memory requirements

Quick sorting divide and conquer comparisons and swapping at each stage the number of elements for each stage is divided, recursively over head in function call: more memory requirements



순차탐색 (Sequential Search)

순차탐색은배열의원소를순서대로하나씩꺼내서탐색키와비교하여원하는값을찾아가는방법

10 20 30 40 50 10

50

비교

성공

grade[0] grade[1] grade[2] grade[3] grade[4] grade[5]



순차탐색#include <stdio.h>

#define SIZE 10

int main(void)

{

int key, i;

int list[SIZE] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

printf("탐색할 값을입력하시오:");

scanf("%d", &key);

for(i = 0; i < SIZE; i++)

if(list[i] == key)

printf("탐색성공 인덱스= %d\n", i);

printf("탐색종료\n");

return 0;

}

탐색할 값을 입력하시탐색 성공 인덱스 =

탐색 종료

for 루프를 이용하여 list[i]와 key를 비교하는연산을 배열의 크기만큼 반복한다. 만약 list[i]와 key가 같으면 탐색은 성공되고 키값이 발견된 배열의 인덱스를 출력한다.



이진탐색 (binary search)

이진탐색(binary search): 정렬된배열의중앙에위치한원소와비교되풀이



이진탐색#include <stdio.h>#define SIZE 16int binary_search(int list[], int n, int key);

int main(void){

int key;int grade[SIZE] = { 2,6,11,13,18,20,22,27,29,30,34,38,41,42,45,47 };printf("탐색할 값을 입력하시오:");scanf("%d", &key);printf("탐색 결과= %d₩n", binary_search(grade, SIZE, key));

return 0;}



이진탐색int binary_search(int list[], int n, int key){

int low, high, middle;low = 0;high = n-1;while( low <= high ){ // 아직 숫자들이남아있으면

printf("[%d %d]\n", low, high);// 하한과 상한을출력한다. middle = (low + high)/2; // 중간 위치를계산한다. if( key == list[middle] ) // 일치하면탐색 성공

return middle;else if( key > list[middle] )// 중간 원소보다크다면

low = middle + 1; // 새로운 값으로 low 설정else

high = middle - 1; // 새로운 값으로 high 설정} return -1;

}



실행결과

탐색할 값을 입력하시오:34[0 15][8 15][8 10][10 10]탐색 결과= 10



순차탐색과이진탐색의비교

N개의원소를가진배열에서지정된값을탐색하기위한비교 (comparison) 회수 순차 탐색 최소: 1 (첫 번째 원소가 탐색 대상일 경우) 최대: N (마지막 원소가 탐색 대상일 경우) 평균: N/2

이진 탐색 최소: 1 (첫 번째 pivot 위치의 원소가 탐색 대상일 경우) 최대: log2N (마지막 레벨의 pivot 원소가 탐색 대상일 경우)

예: 1000개의원소를가진배열에서지정된값탐색 순차탐색: 평균 500회 비교 이진탐색: 최대 10회 비교



2차원배열int s[10]; // 1차원배열int s[3][10]; // 2차원배열int s[5][3][10]; // 3차원배열



2차원배열의구현

2차원배열은 1차원적으로구현된다.



2차원배열의활용#include <stdio.h>

int main(void){

int s[3][5]; // 2차원배열 선언int i, j; // 2개의인덱스 변수int value = 0; // 배열원소에 저장되는값

for(i=0;i<3;i++)for(j=0;j<5;j++)

s[i][j] = value++;

for(i=0;i<3;i++)for(j=0;j<5;j++)

printf("%d\n", s[i][j]);

return 0; }

0123...11121314



2차원배열의초기화int s[3][5] = { { 0, 1, 2, 3, 4 }, // 첫번째행의원소들의초기값{ 10, 11, 12, 13, 14 }, // 두번째행의원소들의초기값{ 20, 21, 22, 23, 24 } // 세번째행의원소들의초기값

};



2차원배열의초기화int s[ ][5] = { { 0, 1, 2, 3, 4 }, // 첫번째행의원소들의초기값{ 10, 11, 12, 13, 14 }, // 두번째행의원소들의초기값{ 20, 21, 22, 23, 24 }, // 세번째행의원소들의초기값

};



2차원배열의초기화int s[ ][5] = { { 0, 1, 2 }, // 첫번째행의원소들의초기값{ 10, 11, 12 }, // 두번째행의원소들의초기값{ 20, 21, 22 } // 세번째행의원소들의초기값

};



2차원배열의초기화int s[ ][5] = { 0, 1, 2, 3, 4, // 첫번째행의원소들의초기값5, 6, 7, 8, 9, // 두번째행의원소들의초기값

};



3차원배열

#include <stdio.h>int main(void){

int s[3][3][3]; // 3차원배열선언int x, y, z; // 3개의인덱스변수int i = 1; // 배열원소에저장되는값

for(z=0;z<3;z++)for(y=0;y<3;y++)

for(x=0;x<3;x++)s[z][y][x] = i++;

return 0; }



다차원배열인수#include <stdio.h>#define YEARS 3#define PRODUCTS 5

int sum(int grade[][PRODUCTS]);

int main(void){

int sales[YEARS][PRODUCTS] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }; int total_sale; total_sale = sum(sales);

printf("총매출은 %d입니다.\n", total_sale); return 0;

} int sum(int grade[][PRODUCTS]){

int y, p; int total = 0; for(y = 0; y < YEARS; y++)

for(p = 0; p < PRODUCTS; p++) total += grade[y][p];

return total; }

첫번째 인덱스의 크기는적지 않아도 된다.

총매출은 45입니다.



다차원배열예제#include <stdio.h>#define CLASSES 3#define STUDENTS 5

int main(void){

int s[CLASSES][STUDENTS] = { { 0, 1, 2, 3, 4 }, // 첫번째 행의 원소들의 초기값{ 10, 11, 12, 13, 14 }, // 두번째 행의 원소들의 초기값{ 20, 21, 22, 23, 24 }, // 세번째 행의 원소들의 초기값

}; int clas, student, total, subtotal; total = 0; for(clas = 0; clas < CLASSES; clas++) {

subtotal = 0; for(student = 0; student < STUDENTS; student++)

subtotal += s[clas][student]; printf("학급 %d의 평균 성적= %d\n", clas, subtotal / STUDENTS); total += subtotal;

} printf("전체 학생들의 평균 성적= %d\n", total/(CLASSES * STUDENTS)); return 0;

}

학급 0의 평균 성적 = 2 학급 1의 평균 성적 = 12 학급 2의 평균 성적 = 22 전체 학생들의 평균 성적 = 12



행렬 (Matrix)

행렬(matrix)는 자연과학에서 많은문제를 해결하는데사용



2차원배열을이용한행렬의표현#include <stdio.h>#define ROWS 3#define COLS 3

int main(void){

int A[ROWS][COLS] = { { 2,3,0 }, { 8,9,1 }, { 7,0,5 } };

int B[ROWS][COLS] = { { 1,0,0 }, { 1,0,0 }, { 1,0,0 } };

int C[ROWS][COLS]; int r,c; // 두개의 행렬을 더한다.for(r = 0;r < ROWS; r++)

for(c = 0;c < COLS; c++) C[r][c] = A[r][c] + B[r][c];

// 행렬을 출력한다.for(r = 0;r < ROWS; r++) {

for(c = 0;c < COLS; c++) printf("%d ", C[r][c]);

printf("\n"); } return 0;

}

3 3 0 9 9 1 8 0 5

중첩 for 루프를 이용하여 행렬 A의 각원소들과 행렬의 B의 각 원소들을 서로 더하여 행렬 C에 대입한다.



4x4 행렬의초기화 (1)/*** matrix4_4.cpp* programmed by Young-Tak Kim (August 10, 2011)**/

#include <iostream>#include <iomanip>using namespace std;

#define SIZE_4 4

void printMtrx(int mA[][SIZE_4], int size_n);void addMtrx(int mA[][SIZE_4], int mB[][SIZE_4], int mX[][SIZE_4],int size_n);void subtractMtrx(int mA[][SIZE_4], int mB[][SIZE_4], int mX[][SIZE_4], int size_n);void multiplyMtrx(int mA[][SIZE_4], int mB[][SIZE_4], int mX[][SIZE_4], int size_n);

int main(){

int mA[4][4] = {{1, 2, 3, 4},{5, 6, 7, 8},{9, 10, 11, 12},{13, 14, 15, 16}};

int mB[4][4] = {{1, 0, 0, 0},{0, 2, 0, 0},{0, 0, 3, 0},{0, 0, 0, 4}};

int mC[4][4];int mD[4][4];int mE[4][4];



4x4 행렬의초기화 (2)/** matrix4_4.cpp (cont.) */

printf("₩n Matrix mA:₩n");printMtrx(mA, 4);

printf("₩n Matrix mB:₩n");printMtrx(mB, 4);

addMtrx(mA, mB, mC, 4);printf("₩n Matrix mC = mA + mB:₩n");printMtrx(mC, 4);

subtractMtrx(mA, mB, mD, 4);printf("₩n Matrix mD = mA - mB:₩n");printMtrx(mD, 4);

multiplyMtrx(mA, mB, mE, 4);printf("₩n Matrix mE = mA x mB:₩n");printMtrx(mE, 4);

printf("₩n");

return 0;

}



확장완성형코드를사용한 4x4 행렬의출력void printMtrx(int mA[][SIZE_4], int size_n){

unsigned char a6 = 0xA6, a1 = 0xA1, a2 = 0xA2;unsigned char a3 = 0xA3, a4 = 0xA4, a5 = 0xA5;

for (int i=0; i< size_n; i++) {for (int j=0; j< size_n; j++) {

if ((i==0) && (j==0))printf("%c%c%3d", a6, a3, mA[i][j]);

else if ((i==0) && j==(size_n -1))printf("%3d%c%c", mA[i][j], a6, a4);

else if ((i>0) && (i<size_n-1) && (j==0))printf("%c%c%3d", a6, a2, mA[i][j]);

else if ((i>0) && (i<size_n-1) && (j== (size_n -1)))printf("%3d%c%c", mA[i][j], a6, a2);

else if ((i==(size_n-1)) && (j==0))printf("%c%c%3d", a6, a6, mA[i][j]);

else if ((i==(size_n-1)) && (j==(size_n -1)))printf("%3d%c%c", mA[i][j], a6, a5);

elseprintf("%3d", mA[i][j]);

}printf("₩n");

}}



4x4 행렬의덧셈, 뺄셈, 곱셈

void addMtrx(int mA[][SIZE_4], int mB[][SIZE_4], int mX[][SIZE_4], int size_n){

for (int i=0; i<size_n; i++)for (int j=0; j<size_n; j++)

mX[i][j] = mA[i][j] + mB[i][j];}

void subtractMtrx(int mA[][SIZE_4], int mB[][SIZE_4], int mX[][SIZE_4], int size_n){

for (int i=0; i<size_n; i++)for (int j=0; j<size_n; j++)

mX[i][j] = mA[i][j] - mB[i][j];}

void multiplyMtrx(int mA[][SIZE_4], int mB[][SIZE_4], int mX[][SIZE_4], int size_n){

for (int i=0; i<size_n; i++)for (int j=0; j<size_n; j++){

mX[i][j] = 0;for (int k=0; k<size_n; k++)

mX[i][j] += mA[i][k] * mB[k][j];}

}



실행결과



Homework 6

6.1 5 x 5 Matrix 계산프로그램(1)입력 데이터가 포함된 입력 파일 (exam1_input.txt)과 출력 결과를 저장할 출력 데

이터 파일(exam1_output.txt)을 fopen()을 사용하여 open 또는 생성하라. 입력 데이터 파일에는 2개의 5 x 5 행렬을 위한 총 50개의 정수형 데이터가 포함되어 있도록 구성할 것.

(2) 2개의 5 x 5 행렬을 저장할 수 있는 2차원 배열 (mA[SIZE][ SIZE] 및 mB[SIZE][ SIZE])을 준비하고, 입력 데이터 파일 (exam1_input.txt)로부터 fscanf() 함수를 사용하여, 각 25개씩의 정수 데이터를 읽어 2차원 배열을 초기화하는 프로그램initMtrx(int M[][SIZE], int size)을 작성할 것.

(3) 입력된 2개의 행렬의 값을 화면에 출력하기 위한 printMtrx(int M[][SIZE], int size) 함수와 출력 데이터 파일 (exam1_output.txt)에 출력하기 위한 fprintMtrx(FILE* fout, int M[][SIZE], int size)함수를 각각 작성할 것. 행렬의 각 값은 최소 5자리를확보하고, 오른쪽 정렬로 출력되도록 할 것. 이 때, 행렬을 표시하기 위하여, 확장완성형 코드를 사용할 것.

출력결과

확장 완성형코드

사용 방법

─ 0xa6, 0xa1 printf(“ %c%c”, 0xa6, 0xa1)

│ 0xa6, 0xa2 printf(“ %c%c”, 0xa6, 0xa2)

┌ 0xa6, 0xa3 printf(“ %c%c”, 0xa6, 0xa3)

┐ 0xa6, 0xa4 printf(“ %c%c”, 0xa6, 0xa4)

┘ 0xa6, 0xa5 printf(“ %c%c”, 0xa6, 0xa5)

└ 0xa6, 0xa6 printf(“ %c%c”, 0xa6, 0xa6)

ch06 - 배열, 동적배열, 정렬...

Documents