강동영의 일상

[자료구조] 연결리스트 2

rokaf6444 — Sat, 5 Aug 2023 06:30:47 +0900

이번 글에서는 연결리스트를 지난 글에 이어서 배울 겁니다.

지난 글에서 노드를 만든 후 서로 연결해보았습니다.

작은 리스트이면 지난 글과 같이 만들어도 되지만 리스트가 커지면 전용 함수들을 통하여 노드를 추가하는 것이 편리합니다.

단순 연결리스트에서 저희가 작성할 함수들은 다음과 같습니다.

- insert_first() : 리스트의 시작 부분에 항목을 삽입하는 함수입니다.
- insert() : 리스트의 중간 부분에 항목을 삽입하는 함수입니다.
- delete_first() : 리스트의 첫 번째 항목을 삭제하는 함수입니다.
- delete() : 리스트의 중간 항목을 삭제하는 함수입니다.
- print_list() : 리스트를 방문하여 모든 항목을 출력하는 함수입니다.

단순 연결리스트 정의

단순 연결리스트는 원칙적으로 헤드 포인터만 있으면 됩니다.

ListNode *head;

insert_first() : 리스트의 시작 부분에 항목을 삽입하는 함수

아래의 코드에서 매개 변수 head는 헤드 포인터이고 value는 새롭게 추가되는 데이터입니다.

ListNode* insert_first(ListNode* head, int value)
{
	ListNode* p = (ListNode*)malloc(sizeof(ListNode)); // 동적 메모리 할당을 통하여 새로운 노드 p를 생성함
	p->data = value; // p->data에 value를 저장함
	p->link = head; // p->link를 현재 head값으로 변경함
	head = p; // head값을 p값으로 변경함

	return head; // 변경된 헤드 포인터 반환함
}

1. ListNode *p = (ListNode *)malloc(sizeof(ListNode))는 노드를 추가하는 과정에서 먼저 새로운 노드(p)를 동적 메모리 할당을 통해 생성합니다.

2. p->data = value는 새로운 노드 p의 'data' 필드에 매개 변수로 받은 value 값(데이터)를 저장합니다.

3. p->link = head는 새로운 노드 p의 'link' 필드에 현재 head 값(헤드 포인터가 가리키는 노드의 주소 값)을 저장합니다.

이렇게 되면 새로운 노드의 다음 노드가 원래 리스트의 첫 번째 노드가 됩니다.

4. head = p는 헤드 포인터의 값을 p 값(새로운 노드의 주소)으로 변경합니다.

이제 헤드 포인터는 새로 추가된 노드를 가리키게 됩니다.

5. return head는 변경된 헤드 포인터를 반환합니다.

이는 새로운 노드가 리스트의 시작 부분에 추가되었음을 나타냅니다.

코드를 그림으로 보면 다음과 같습니다.

출처 : C언어로 쉽게 풀어쓴 자료구조

insert() : 리스트의 중간 부분에 항목을 삽입하는 함수

이 함수는 연결리스트의 중간에 새로운 노드를 추가합니다.

이때는 반드시 삽입되는 위치의 선행 노드를 알아야 삽입이 가능합니다.

그리고 선행 노드를 pre가 가리키고 있다고 가정합니다.

// 노드 pre 뒤에 새로운 노드 삽입
ListNode* insert(ListNode* head, ListNode* pre, element value)
{
	ListNode* p = (ListNode*)malloc(sizeof(ListNode));
	p->data = value;
	p->link = pre->link;
	pre->link = p;

	return head;
}

1. ListNode *p = (ListNode *)malloc(sizeof(ListNode))는 노드를 추가하는 과정에서 먼저 새로운 노드(p)를 동적 메모리 할당을 통해 생성합니다.

2. p->data = value는 새로운 노드 p의 'data' 필드에 매개 변수로 받은 value 값(데이터)를 저장합니다.

3. p->link = pre->link는 새로운 노드 p의 'link' 필드에 선행 노드 pre의 'link'필드 값을 저장합니다.

이건 새로운 노드가 선행 노드의 다음 노드를 가리킬 수 있게 합니다.

4. pre->link = p는 선행 노드 pre의 'link' 필드 값을 새로운 노드 p의 주소로 변경합니다.

이로써 선행 노드(pre)와 새로운 노드(p) 사이에 연결이 생성됩니다.

5. return head는 헤드 포인터를 반환합니다.

이는 중간 부분에 노드가 추가되었음을 나타냅니다.

출처 : C언어로 쉽게 풀어쓴 자료구조

delete_first() : 리스트의 첫 번째 항목을 삭제하는 함수

ListNode* delete_first(ListNode* head)
{
	ListNode* removed;
	if (head == NULL) return NULL;
	removed = head;
	head = removed->link;
	free(removed);

	return head;
}

1. ListNode *removed는 삭제할 노드를 가리킬 포인터를 선언합니다.

2. if (head == NULL) return NULL는 리스트가 비어 있으면(NULL 인 경우) NULL을 반환하여 함수를 종료합니다.

3. removed = head는 삭제할 노드로 헤드 포인터(head)가 가리키는 노드를 지정합니다(첫 번째 노드).

4. head = removed->link는 헤드 포인터를 두 번째 노드로 옮깁니다.

이렇게 되면 기존의 첫 번째 노드는 리스트에서 끊어집니다.

5. free(removed)는 removed가 가리키는 노드(첫 번째 노드)를 메모리에서 해제하여 더 이상 사용되지 않게 합니다.

6. return head는 변경된 헤드 포인터를 반환합니다. 이렇게 리스트의 첫 번째 노드가 삭제되었음을 나타냅니다.

출처 : C언어로 쉽게 풀어쓴 자료구조

delete() : 리스트의 중간 항목을 삭제하는 함수

// pre가 가리키는 노드의 다음 노드를 삭제한다. 
ListNode* delete(ListNode* head, ListNode* pre)
{
	ListNode* removed;
	removed = pre->link;
	pre->link = removed->link;
	free(removed);

	return head;
}

1. ListNode* removed는 삭제할 노드를 가리킬 포인터를 선언합니다.

2. removed = pre->link는 삭제할 노드로 pre(선행 노드)의 다음 노드를 지정합니다.

3. pre->link = removed->link는 선행 노드(pre)의 'link' 필드 값을 삭제할 노드(removed)의 다음 노드로 변경합니다.

이렇게 되면 삭제할 노드는 리스트에서 끊어집니다.

4. free(removed)는 removed가 가리키는 노드(삭제할 노드)를 메모리에서 해제하여 더 이상 사용되지 않게 합니다.

5. return head는 헤드 포인터를 반환합니다.

이렇게 리스트의 중간 노드가 삭제되었음을 나타냅니다.

출처 : C언어로 쉽게 풀어쓴 자료구조

print_list() : 리스트를 방문하여 모든 항목을 출력하는 함수

void print_list(ListNode *head)
{
	for (ListNode *p = head; p != NULL; p = p->link)
		printf("%d->", p->data);
	printf("NULL \n");
}

1. for (ListNode *p = head; p != NULL; p = p->link)는 연결 리스트를 순회하기 위한 for 반복문입니다.

초기화 부분에서 포인터 변수 p에 head 값을 할당하여 첫 번째 노드부터 시작합니다.

조건 부분에서 p가 NULL이 아닌동안 반복문을 수행합니다.

NULL이 되면 리스트의 끝에 도달했다는 것을 의미합니다.

갱신 부분에서 p에 p->link를 할당해 다음 노드로 이동합니다.

2. printf("%d->", p->data)은 현재 노드(p)의 데이터를 출력합니다.

출력 형식은 데이터 값 뒤에 '->'가 붙는 형태입니다.

3. printf("NULL \n")는 리스트의 끝에 도달했음을 나타내기 위해 "NULL"을 출력하고 줄 바꿈을 합니다.

마지막으로 테스트 프로그램을 한번 살펴보겠습니다.

// 테스트 프로그램
int main(void)
{
	ListNode* head = NULL;

	for (int i = 0; i < 3; i++) {
		head = insert_first(head, i);
		print_list(head);
	}
	for (int i = 0; i < 3; i++) {
		head = delete_first(head);
		print_list(head);
	}
	return 0;
}

1. 이중연결리스트의 머리(head)를 NULL로 초기화합니다.

이는 빈 이중연결리스트를 나타냅니다.

2. 세 번의 반복문을 수행하며, 이중연결리스트의 처음에 0부터 2까지의 정수를 삽입합니다.

삽입할 때마다 insert_first 함수를 호출하고, 리스트의 현재 상태를 print_list 함수를 사용하여 출력합니다.

3. 다음 세 번의 반복문에서 이중연결리스트에서 첫째 항목을 제거합니다.

제거할 때마다 delete_first 함수를 호출하고, 리스트의 현재 상태를 print_list 함수를 사용하여 출력합니다.

4. 프로그램이 성공적으로 종료되면 0을 반환합니다.

위의 코드를 실행한 결과

[자료구조] 연결리스트 1

rokaf6444 — Sat, 5 Aug 2023 06:30:32 +0900

이번 글에서는 연결리스트에 대해서 배워보도록 하겠습니다.

출처 : Share and Discover Knowledge on SlideShare

연결리스트를 설명하기 전에 용어부터 살펴보겠습니다.

리스트란?

A, B, C, ... 처럼 순서를 가진 항목들의 모임입니다.

항목이란?

데이터 필드를 말합니다.

즉, 리스트의 원소들을 저장하는 곳입니다.

리스트는 대표적인 선형 자료구조로 노드들이 일렬로 연결된 구조입니다.

연결리스트에서는 리스트의 항목들을 노드라는 곳에 저장합니다.

노드란?

항목(데이터)과 링크의 쌍으로 표현합니다.

링크란?

다음 노드에 대한 주소입니다.

다음 노드가 있는 곳의 주소를 포인터로 표현합니다.

그렇기에 노드들은 데이터와 다른 노드에 대한 포인터를 가집니다.

이렇게 만들어진 연결리스트는 아래의 조건에 따라서 유형이 나뉠 수 있습니다.

링크의 갯수에 따라서

단일 연결리스트와 이중 연결리스트 등으로 나타낼 수 있습니다.

출처 : Wikipedia

단일 연결 리스트는 각 노드에 자료 공간과 한 개의 포인터 공간이 있고,

각 노드의 포인터는 다음 노드를 가리킵니다.

출처 : Wikipedia

이중 연결 리스트의 구조는 단일 연결 리스트와 비슷하지만,

포인터 공간이 두 개가 있고 각각의 포인터는 앞의 노드와 뒤의 노드를 가리킵니다.

링크가 순환하는 구조인가에 따라

선형 연결리스트와 원형 연결리스트 등으로 나눌 수 있습니다.

선형 연결리스트는 단일 연결리스트, 이중 연결리스트와 같은 선형 구조인 연결리스트를 말합니다.

출처 : Wikipedia

원형 연결 리스트는 일반적인 연결 리스트에 마지막 노드와 처음 노드를 연결시켜 원형으로 만든 구조입니다.

출처 : Share and Discover Knowledge on SlideShare

배열을 이용한 구현에는 인덱스를 이용하여 접근합니다.

배열은 크기가 고정되어 있어서 원소의 갯수를 모를 때 메모리 낭비가 발생할 수 있습니다.

때에 따라서 메모리가 모자라는 경우도 생깁니다.

연결리스트를 이용한 구현에서는 위의 사진과 같이 20 -> 30 -> 40 뒤에 노드들을 이어서 동적으로 연결할 수 있습니다.

연결리스트와 배열을 비교해 보겠습니다.

연결리스트	배열
가변적인 크기로 메모리 낭비가 적음	고정된 크기의 데이터를 저장할 때 적합함 그렇지 않을 경우 메모리 낭비가 많을 수 있음
삽입과 삭제가 효율적임	삽입과 삭제시에 데이터의 이동이 발생함
임의의 위치에 대한 접근이 안 됨 - 순차적인 탐색만 가능함	임의의 위치에 인덱스를 통한 접근이 쉬움
순차적으로 데이터에 접근할 경우 느림	순차적인 접근시 매우 빠름 (순차적인 메모리 공간이 할당되기 때문임)

연결리스트는 크기가 제한되지 않고,

중간에서 쉽게 삽입하거나 삭제할 수 있는 유연한 리스트를 구현할 수 있습니다.

하지만 구현이 복잡하고,

임의의 항목(i번째 항목)을 추출하려고 할 때는 배열을 사용하는 방법보다 시간이 오래 걸립니다.

즉, 리스트는 배열로 구현할 수 있으나,

삽입과 삭제가 자주 일어날 경우에 연결리스트를 사용하는 것이 효율적이라는 것입니다.

항목과 링크를 가진 노드의 C 표현

typedef int item // typedef로 항목을 추상화
typedef struct ListNode {
	item data;
	struct ListNode* link; // ListNode 구조체를 가리키는 포인터 변수
} ListNode;

위의 코드에서 item은 항목을 저장할 수 있게 해줍니다.

link는 ListNode 구조체를 가리키는 포인터 변수입니다.

우리는 구조체 변수를 포인터를 통해서 접근해야 합니다.

ListNode node = { 10, NULL }; // 이 구조체가 있을 때,

ListNode *list = &node; // 구조체를 가리키는 포인터 변수 list가 node의 주소값을 가지고 있습니다.

즉, node를 참조하고 있다는 것입니다.

data에 접근하는 방법은 두 가지가 있습니다.

1. (*list).data

list라고 하는 포인터 변수가 참조하고 있는 구조체(노드)의 원소에 접근해야 합니다.

그렇기에 도트 연산자(.)을 사용합니다.

2. list->data

포인터 변수 list를 통해 구조체 변수 내부의 멤버에 접근하는 표현입니다.

그렇기에 화살표 연산자(->)를 사용합니다.

아래는 data에 접근하는 두 가지 방법을 보여주기 위한 예시 코드입니다.

#include <stdio.h>

typedef int item;
typedef struct ListNode {
	item data;
	struct ListNode* link;
} ListNode;

int main() {
	ListNode node = { 10, NULL };
	ListNode* list = &node;

	printf("node.data = %d\n", node.data); // 노드 객체의 데이터
	printf("(*list).data = %d\n", (*list).data); // list라는 포인터 변수가 참고하는 객체의 데이터
	printf("list->data = %d\n", list->data);

	return 0;
}

위의 코드를 실행한 결과

아래의 코드는 다른 예시입니다.

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

typedef int item;
typedef struct ListNode {
	item data;
	struct ListNode* link;
} ListNode;

int main() {
	ListNode* p1;
	ListNode* p2;

	p1 = (ListNode*)malloc(sizeof(ListNode));
	p1->data = 10;

	p2 = (ListNode*)malloc(sizeof(ListNode));
	p2->data = 20;
	p2->link = NULL;
	p1->link = p2;

	printf("p1->data = %d\n", p1->data);
	printf("p1->link->data = %d\n", p1->link->data);
	printf("p2->data = %d\n", p2->data);

	return 0;
}

p1은 ListNode 객체를 가리키는 포인터 변수입니다.

malloc을 이용해서 동적으로 ListNode 객체를 만들었습니다.

객체가 생성된 후, 구조체의 데이터에 접근한 후 10을 넣었습니다.

p2도 같은 방법으로 동적 메모리를 만들고 동적 메모리의 데이터 필드에 20을 넣었습니다.

그리고 p2의 link에는 NULL을 넣었습니다.

값이 할당되지 않던 p1의 link에 p2를 넣었습니다.

p1과 p2는 모두 포인터 변수입니다.

그렇기에 p1의 link와 p2는 같은 메모리 영역을 가리키게 됩니다.

이러한 과정을 통해서 두 노드 간에 연결이 형성되었습니다.

그래서 p1->link의 값과 p2의 값은 같습니다.

따라서 아래와 같은 실행 결과가 나옵니다.

위의 코드 실행한 결과

[자료구조] 이진탐색트리의 탐색, 삽입, 삭제

rokaf6444 — Tue, 25 Jul 2023 06:00:13 +0900

이번 글에서는 이진탐색트리의 탐색, 삽입, 삭제, 출력을 살펴보겠습니다.

이진트리에서 원하는 값을 찾으려면 루트부터 시작해 현재 선택한 노드의 키 값과 목표하는 값을 비교하면서 왼쪽, 오른쪽으로 검색을 진행하면 됩니다.

출처 : 생능 출판사

알고리즘은 다음과 같습니다.

1. 루트부터 선택하여 검색을 진행합니다.

여기서 선택하는 노드를 p라고 합니다.

2. p가 널이면 검색에 실패합니다.

3. 검색하는 값 key와 선택한 노드 p의 키 값을 비교하여

1) 값이 같으면 검색에 성공(검색 종료)합니다.

2) key가 작으면 선택한 노드에 왼쪽 자식 노드를 대입합니다(왼쪽으로 검색 진행).

3) key가 크면 선택한 노드에 오른쪽 자식 노드를 대입합니다(오른쪽으로 검색 진행).

4. 2번 과정으로 되돌아갑니다.

아래의 코드는 이 알고리즘을 바탕으로 이진탐색트리에서 노드를 검색하는 과정을 보여줍니다.

// 순환적인 탐색 함수
TreeNode* search(TreeNode* node, int  key)
{
	if (node == NULL) return NULL;
	if (key == node->key) return node;
	else if (key < node->key)
		return  search(node->left, key);
	else
		return  search(node->right, key);
}

// 반복적인 탐색 함수
TreeNode* search(TreeNode* node, int key)
{
	while (node != NULL) {
		if (key == node->key) return node;
		else if (key < node->key)
			node = node->left;
		else
			node = node->right;
	}
	return NULL; // 탐색에 실패했을 경우 NULL 반환
}

p를 루트로 하는 이진탐색트리에 데이터를 삽입하는 알고리즘은 다음과 같습니다.

출처 : 생능 출판사

p가 널인 경우

처음에 insert_node 함수를 호출할 때 널이면 루트 노드가 없다는 뜻입니다(이진탐색트리가 비어 있음).

따라서 루트 노드를 만들고 값을 설정합니다.

그러면 루트만 있는 이진탐색트리가 만들어집니다.

함수를 처음 호출하는 상태가 아니라면(재귀 호출 시에 p의 값이 널이면) 노드를 삽입할 위치를 제대로 찾은 것입니다.

삽입할 노드를 만들고 값을 설정하면 삽입 과정이 끝납니다.

p가 널인 아닌 경우는 세 가지 방법으로 처리합니다.

1. 선택한 노드의 키 값과 삽입할 키 값이 같은 경우

값을 삽입할 수 없습니다. 삽입할 수 없다는 내용을 출력합니다.

2. 삽입할 키 값이 선택한 노드의 키 값보다 작은 경우

선택한 노드에 왼쪽 자식 노드를 대입합니다.

3. 삽입할 키 값이 선택한 노드의 키 값보다 큰 경우

선택한 노드에 오른쪽 자식 노드를 대입합니다.

아래의 코드는 이 알고리즘을 바탕의 의사코드입니다.

insert(root, n) :

	if KEY(n) == KEY(root) // root와 키가 같으면
		then return; // return
	else if KEY(n) < KEY(root) then // root보다 키가 작으면
		if LEFT(root) == NULL // root의 왼쪽 자식이
			then LEFT(root) ← n; // 없으면 n이 왼쪽 자식
		else insert(LEFT(root), n); // 있으면 순환 호출
	else // root보다 키가 크면
		if RIGHT(root) == NULL
			then RIGHT(root) ← n;
		else insert(RIGHT(root), n);

아래의 코드는 위의 의사코드를 바탕으로 노드를 삽입하는 과정을 보여줍니다.

TreeNode* insert_node(TreeNode* node, int key)
{
	// 트리가 공백이면 새로운 노드를 반환
	if (node == NULL) return new_node(key);

	// 그렇지 않으면 순환적으로 트리를 내려감
	if (key < node->key)
		node->left = insert_node(node->left, key);
	else if (key > node->key)
		node->right = insert_node(node->right, key);

	// 변경된 루트 포인터를 반환
	return node;
}

TreeNode* new_node(int item)
{
	TreeNode* temp = (TreeNode*)malloc(sizeof(TreeNode));
	temp->key = item;
	temp->left = temp->right = NULL;

	return temp;
}

노드를 삭제하는 함수

노드를 삭제하는 과정은 삽입하는 과정보다 복잡합니다.

노드를 삭제할 때는 '세 가지 서로 다른 상황'에 놓이기 때문입니다.

따라서 각각의 상황에 맞게 알맞은 처리를 해야 합니다.

1. 자식 노드가 없는 노드를 삭제하는 경우

출처 : 생능 출판사

위의 크림은 자식 노드가 없는 노드 30을 삭제하는 경우입니다.

이런 경우에는 노드 30을 가리키는 부모 노드 26의 오른쪽 포인터를 널로 업데이트하면 됩니다.

이렇게 하면 노드 30은 아무것도 가리키지 않기 때문에 이진탐색트리에서 삭제됩니다.

이 과정을 간단히 정리하면 다음과 같습니다.

1) 삭제할 노드가 부모 노드의 왼쪽 자식이면 부모의 왼쪽 포인터를 NULL로 합니다.

2) 삭제할 노드가 부모 노드의 오른쪽 자식이면 부모의 오른쪽 포인터를 NULL로 합니다.

이 작업이 끝난 다음에 삭제 대상인 노드 객체의 메모리 영역을 해제하면 됩니다.

만일 이런 순서로 삭제를 진행하지 않고 삭제할 노드의 메모리를 먼저 해제하면 부모는 해제한 메모리의 주소를 가리킵니다.

이렇게 되면 프로그램에 치명적인 오류가 발생할 수 있습니다.

2. 자식 노드가 1개인 포인터를 삭제하는 경우

출처 : 생능 출판사

위의 그림은 자식 노드를 1개만 갖는 노드인 68을 삭제하는 경우입니다.

이런 경우에는 원래 노드 68의 위치로 노드 99를 가져와야 삭제할 수 있습니다.

이런 과정을 거치면 '자식 노드 99를 루트로 하는 서브 트리의 모든 키 값은 부모 노드인 68보다 커야 한다'라는 조건을 유지할 수 있습니다.

삭제 노드의 부모 노드인 35의 오른쪽 포인터가 삭제 대상 노드인 68의 자식 99를 가리키도록 업데이트하면 됩니다.

그러면 68은 아무것도 가리키지 않기 때문에 이진검색트리에서 삭제됩니다.

이 과정을 간단히 정리하면 아래와 같습니다.

1) 삭제 대상 노드가 부모 노드의 왼쪽 자식인 경우

부모의 왼쪽 포인터가 삭제 대상 노드의 자식을 가리키도록 합니다.

2) 삭제 대상 노드가 부모 노드의 오른쪽 자식인 경우

부모의 오른쪽 포인터가 삭제 대상 노드의 자식을 가리키도록 합니다.

3. 자식 노드가 2개인 노드를 삭제하는 경우

출처 : 생능 출판사

자식 노드가 2개인 노드를 삭제하는 과정은 앞의 두 과정보다 더 복잡합니다.

위의 그림은 노드 18을 삭제하는 경우입니다.

노드 18의 오른쪽 서브 트리(노드 26이 루트)의 노드 가운데 키 값이 가장 작은 노드 22를 노드 18이 있는 곳으로 옮겨 삭제해야 합니다.

이 과정을 간단히 정리하면 다음과 같습니다.

1) 삭제할 노드의 오른쪽 서브 트리에서 키 값이 가장 작은 노드를 검색합니다.

2) 검색한 노드를 삭제 위치로 옮깁니다(검색한 노드의 데이터를 삭제 대상 노드 위치로 복사합니다).

3) 옮긴 노드를 삭제합니다.

이때 옮긴 노드에 자식이 없으면 '자식 노드가 없는 노드의 삭제 순서'에 따라 노드를 삭제합니다.

옮긴 노드에 자식이 1개만 있으면 '자식 노드가 1개 있는 노드의 삭제 순서'에 따라 노드를 삭제합니다.

// 이진탐색트리와 키가 주어지면 키가 저장된 노드를 삭제하고
// 새로운 루트 노드를 반환
TreeNode* delete_node(TreeNode* root, int key)
{
	if (root == NULL) return root;

	// 만약 키가 루트보다 작으면 왼쪽 서브 트리에 존재
	if (key < root->key)
		root->left = delete_node(root->left, key);
	// 만약 키가 루트보다 크면 오른쪽 서브 트리에 존재
	else if (key > root->key)
		root->right = delete_node(root->right, key);
        
	// 키가 루트와 같으면 이 노드를 삭제
	else {
		if (root->left == NULL) {
			TreeNode* temp = root->right;
			free(root);
			return temp;
		}
		else if (root->right == NULL) {
			TreeNode* temp = root->left;
			free(root);
			return temp;
		}
		else {
			TreeNode* temp = min_value_node(root->right);

			// 후계 노드를 복사
			root->key = temp->key;
			// 후계 노드를 삭제
			root->right = delete_node(root->right, temp->key);
		}
	}
	return root;
}

TreeNode* min_value_node(TreeNode* node)
{
	TreeNode* current = node;

	// 맨 왼쪽 단말 노드를 찾으러 내려감
	while (current->left != NULL)
		current = current->left;

	return current;
}

[자료구조] 이진트리와 이진탐색트리

rokaf6444 — Tue, 18 Jul 2023 03:00:48 +0900

출처 : 트리(그래프) - 나무위키 (namu.wiki)

이번 글에서는 이진트리와 이진탐색트리를 살펴보겠습니다.

이진트리

노드가 왼쪽 자식과 오른쪽 자식을 갖는 트리를 이진트리(binary tree)라고 합니다.

이때 각 노드의 자식은 2명 이하만 유지해야 합니다.

이진트리의 특징은 왼쪽 자식과 오른쪽 자식을 구분한다는 점입니다.

예를 들어 위의 그림에서 노드 A의 왼쪽 자식은 B, 오른쪽 자식은 C입니다.

이때 왼쪽 자식을 다시 루트로 하는 서브 트리를 왼쪽 서브 트리(left subtree), 오른쪽 자식을 다시 루트로 하는 서브 트리를 오른쪽 서브 트리(right subtree)라고 합니다.

완전이진트리

루트부터 노드가 채워져 있으면서 같은 레벨에서는 왼쪽에서 오른쪽으로 노드가 채워져 있는 이진트리를 완전이진트리(complete binary tree)라고 합니다.

위의 그림을 보면서 '채우다'라는 말의 의미와 함께 좀 더 자세히 살펴보겠습니다.

1. 마지막 레벨을 제외한 레벨은 노드를 가득 채웁니다.

2. 마지막 레벨은 왼쪽부터 오른쪽 방향으로 노드를 채우되 반드시 끝까지 채울 필요는 없습니다.

완전이진트리에서 너비 우선 탐색을 하며 각 노드에 0, 1, 2, ... 값을 주면 배열에 저장하는 인덱스와 일대일로 대응한다는 것을 알 수 있습니다.

높이가 k인 완전이진트리가 가질 수 있는 노드의 최댓값은 2^(k+1) - 1개입니다.

따라서 n개의 노드를 저장할 수 있는 완전이진트리의 높이는 log n입니다.

이진탐색트리

이진탐색트리(binary Search tree)는 이진트리가 다음 조건을 만족하면 됩니다.

1. 어떤 노드 N을 기준으로 왼쪽 서브 트리 노드의 모든 키 값은 노드 N의 키 값보다 작아야 합니다.

2. 오른쪽 서브 트리 노드의 키 값은 노드 N의 키 값보다 커야 합니다.

3. 같은 키 값을 갖는 노드는 없습니다.

이진탐색트리는 중위 순회를 하면 키 값의 오름차순으로 노드를 얻을 수 있다는 점과 구조가 단순하다는 점,

이진탐색과 비슷한 방식으로 검색이 가능하다는 점,

노드의 삽입이 쉽다는 점 등의 특징이 있어 폭넓게 사용됩니다.

[자료구조] 트리

rokaf6444 — Tue, 18 Jul 2023 03:00:29 +0900

출처 : 트리(그래프) - 나무위키 (namu.wiki)

이번 글에서는 데이터 사이의 계층 관계를 나타내는 자료구조인 트리를 살펴보겠습니다.

트리 관련 용어

트리를 구성하는 요소는 노드(node)와 가지(edge)입니다. 각각의 노드는 가지를 통해 다른 노드와 연결되어 있습니다.

루트

트리의 가장 윗부분에 위치하는 노드를 루트(root)라고 합니다.

하나의 트리에는 하나의 루트가 있습니다.

식물의 나무에도 루트가 1개인 것과 같습니다.

트리 구조를 거꾸로 보면 나무 모양과 비슷하다는 것을 알 수 있습니다.

리프

트리의 가장 아랫부분에 위치하는 노드를 리프(leaf)라고 합니다.

이때 '가장 아래에 위치한다'라는 말은 물리적으로 가장 아랫부분에 위치한다는 의미가 아니라 더 이상 뻗어나갈 수 없는 마지막에 노드가 위치한다는 의미입니다.

다른 용어로는 끝 노드(terminal node) 또는 바깥 노드(external node)라고도 합니다.

안쪽 노드

루트를 포함하여 리프를 제외한 노드를 안쪽 노드라고 합니다.

다른 용어로는 끝이 아닌 노드(non-terminal node)라고도 합니다.

자식

어떤 노드로부터 가지로 연결된 아래쪽 노드를 자식(child)이라고 합니다.

노드는 자식을 여러 개 가질 수 있습니다.

예를 들어 B는 두 개, H는 0개의 자식을 가지고 있습니다.

리프는 자식을 가질 수 없습니다.

부모

어떤 노드에서 가지로 연결된 위쪽 노드를 부모(parent)라고 합니다.

노드는 1개의 부모를 가집니다.

예를 들어 D의 부모는 B입니다.

루트는 부모를 가질 수 없습니다.

형제

같은 부모를 가지는 노드를 형제(sibling)라고 합니다.

조상

어떤 노드에서 가지로 연결된 위쪽 노드 모두를 조상(ancestor)이라고 합니다.

자손

어떤 노드에서 가지로 연결된 아래쪽 노드 모두를 자손(descendant)이라고 합니다.

레벨

루트로부터 얼마나 떨어져 있는지에 대한 값을 레벨(level)이라고 합니다.

루트의 레벨은 0이고 루트로부터 가지가 하나씩 아래로 뻗어나갈 때마다 레벨이 1씩 늘어납니다.

차수

노드가 가지는 자식의 수를 차수(degree)라고 합니다.

예를 들어 C의 차수는 2, F의 차수는 0입니다.

모든 노드의 차수가 0 이하인 트리를 n진 트리라고 합니다.

앞의 그림과 같이 모든 노드의 자식 수가 2개 이하인 경우는 특별히 이진트리라고 합니다.

높이

루트부터 가장 멀리 떨어진 리프까지의 거리(리프 레벨의 최댓값)를 높이(height)라고 합니다.

그림의 높이는 3입니다.

서브 트리

트리 안에서 다시 어떤 노드를 루트로 정하고 그 자손으로 이루어진 트리를 서브 트리(subtree)라고 합니다.

널 트리

노드, 가지가 없는 트리를 널 트리(null tree)라고 합니다.

순서 트리와 무순서 트리

형제 노드의 순서가 있는지 없는지에 따라 트리를 두 종류로 분류합니다.

형제 노드의 순서를 따지면 순서 트리(orderde tree), 따지지 않으면 무순서 트리(unordered tree)라고 합니다.

순서 트리 탐색

순서 트리의 노드를 스캔하는 방법은 두 가지입니다. 위의 트리를 예로 들어 살펴보겠습니다.

너비 우선 탐색 - Queue

너비 우선 탐색(breadth-first Search)은 낮은 레벨에서 시작해 왼쪽에서 오른쪽 방향으로 검색하고 한 레벨에서의 검색이 끝나면 다음 레벨로 내려갑니다.

위의 그림에서 검색 순서는 다음과 같습니다.

A -> B -> C -> D -> E -> F -> G -> H -> I

깊이 우선 탐색 - Stack

깊이 우선 탐색(depth-first Search)은 리프까지 내려가면서 검색하는 것을 우선순위로 하는 탐색 방법입니다.

리프에 도달해 더 이상 검색을 진행할 곳이 없는 경우에는 부모에게 돌아갑니다.

그런 다음 다시 자식 노드로 내려갑니다.

두 자식 가운데 한쪽(또는 양쪽)이 없으면 노드를 지나가는 횟수가 줄어들겠지만 노드를 지나가는 최댓값은 3회입니다.

1. D에서 H로 내려가며 D를 지나갑니다.

2. H에서 I로 지나가며 D를 지나갑니다.

3. I에서 D로 되돌아오면서 D를 지나갑니다.

그런데 깊이 우선 탐색을 진행하면서 '언제 노드를 방문할지'는 다음과 같이 세 종류로 구분합니다.

친구의 집도 지나치는 것과 직접 방문하는 것은 다릅니다.

이와 마찬가지로 깊이 우선 탐색도 지나가는 것과 방문하는 것을 구분해서 생각합니다.

전위 순회(Preorder)

전위 순회는 아래와 같은 방법으로 깊이 우선 탐색을 진행합니다.

노드 방문 -> 왼쪽 자식 -> 오른쪽 자식

그림 : A -> B -> D -> H -> I -> E -> C -> F -> G

중위 순회(Inorder)

중위 순회는 아래와 같은 방법으로 깊이 우선 탐색을 진행합니다.

왼쪽 자식 -> 노드 방문 -> 오른쪽 자식

그림 : H -> D -> I -> B -> E -> A -> F -> C -> G

후위 순회(Postorder)

후위 순회는 다음과 같은 방법으로 깊이 우선 탐색을 진행합니다.

왼쪽 자식 -> 오른쪽 자식 -> (돌아와) 노드 방문

그림 : H -> I -> D -> E -> B -> F -> G -> C -> A

[쉽게 풀어쓴 C언어 Express] 9일 차

rokaf6444 — Tue, 3 Jan 2023 02:30:33 +0900

01. 문자열을 받아서 문자열에 포함된 문자를 대문자로 변환하는 함수 str_upper(char *s)를 작성하고 테스트하라.

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>

void str_upper(char *s) {
	for (int i = 0; s[i] != '\0'; i++) { // 문자열이 끝나면 중단
		if (s[i] >= 'a' && s[i] <= 'z') {
			s[i] -= 32; // 대문자와 소문자의 아스키 코드값 차이 : 32
		}
	}
}
int main() {
	char myString[1000];

	printf("문자열을 입력하시오: ");
	scanf("%s", myString); // myString 배열에 입력
	str_upper(myString);
	printf("변환된 문자열: %s\n", myString);

	return 0;
}

문자열을 입력하시오: abcdef
변환된 문자열: ABCDEF

02. 구조체를 이용하여 복소수를 다음과 같이 정의하고 복소수의 덧셈을 수행하는 함수를 작성하고 테스트하라.

struct complex {

double real;

double imag;

};

struct complex complex_add(struct complex c1, struct complex c2){ ⋯ }

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

struct complex {
	double real; // 실수부
	double imag; // 허수부
};
struct complex complex_add(struct complex c1, struct complex c2) {
	struct complex result;

	result.real = c1.real + c2.real; // 실수부의 합
	result.imag = c1.imag + c2.imag; // 허수부의 합

	return result;
}
int main() {
	struct complex c1;
	struct complex c2;
	struct complex c3;

	printf("1번 복소수의 실수부와 허수부를 입력하세요(실수부,허수부) : ");
	scanf("%lf,%lf", &c1.real, &c1.imag);
	printf("2번 복소수의 실수부와 허수부를 입력하세요(실수부,허수부) : ");
	scanf("%lf,%lf", &c2.real, &c2.imag);

	c3 = complex_add(c1, c2);
	printf("%lf+%lfi\n", c3.real, c3.imag);

	return 0;
}

1번 복소수의 실수부와 허수부를 입력하세요(실수부,허수부) : 1,2
2번 복소수의 실수부와 허수부를 입력하세요(실수부,허수부) : 2,3
3.000000+5.000000i

03. equal() 함수를 다음과 같이 구조체의 포인터를 받도록 변경하여서 작성하고 테스트하라.

int equal(struct point *p1, struct point *p2)

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

struct point { // 점의 좌표 표현하는 구조체
	int x, y;
};
int equal(struct point* p1, struct point* p2) { // 두 점이 같은 좌표를 가지는지 판단하는 함수
	if (p1->x == p2->x && p1->y == p2->y) { // 구조체 포인터를 통하여 접근할 때는 p->x1과 같이 접근
		return 1;
	}
	return 0;
}
int main() {
	point p1, p2;

	printf("1번 점의 좌표 입력(x1,y1) : ");
	scanf("%d,%d", &p1.x, &p1.y);
	printf("2번 점의 좌표 입력(x2,y2) : ");
	scanf("%d,%d", &p2.x, &p2.y);

	if (equal(&p1, &p2) == 1)
		printf("(%d, %d) == (%d, %d)\n", p1.x, p1.y, p2.x, p2.y);
	else
		printf("(%d, %d) != (%d, %d)\n", p1.x, p1.y, p2.x, p2.y);

	return 0;
}

1번 점의 좌표 입력(x1,y1) : 1,2
2번 점의 좌표 입력(x2,y2) : 3,5
(1, 2) != (3, 5)

[쉽게 풀어쓴 C언어 Express] 8일 차

rokaf6444 — Mon, 2 Jan 2023 02:30:04 +0900

01. 2차원 행렬(matrix)에 대한 다음과 같은 함수를 작성하고 테스트하여 보라. 행렬의 크기는 3x3으로 가정한다.

scalar_mult(int a[][3], int scalar)

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

void scalar_mult(int a[][3], int scalar) {
	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 3; j++) {
			a[i][j] = scalar * a[i][j]; // 행렬의 모든 값에 2를 곱하는 과정
		}
	}
	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 3; j++) {
			printf("%d ", a[i][j]); // 바뀐 행렬을 시각화
		}
		printf("\n");
	}
}
int main() {
	int a[3][3] = {
		{1, 2, 3},
		{4, 5, 6},
		{7, 8, 9}
	};
	scalar_mult(a, 2); // 배열 a와 곱할 값인 2를 넘기는 과정

	return 0;
}

2 4 6
8 10 12
14 16 18

02. 2차원 행렬(matrix)에 대한 다음과 같은 함수를 작성하고 테스트하여 보라. 행렬의 크기는 3x3으로 가정한다.

transpose(int a[][3], int b[][3])

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

void transpose(int a[][3], int b[][3]) {
	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 3; j++) {
			b[j][i] = a[i][j]; // i와 j의 위치 교환을 통해 대각선 기준으로 값이 교환
		}
	}
}
int main() {
	int a[3][3] = {
		{1, 2, 3},
		{4, 5, 6},
		{7, 8, 9}
	};
	int b[3][3] = { 0, 0, 0 }; // 배열 초기화

	transpose(a, b);

	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 3; j++) {
			printf("%d ", b[i][j]); // 값이 들어간 배열 b를 시각화
		}
		printf("\n");
	}
	return 0;
}

1 4 7
2 5 8
3 6 9

03. 2개의 정수의 합과 차를 동시에 반환하는 함수를 작성하고 테스트하라. 포인터 매개 변수를 사용한다.

void get_sum_diff (int x, int y, int *p_sum, int *p_diff) {

⋯

}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

void get_sum_diff(int x, int y, int* p_sum, int* p_diff) {
	*p_sum = x + y; // sum이 저장된 공간에 직접 접근하여 값을 입력
	*p_diff = x - y; // diff가 저장된 공간에 직접 접근하여 값을 입력
}
int main() {
	int sum = 0, diff = 0; // 생성한 변수의 값을 초기화

	get_sum_diff(100, 200, &sum, &diff); // 주소값을 보내야 직접 접근하여 값을 입력 가능

	printf("원소들의 합=%d\n", sum);
	printf("원소들의 차=%d\n", diff);

	return 0;
}

원소들의 합=300
원소들의 차=-100

[쉽게 풀어쓴 C언어 Express] 7일 차

rokaf6444 — Sun, 1 Jan 2023 02:30:39 +0900

01. 순환 기법을 이용하여 지숫값을 계산하는 함수 power(int base, int power_raised)를 작성하라. power(2,3)가 호출되면 2^3을 계산하여 반환한다.

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int power(int base, int power_raised) {
	int sum = 1; // sum == 모든 곱의 결과값

	for (int i = 0; i < power_raised; i++)
		sum = sum * base; // base를 power_raised만큼 곱하고 sum에 저장

	return sum; // 함수의 결과값을 반환
}

int main() {
	int base, power_rasied; // 각각 밑수와 지수

	printf("밑수: ");
	scanf("%d", &base);
	printf("지수: ");
	scanf("%d", &power_rasied);

	int result = power(base, power_rasied);
	printf("%d^%d = %d", base, power_rasied, result);

	return 0;
}

밑수: 2
지수: 10
2^10 = 1024

02. 주어진 정수가 몇 개의 자릿수를 가지고 있는지 계산하는 프로그램을 순환을 이용하여 작성해보자. 예를 들어서 12345의 경우에는 5가 출력된다.

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int number_size(int number) {
	int size;

	if (number == 0) {
		return 0; // 10으로 나눌 값이 0 -> 자릿수 계산이 끝남, 반환값은 0
	}
	else
	size = number_size(number / 10) + 1; // 일의 자릿수 제거, 자릿수 1씩 측정

	return size;
}

int main() {
	int number, answer; // scanf로 값을 입력, number 값 초기화 불필요

	printf("정수를 입력하시오: ");
	scanf("%d", &number); // 자릿수를 구할 정수값을 입력

	answer = number_size(number);
	printf("자릿수의 개수: %d", answer);

	return 0;
}

정수를 입력하시오: 12345
자릿수의 개수: 5

03. 다음과 같은 수식의 값을 계산하는 순환적인 프로그램을 작성하라.

1/1 + 1/2 + 1/3 + ⋯ + 1/n

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

double func_sum(int n) {
	double sum = 0; // 실수 변수 필요

	if (n == 1) {
		return 1;
	}
	sum = func_sum(n - 1) + 1.0 / n; // 점점 쉬워지는 방향

	return sum;
	}

int main() {
	int user; // 입력한 값
	double result; // 수식의 값

	printf("n의 값: ");
	scanf("%d", &user);

	result = func_sum(user);
	printf("%lf", result);

	return 0;
}

n의 값: 10
2.928968

04. 순환 호출을 이용하여 피보나치수열을 계산해 보자. 피보나치수열이란 다음과 같이 정의되는 수열이다.

{0 n = 0}

fib(n) = {1 n = 1}

{fib(n - 1) + fib(n - 1) otherwise}

즉 일반적인 경우, 앞의 두 개의 숫자를 더해서 뒤의 숫자를 만들면 된다. 정의에 따라 수열을 만들어 보면 다음과 같다.

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int fib(int n) {
	if (n == 0) {
		return 0; // fib(0) = 0
	}
	if (n == 1) {
		return 1; // fib(1) = 1
	}
	else {
		int answer = fib(n - 2) + fib(n - 1); // fib(n) = fib(n - 2) + fib(n - 1) -> n = 0, 1 제외

		return answer;
	}
}

int main() {
	int user;

	printf("정수를 입력하시오: ");
	scanf("%d", &user);

	for (int i = 0; i <= user; i++) { // 사용자가 입력한 정수까지 출력
		printf("fib(%d)=%d\n", i, fib(i));
	}
	return 0;
}

정수를 입력하시오: 15
fib(0)=0
fib(1)=1
fib(2)=1
fib(3)=2
fib(4)=3
fib(5)=5
fib(6)=8
fib(7)=13
fib(8)=21
fib(9)=34
fib(10)=55
fib(11)=89
fib(12)=144
fib(13)=233
fib(14)=377
fib(15)=610

[쉽게 풀어쓴 C언어 Express] 6일 차

rokaf6444 — Wed, 16 Nov 2022 02:30:25 +0900

01. 0 또는 1 값을 무작위로 반환하는 coin_rand() 함수를 작성하여 간단한 동전 던지기 게임을 시뮬레이션하여 보자. 컴퓨터가 동전을 던지고 사용자는 앞뒤를 말한다. 컴퓨터는 coin_rand()를 이용하여 생성된 난수가 1이면 동전의 앞면으로 간주하고 0이면 동전의 뒷면으로 간주한다.

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int coin_rand() {
	int coin;

	srand(time(NULL));
	coin = rand() % 2;

	return 0;
}
int main() {
	while (1) {
		int coin = 0, user = 0;
		char go = 0, y = 0, n = 0;

		coin_rand();
		printf("앞면 또는 뒷면(1 또는 0):");
		scanf("%d", &user);

		if (coin == user) {
			printf("맞았습니다.");
		}
		else {
			printf("틀렸습니다.");
		}
		printf("\n계속하시겠습니까?(y 또는 n):");
		getchar();
		scanf("%c", &go);

		if (go == 'n')
			break;

		else if (go == 'y')
			continue;
	}
	return 0;
}

앞면 또는 뒷면(1 또는 0):1
틀렸습니다.
계속하시겠습니까?(y 또는 n):y
앞면 또는 뒷면(1 또는 0):0
맞았습니다.
계속하시겠습니까?(y 또는 n):y
앞면 또는 뒷면(1 또는 0):

02. 화면에 가로로 막대그래프를 그리는 프로그램을 작성하여 보자. 인수의 값만큼의 별표 문자를 출력하는 함수 print_star(int n)를 작성하라. 반복적으로 사용자로부터 값을 입력받아서 print_star()를 호출하여 입력값만큼 막대를 그리는 프로그램을 완성하라. 사용자가 음수를 입력하면 반복을 중단하라.

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

void print_star(int n);

int main() {
	int n;
	
	while (1) {
		printf("\n값을 입력하시오(종료는 음수): ");
		scanf("%d", &n);

		if (n < 0) {
			break;
		}
		print_star(n);
	}
	return 0;
}

void print_star(int n) {
	for (int i = 0; i < n; i++) {
		printf("*");
	}
}

값을 입력하시오(종료는 음수): 5
*****
값을 입력하시오(종료는 음수): 10
**********
값을 입력하시오(종료는 음수): -1

03. 오일러의 수 e는 자연로그의 밑수로 사용된다. 이 값은 다음과 같은 식에 의하여 근사치를 구할 수 있다. 팩토리얼 값을 계산하는 함수 factorial()을 작성하고 오일러의 수를 계산하는 프로그램을 작성하라.

e = 1 + 1/1! + 1/2! + 1/3! + ⋯ + 1/n!

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int factorial(int user);

int main() {
	int user;
	double e = 1;

	printf("어디까지 계산할까요: ");
	scanf("%d", &user);

	for(int i = 1; i <= user; i++)
		e  = e + 1.0 / factorial(i);

	printf("오일러의 수는 %lf입니다.", e);

	return 0;
}

int factorial(int user) {
	if (user == 1)
		return user;

	else
		return (user * factorial(user - 1));
}

어디까지 계산할까요: 30
오일러의 수는 2.718282입니다

04. 두 개의 부동 소수점 수가 근사적으로 같은 값이면 1을 반환하고 근사적으로 같지 않으면 0을 넘겨주는 함수 math_equal(a, b)을 작성하시오. 근사적으로 같다고 하는 것은 다음의 부등식을 만족하는 경우라고 가정한다.

|a - b| / min(|a|,|b|) < e

부동 소수점 수의 절대값을 구하는 함수와 두수 중에서 최솟값을 찾는 함수는 라이브러리 함수를 이용하라. e는 상수로서 0.000001로 정의된다.

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <math.h>
#define e 0.000001

double math_equal(double a, double b);
double min(double a, double b);

int main() {
	double a, b;

	printf("실수를 입력하시오: ");
	scanf_s("%lf", &a);
	printf("실수를 입력하시오: ");
	scanf_s("%lf", &b);

	math_equal(a, b);

	return 0;
}

double min(double a, double b) {
	double c = a - b;

	if (c == a - b) {
		return b;
	}

	if (c == b - a) {
		return a;
	}
}

double math_equal(double a, double b) {
	double c = a - b;

	if ((fabs(c) / (min(fabs(a), fabs(b))) < e)) {
		printf("두 개의 실수는 서로 같음");

		return 0;
	}

	if ((fabs(c) / (min(fabs(a), fabs(b))) >= e)) {
		printf("두 개의 실수는 서로 다름");

		return 1;
	}
}

실수를 입력하시오: 1.2345
실수를 입력하시오: 1.2346
두 개의 실수는 서로 다름

[쉽게 풀어쓴 C언어 Express] 5일 차

rokaf6444 — Tue, 15 Nov 2022 02:30:33 +0900

01. 컴퓨터는 막대그래프를 그리는 데도 사용된다. 사용자로부터 1부터 50사이의 숫자를 입력 받아서 숫자만큼의 별표를 출력하는 프로그램을 작성하라. 막대는 가로로 그려지게 된다.

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main() {
	int height;

	while (1) {
		printf("막대의 높이(종료 -1): ");
		scanf("%d", &height);

		if (height == -1)
			break;

		if (height == 0 || height < -1 || height > 50) {
			printf("1부터 50까지의 숫자만 입력 가능합니다.");
			break;
		}

		for (int i = 0; i < height; i++) {
			printf("*");
		}
		printf("\n");
	}
	return 0;
}

막대의 높이(종료 -1): 7
*******
막대의 높이(종료 -1): 18
******************
막대의 높이(종료 -1): 20
********************
막대의 높이(종료 -1):

02. 피보나치수열은 다음과 같이 정의되는 수열이다.

f(0) = 0

f(1) = 1

f(i+1) = f(i) + f(i-1)

for i = 1, 2, ...

피보나치수열에서는 앞의 2개의 원소를 합하여 뒤의 원소를 만든다. 피보나치수열은 컴퓨터에서도 탐색 문제 등에 사용되기도 한다. 피보나치수열을 생성하여 출력하는 프로그램을 작성하여 보자.

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main() {
	int a = 0, b = 1;
	int c, n;

	printf("몇번째 항까지 구할까요? ");
	scanf("%d", &n);

	if (n == 1)
		printf("%d", a);

	if (n == 2)
	printf("%d, %d", a, b);

	if (n >= 3) {
		printf("%d, %d, ", a, b);
		for (int i = 0; i < n - 1; i++) {
			c = a + b;
			printf("%d, ", c);
			a = b;
			b = c;
		}
	}
	return 0;
}

몇번째 항까지 구할까요? 10
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55,

03. 사용자가 입력한 특정한 정수의 자릿수를 반대로 출력하는 프로그램을 작성하라. 예를 들어서 사용자가 정수 1206을 입력하였다면 6021이 출력되어야 한다. do…while 문을 사용하여 보라.

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main() {
	int num;

	printf("정수를 입력하시오: ");
	scanf("%d", &num);

	do {
		printf("%d", num % 10);
		num = num / 10;
	} while (num > 0);

	return 0;
}

정수를 입력하시오: 123456
654321

04. 사용자에게 숫자를 입력 받고, 해당 숫자의 줄만큼 * 기호를 출력하는 프로그램을 작성하라. 아래와 같이 정렬되어 출력되도록 한다.

정수를 입력하세요: 1
*
정수를 입력하세요: 2
*
* *
정수를 입력하세요: 3
  *
* *
* * *
정수를 입력하세요: 4
   *
  * *
* * *
* * * *
정수를 입력하세요:

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main() {
	int n = 0;

	while (1)
	{
		printf("정수를 입력하세요: ");
		scanf("%d", &n);

		for (int i = 0; i < n; i++) { // 층수
			for (int j = n - 1; j > i; j--) {
				printf(" ");
			}

			for (int k = 0; k <= i; k++) {
				printf("* ");
			}
			printf("\n");
		}
	}
	return 0;
}

정수를 입력하세요: 1
*
정수를 입력하세요: 2
 *
* *
정수를 입력하세요: 3
  *
 * *
* * *
정수를 입력하세요: 4
   *
  * *
 * * *
* * * *
정수를 입력하세요: