Jekyll2024-07-19T12:38:39+00:00https://kieranoh.github.io/feed.xmlKieran’s blogKieran's study blogKieran ohBubble Sort2024-07-19T00:00:00+00:002024-07-19T00:00:00+00:00https://kieranoh.github.io/datastructure/bubble-sortBubble Sort

이번 목표는 Sorting 기법중 하나인 Bubble Sort를 C언어로 구현하는것이다.

Bubble Sort (버블 정렬)은 인접한 두 원소를 검사하여 정렬하는 알고리즘이다

시간 복잡도 O(n^2)

공간복잡도 O(n)

설명

버블 정렬은 첫번째 자료와 두번째 자료를 비교, 두번째 자료와 세번째 자료 비교,… 마지막-1 자료와 마지막 자료를 비교하여정렬한다.

이를 한번 마지막까지 실행하면 가장 큰 자료가 맨 뒤로 이동한다. 두번째 실행에서는 마지막을 제외하고 실행하면 정렬되는 데이터가 하나는 증가한다.

구현

#include <stdio.h>

void bubbleSort(int arr[],int size)
{
	int temp;
	for(int i=0;i<size;i++)
	    {
	        for(int j=1;j<size-i;j++)
	        {
	            if(arr[j-1] > arr[j])
	            {
	                temp = arr[j-1];
	                arr[j-1] = arr[j];
	                arr[j] = temp;
	            }
	        }
	    }
}
int main(void)
{
	int arr[100];
	int i, cnt;        
	
	scanf("%d", &cnt);
	
	for(i = 0 ; i < cnt; i++)
	{
		scanf("%d", &arr[i]);
	}

	printf("before bubble sort\n");

	for(i = 0 ; i < cnt; i++)
	{
		printf("%d ",arr[i]);
	}
	printf("\nafter bubble sort\n");
    
	bubbleSort(arr,cnt - 1);    
	
    for(i = 0; i < cnt; i++)
	{
		printf("%d ", arr[i]);
	}
}

결과

before bubble sort
5  7  6  8  9  1  3  2  4  10
after bubble sort
1  2  3  4  5  6  7  8  9  10
]]>Kieran ohMerge Sort2024-07-19T00:00:00+00:002024-07-19T00:00:00+00:00https://kieranoh.github.io/datastructure/merge-sortMerge Sort

이번 목표는 Sorting 기법중 하나인 Merge Sort를 C언어로 구현하는것이다.

Merge Sort(병합 정렬)은 하나의 리스트를 균등한 크기로 분할하고 분할한 리스트를 정렬한 다음 두개의 리스트를 다시 합하여 전체가 정렬되게 하는 것이다.

시간 복잡도 O(nlongn)

공간복잡도 O(n)

설명

Merge Sort는 총 3단계로 구성되어있다.

  • 분할(Divide): 입력 배열을 같은 크기의 2개의 배열로 분할한다.

  • 정복(Conquer): 각각 배열을 정렬한다.

  • 결합(Combine): 정렬된 배열을 하나의 배열에 결합한다.

위 3단계를 수행하기 위해서 추가적인 리스트가 필요하다.

구현

#include <stdio.h>

void merge(int a[], int low, int mid, int hight)   
{
	int b[100];
	int i = low;        
	int j = mid + 1;    
	int k = 0;          
	
	while(i <= mid && j <= hight)
	{
		if(a[i] <= a[j])        
			b[k++] = a[i++];
		else
			b[k++] = a[j++];
	}
	while(i <= mid)            
		b[k++] = a[i++];
	while(j <= hight)           
		b[k++] = a[j++];
	k--;
    
	while(k >= 0)               
	{
		a[low + k] = b[k];
		k--;
	}
}
void mergeSort(int a[], int low, int hight)    
{
	
	int mid;
	if(low < hight)
	{
		mid = (low + hight) / 2;
		mergeSort(a, low, mid);            
		mergeSort(a, mid + 1, hight);      
		merge(a, low, mid, hight);          
	}
}
int main(void)
{
	int arr[100];
	int i, cnt;        
	
	scanf("%d", &cnt);
	
	for(i = 0 ; i < cnt; i++)
	{
		scanf("%d", &arr[i]);
	}

	printf("before merge sort\n");

	for(i = 0 ; i < cnt; i++)
	{
		printf("%d ",arr[i]);
	}
	printf("\nafter merge sort\n");
    
	mergeSort(arr, 0, cnt - 1);    
	
    for(i = 0; i < cnt; i++)
	{
		printf("%d ", arr[i]);
	}
}

결과

before merge sort
5  7  6  8  9  1  3  2  4  10
after merge sort
1  2  3  4  5  6  7  8  9  10
]]>Kieran ohqsort2024-07-19T00:00:00+00:002024-07-19T00:00:00+00:00https://kieranoh.github.io/function/qsortqsort

이번 목표는 qsort 함수 사용법을 공부하는 것이다. qsort는 C언어에서 제공하는 정렬 라이브러리 함수이고 quick sort를 이용한다

기본 구조

void qsort(void *base, size_t nel, size_t width, int(*compare)(const void*, const void*));

  • base : 정렬할 배열의 포인터

  • nel : 배열의 각 원소들의 총 수

  • width : 배열에서 원소하나의 크기

  • (*compare) : 비교를 수행할 함수 포인터

compare 함수

비교함수 내부에는 1,0,-1 중 하나를 반환해야한다. 만약 오름차순으로 정렬하고 싶으면 비교함수 내부에서 첫번째가 두번째보다 클 때 1을, 작을 때 -1, 같을 때 0을 반환하면 된다.

구현

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


int compare (const void* first, const void* second)
{
	int a = *(int*) first; //포인터를 int형으로 변환
	int b = *(int*) second;
    if (a > b)
        return 1;
    else if (a < b)
        return -1;
    else
        return 0;
}

int main()
{
    int arr[] = {5, 7, 6, 8, 9, 1, 3, 2, 4, 10};
    int array_size = sizeof(arr) / sizeof(int);
    int i;

    printf("before qsort \n")
    for (i = 0; i < array_size; i++) 
	{
		printf("%d ", arr[i]);
	}
    printf("\n");

    qsort(arr, array_size, sizeof(int), compare);

	printf("after qsort \n")
    for (i = 0; i < array_size; i++) 
	{
		printf("%d ", arr[i]);
	}


    return 0;
}

결과

before qsort 
5  7  6  8  9  1  3  2  4  10
after qsort
1  2  3  4  5  6  7  8  9  10
]]>Kieran oh1.2 Protocol Layering2024-03-21T00:00:00+00:002024-03-21T00:00:00+00:00https://kieranoh.github.io/computer_network/Protocal-LayeringProtocol

Protocol - defines the rule both the sender and receiver.

데이터 통신을 원활하게 하기 위한 통신 규약.

There are 5 layers in TCP/IP protocol

Protocol Layering

  1. Application Layer (Layer 5)

    • To communicate, a process send a requst to the other process and receives a response

    • Process-toProcess communication is the duty of the Application Layer

  2. Transport Layer (Layer 4)

    • giving servies to the application layer

    • get a message from an application program and deliver it to the corresponding application

  3. Network Layer (Layer 3)

    • responsible for creating a connection between the source computer and destination computer

    • the communication at the network layer is host-to-host

  4. Data-link Layer (Layer 2)

    • routers are responsible for chossing the best link

  5. Physical Later (Layer 1)

    • carrying indiciduals bits in a frame across the link
Layer name 설명
Layer 5 Application 서비스 제공
HTTP,FTP,SMTP,DNS등 프로토콜 동작
데이터 형식, 암호화 압축등 정의
Layer 4 Transport End-toEnd 데이터 전송 관리
TCP와 UDP 프로토콜이 대표적
TCP 연결 지행적, 신뢰성 데이터 전송,
UDP는 비연결 지향적, 신뢰성은 낮지만 속도 중시
Layer 3 Network 패킬을 목적지로 전달
IP 프로토콜이 이 계층에서 동작
라우우팅 패킷 분할/재조립 기능 수행
Layer 2 Data link 물리적 네트워크의 접근을 제공
물리주소(MAC) 사용
Layer 1 Physical 물리 매채를 비트스트림 전송
전기 신호, 광신호 등의 구체적인 전송방식 정의

*End to End - 제3자가 엔드포인트 간에 전송된 데이터에 액세스하지 못하도록 차단하는 보안 통신 프로세스

*Packet - 정보를 보낼 때 특정 형태를 맞추어 보낸다는 것

상위 계층으로 갈수록 추상화 수준이 높아진다

각 계층은 하위 계층에 의존

데이터 전송은 Application Layer(가장 상위 계층)에서 시작된다.

Layer 5에서 생성된 데이터는 아래 계층으로 내려가며 해당 프로토콜에 따라 캡슐화(encapsulation)된다.

Communication

Communication_from_A_to_B

The source host (Source A) need to create a messafe in the application layer and sent it down the layers.

Router is onvolved only three layer (is used only for routing)

-> Physical, Data link, Network

Switch is involved only two layer

->Physical, Data link

*Top three layer is the network, two lower layer is the link.

One of the most important concepts in protocol layering in the Internet is encapsulation/decapsulation.

  • Encapsulation at the Source Host
  • Decapsulation and Encapsulation at Router
  • Decapsulation at the Destination Host

Adressing in the TCP/IP protocol

protocol

This is the table for the packet names and addresses for each layer.

Difference between Frame and Datagram

Frame

  • Data-linke에서 사용되는 단위
  • 물리주소를 헤더에 포함
  • 신뢰성을 위해 오류 검출 및 수정기능 제공

Datagram

  • Internet layer에서 사용되는 단위
  • 소스와 목적지의 논리주소 (IP 주소) 를 헤더에 포함
  • 신뢰성 보장이 약함

Multiplexing and Demutiplexing

multiplexing

Multiplexing : A protocol at a layer can encapsulate a paket from several next-higher layer protocol

Demultiplexing : decapsulating and delivera packe to several next-higher layer.

위 표는 TCP/IP 프로토콜 스탹의 구조를 보여준다.

최상위 계층은 애플리케이션 계층으로, FTP(파일 전송 프로토콜), HTTP(웹 프로토콜), DNS(도메인 이름 시스템), SNMP(네트워크 관리 프로토콜)이 있다.

전송계층에는 TCP(Transmission Control Protocol) 와 UDP (User Data Protocol)이 있다.

]]>Kieran oh1.1 Overview of the Internet2024-03-20T00:00:00+00:002024-03-20T00:00:00+00:00https://kieranoh.github.io/computer_network/Overview-of-InternetLAN & WAN

LAN( local area network ) 은 근거리 통신망으로 제한된 지역 내에서 컴퓨터, 프린터, 스토리지 등 장치들을 연결하는 네트워크이다.

WAN( Wide area network ) 은 광대한 지역을 연결하는 원거리 통신망으로 도시, 지역, 국가 간 거리를 포관하는 넓은 영역들을 연결한다.

difference between LAN & WAN

LAN WAN
Limited in size
interconnect host
privately		 widw sapn
connect switch, router, mordem

*modem - 정보 전달을 위해 신호를 변조하고 송신하고, 수신측에서 원래 신호로 복구하기 위한 보조장치이다. (디지털 신호 (01001) -> 아날로그 신호(진동))

WAN

WAN의 두가지 대표적인 예시에는 Point-to-point WANs, Switched WANs가 있다.

Point-to-point WAN

point-to-point

  • connet two communicating device (cable or air)

Switched WAN

switched-wan

  • conneted by switch

데이터 전송방식

데이터 전송 방식에는 Circuit Switch(CSNs)와 Packet Switch(PSNs)가 있다

Circuit Switch Packet Switch
전용 통신획선을 전송 기간동안 독점적으로 사용 네트워크 자원을 동적으로 공유
전공 대역폭이 데이터 양과 상관없이 고정 패킷 단위로 데이터 전송
전화 네트워크 등에서 사용 패킷은 동일한 물리 회선을 공유하며 서로다른 경로를 거칠 수 있다

*Packet - 정보를 보낼때 특정형태를 맞추어 보내는것

Circuit-Switch

Packet Switch

Difference between internet & Internet

internet - is two or more network that can communicate each other

Internet - composed of thousand of interconnected network

]]>Kieran ohCircular Linked List2023-10-15T00:00:00+00:002023-10-15T00:00:00+00:00https://kieranoh.github.io/datastructure/circular-linked-listCircular Linked List

이번 목표는 자료구조중 하나인 Circular Loinked List, 원형 연결 리스트를 c 언어로 구현하는것 이다. 원형 연결 리스트는 노드를 이용해서 리스트를 만드는 것이다

구조

Node ->Node *next, int data

List ->Node *head(시작),Node *tail(마지막),Node *cur(현재),Node *before(현재 -1)

brfore를 사용하는 이유는 remove를 하기위해 사용된다.

remove 함수는 li->before->next 주소를(리스트의 현재 위치 -1 의 next 주소) li->cur-> next 주소로 (리스트 현재 위치의 다음주소) 바꾸어 주고, li->cur를 (리스트의 현재 위치) li->before로 (리스트의 현재 위치 -1) 바꾸어준후 free를 통해 제거해준다.

구현

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

typedef struct Node{
	struct Node *next;
	int data;
}Node;

typedef struct List{
	Node *head;
	Node *tail;
	Node *cur;
	Node *brefore;
}List;

void init(List *li)
{
	li->head = NULL;
	li->tail = NULL;
	li->cur = NULL;
	li->brefore = NULL;
	
}

void Insert_node(List *li, int num)
{
	Node *temp = (Node*)malloc(sizeof(Node));
	temp->data = num;
	
	if(li->head == NULL)
	{
		li->head = temp;
		li->tail = temp;
		temp->next = temp;
	}
	else
	{
		temp->next = li->tail->next;
		li->tail->next = temp;
		li->tail = temp;	
	}
}

void Cur_init(List *li)
{
	li->cur = li->tail;
	li->brefore = li->tail;
}

void Remove_node(List *li)
{
	Node *temp = li->cur;
	if(temp == li->tail)
	{
		if(li->tail == li->tail->next)
		{
			li->head = NULL;
			li->tail = NULL;
		}
		else
		{
			li->tail = li->brefore;
		}
	}
	li->brefore->next = li->cur->next;
	li->cur = li->brefore;
	free(temp);
}


int main()
{
	int num;
	scanf("%d",&num;
	
	List li;
	init(&li);
	
	for(int i = 1;i<=num;i++)
	{
		Insert_node(&li,i);
	}
	
	Cur_init(&li);
	
	return 0;
}
]]>Kieran ohDeque2023-10-15T00:00:00+00:002023-10-15T00:00:00+00:00https://kieranoh.github.io/datastructure/dequeQueue

이번 목표는 자료구조중 하나인 Deque를 c 언어로 구현하는 것 이다. Deque의 경우 흔히 덱 이라고 부르는데, 이는 기존 큐랑 다르게 앞, 뒤에서 다 출력이 가능하다.

기능

큐에 기본 기능들은 init, push, pop, size, empty, front, back이다.

init -> 덱 초기화

push front -> 데이터를 가장 앞에 삽입

push back -> 데이터를 가장 뒤에 삽입

pop front-> 가장 앞 데이터 추출

pop back -> 가장 뒤 데이터 추출

size -> 큐 크기 확인

empty -> 큐가 비어있는지 유무 확인

front -> 가장 앞에 데이터 확인

back -> 가장 뒤에 있는 데이터 확인

구현

#include <stdio.h>
#include <string.h>
#define SIZE 10000

typedef struct{
	int arr[SIZE];
	int front;
	int back;
}Deque;

void init(Deque *d)
{
	d->front = 0;
	d->back = 0;
	return;
}

int empty(Deque *d)
{
	return(d->front == d->back);
}


void push_front(Deque *d, int num)
{
	d->arr[d->front] = num;
	d->front = (d->front + SIZE -1) % SIZE;
	return;
}

void push_back(Deque *d, int num)
{
	d->back = (d->back +1) %SIZE;
	d->arr[d->back] = num;
	return;
}

int pop_front(Deque *d)
{
	if(empty (d))
	{
		return -1;
	}
	d->front = (d->front+1) %SIZE;
	int temp = d->arr[d->front];
	return temp;
}

int pop_back(Deque *d)
{
	if(empty (d))
	{
		return -1;
	}
	int temp = d->arr[d->back];
	d->back = (d->back + SIZE -1) %SIZE;
	
	return temp;
}

int size(Deque *d)
{
	return (d->back - d->front + SIZE )%SIZE;
}

int front(Deque *d)
{
	if(empty (d))
	{
		return -1;
	}
	int temp = (d->front+1)%SIZE;
	return d->arr[temp];
}

int back(Deque *d)
{
	if(empty (d))
	{
		return -1;
	}
	return d->arr[d->back];
}

int main()
{
	int Tc;
	int num;
	char input[12];
	Deque d;
	init(&d);
	
	scanf("%d",&Tc);
	
	for(int i = 0; i<Tc; i++)
	{
		scanf("%s",&input);
		if(strcmp(input,"push_front")==0)
		{
			scanf("%d",&num);
			push_front(&d,num);
		}
		else if(strcmp(input,"push_back")==0)
		{
			scanf("%d",&num);
			push_back(&d,num);
		}
		else if(strcmp(input,"pop_front")==0)
		{
			printf("%d\n",pop_front(&d));
		}
		else if(strcmp(input,"pop_back")==0)
		{
			printf("%d\n",pop_back(&d));
		}
		else if(strcmp(input,"size")==0)
		{
			printf("%d\n",size(&d));
		}
		else if(strcmp(input,"empty")==0)
		{
			printf("%d\n",empty(&d));
		}
		else if(strcmp(input,"front")==0)
		{
			printf("%d\n",front(&d));
		}
		else if(strcmp(input,"back")==0)
		{
			printf("%d\n",back(&d));
		}
	}
	return 0;
}
]]>Kieran ohQueue2023-10-15T00:00:00+00:002023-10-15T00:00:00+00:00https://kieranoh.github.io/datastructure/queueQueue

이번 목표는 자료구조중 하나인 Queue를 c 언어로 구현하는 것 이다. Queue의 경우 Stack이랑 다르게 선입 선출(FIFO, First in First Out)을 사용한다. 대기줄이라고 생각을 하면 편하다.

기능

큐에 기본 기능들은 init, push, pop, size, empty, front, back이다.

init -> 큐 초기화

push -> 데이터를 가장 뒤에 삽입

pop -> 가장 앞 데이터 추출

size -> 큐 크기 확인

empty -> 큐가 비어있는지 유무 확인

front -> 가장 앞에 데이터 확인

back -> 가장 뒤에 있는 데이터 확인

구현

#include <stdio.h>

typedef struct {
	int arr[10000];
	int front;
	int back;
}Queue;

int init(Queue *q)
{
	q->front=0;	
	q->back=0;
}

void push(Queue *q, int num)
{
	q->arr[q->back++] = num;
	
}

int pop(Queue *q)
{
	if(empty(q)==1)
	{
		printf("pop\nqueue is empty\n________\n");
		return -1;
	}
	printf("pop\n %d\n________\n",q->arr[q->front]);
	return q->arr[q->front++];
}

int size(Queue *q)
{
	printf("size\nsize is %d\n________\n",q->back - q->front);
	return q->back - q->front;
}

int empty(Queue *q)
{
	if(q->front==q->back)
	{
		printf("empty\nqueue is empty\n_______\n");
		return 1;
	}
	printf("empty\nqueue is not empty\n______\n");
	return 0;
}

int front(Queue *q)
{
	if(empty(q)==1)
	{
		printf("front\nqueue is empty\n________\n");
		return -1;
	}
	printf("front\n %d\n________\n",q->arr[q->front]);
	return q->arr[q->front];
}

int back(Queue *q)
{
	if(empty(q)==1)
	{
		printf("back\nqueue is empty\n________\n");
		return -1;
	}
	printf("back\n %d\n________\n",q->arr[q->back -1]);
	return q->arr[q->back-1];
}


int main()
{
	Queue q;
	init(&q);
	push(&q,2);
	push(&q,4);
	push(&q,6);
	pop(&q);
	size(&q);
	empty(&q);
	back(&q);
	front(&q);
	pop(&q);
	pop(&q);
	pop(&q);
	
	return 0;
}

결과

pop
 2
________
size
size is 2
________
empty
queue is not empty
______
back
 6
________
front
 4
________
pop
 4
________
pop
 6
________
pop
queue is empty
________
]]>Kieran ohBinary Search2023-10-01T00:00:00+00:002023-10-01T00:00:00+00:00https://kieranoh.github.io/datastructure/binary-searchBinary Search

이번 목표는 탐색 기법중 하나인 Binary Search(이진 검색)를 C언어로 구현하는 것 이다.

이진 검색을 사용하기 위해 사용되는 배열은 정렬된 상태여야한다.

이 알고리즘은 반씩 나눠서 검색을 반복하는것이다

설명

중간 index인 mid 를 설정해주고, 찾고 싶은 값이 mid 보다 크면 mid+1와 가장 우측 값 사이에서 다시 반을 나누고, 작다면 가장 왼쪽 값과 mid 사이에서 반을 나눈다. 원하는 값이 나올때 까지 반복을 하고 왼쪽 index와 오른쪽 index가 같으면 탐색을 멈춘다

구현

#include <stdio.h>

int binary_search(int *arr,int target, int size)
{
	if(arr[0]>target || arr[size-1] < target)
	{
		
		return -1;
	}
	// 최대 최소를 통해 미리 찾기
	
	int left = 0;
	int right = size-1;
	int mid;
	
	while(left<=right)
	{
		mid =(left+right)/2;
		if(arr[mid]==target)
		{
			return mid;
		}
		if(arr[mid]<target)
		{
			left = mid+1;
			//mid보다 크다면 우측 절반을 다시 찾기
		}
		else
		{
			right = mid-1;
		}
	}
	
}

int main()
{
	int arr[6] = {2,4,6,10,45,95};
	
	printf("array is \n");
	for(int i = 0;i<6;i++)
	{
		printf("%d  ",arr[i]);
	}
	printf("\n");
	
	int target = 6;
	int result = binary_search(arr,target,6);
	printf("target is %d ,it is in %d\n",target,result);
	
	target = 1;
	result = binary_search(arr,target,6);
	printf("target is %d ,it is in %d\n",target,result);
	
	result = binary_search(arr,target,6);
	target = 13;
	printf("target is %d ,it is in %d\n",target,result);
	
	return 0;
	
}

결과

array is
2  4  6  10  45  95
target is 6 ,it is in 2
target is 1 ,it is in -1
target is 13 ,it is in -1
]]>Kieran ohQuick Sort2023-10-01T00:00:00+00:002023-10-01T00:00:00+00:00https://kieranoh.github.io/datastructure/quick-sortQuick Sort

이번 목표는 Sorting 기법중 하나인 Quick Sort를 C언어로 구현하는것이다.

Quick Sort는 병합정렬과 비슷한 로직으로 기준이 되는 pivot을 기준으로 앞,뒤 배열을 쪼개어 기준값보다 작은 값을 앞으로, 큰값은 뒤로 보내어 재귀함수를 통해 정렬하는 방식이다.

시간 복잡도 O(nlongn)

공간복잡도 O(n)

설명

중간값을 pivot으로 설정을 한다면 왼쪽값을 left 오른쪽을 right로 설정한다. (L과 R은 index이다)

각각 반대 방향으로 이동하고, left는 기준보다 큰수, right는 기준보다 작은수를 만나면 멈추고 swap한다.

위 과정을 left가 right보다 오른쪽에 올 때까지 반복하고 반복한다.

구현

#include <stdio.h>

void quick_sort(int *arr,int L,int R)
{
	int left = L;
	int right = R;
	int p = arr[(L+R)/2]; //pivot 설정 (가운데 기준값)
	int temp;//swap 용 temp

	do
	{
		while(arr[left]<p)
		{
			left++;
		}
		while(arr[right]>p)
		{
			right--;
		}
		if(left<=right)
		{
			temp = arr[left];
			arr[left] = arr[right];
			arr[right] = temp;
			left++;
			right--;			
		}
	}while(left<=right);
	
	if(L<right)
	{
		quick_sort(arr,L,right);
	}
	if(left<R)
	{
		quick_sort(arr,left,R);
	}
}

int main()
{
	int arr[10]={5,7,6,8,9,1,3,2,4,10};
	printf("before quick sort\n");
	for(int i = 0; i<10;i++)
	{
		printf("%d  ",arr[i]);
	}
	printf("\nafter quick sort\n");
	quick_sort(arr,0,10-1);
	for(int i = 0; i<10;i++)
	{
		printf("%d  ",arr[i]);
	}
	
	return 0;
}

결과

before quick sort
5  7  6  8  9  1  3  2  4  10
after quick sort
1  2  3  4  5  6  7  8  9  10
]]>Kieran oh