반응형

삽입정렬이란?

주어진 원소들을 하나씩 뽑은 후, 나열된 원소들이 항상 정렬된 형태를 가지도록 뽑은 원소를 바른 위치에 삽입하여 나열하는 정렬방식

 

삽입정렬의 특징 

1. 입력이 거의 정렬된 경우 빠른 수행시간을 보인다.

2. 안정적인 정렬이다.

-  두 데이터가 정렬되지 않은 경우에만 교환이 일어난다.

3. 제자리 정렬이다.

- 데이터를 움직이는 경우는 두원소를 서로 교환하는 경우밖에 없으므로, 데이터가 저장된 공간 이외에 별도 공간을 상수 개만 사용한다.

 

뽑은 원소를 어떻게 바른 위치에 삽입할 수 있을까?

- 컴퓨터에서는 나열된 원소를 하나씩 차례대로 비교하면서 삽입된 위치를 찾을 수 있다.

 

#include<stdio.h>
int temp, n= 10;
InsertSort(int A[],int n){
	for(int i = 0; i<n; i++){
		for(int j = i; j>0 && A[j]<A[j-1]; j--){ //정렬된 원소들과 비교 
			temp = A[j]; // 원소를 서로 교환 
			A[j] = A[j-1];
			A[j-1] = temp;
		}
		printf("%d단계를 출력 :", i);
		for(int k=0; k<n; k++){ //정렬되는 과정 출력 
			printf("%d ", A[k]);
		}
		printf("\n");
	}
}
int main(){
	int n = 10; //원소의 개수 
	int A[10]; //정렬 선언 
	printf("입력하세요 :");
	for(int i= 0; i<n; i++){ //정렬할 배열 입력하기 
		scanf("%d",&A[i]);
	}
	InsertSort(A, n);
	for(int i=0; i<n; i++){
		printf("%d ", A[i]); //정렬완료
	}
}
/*
입력하세요 :5 4 3 2 1
0단계를 출력 :5 4 3 2 1
1단계를 출력 :4 5 3 2 1
2단계를 출력 :3 4 5 2 1
3단계를 출력 :2 3 4 5 1
4단계를 출력 :1 2 3 4 5
1 2 3 4 5
--------------------------------
Process exited after 3.268 seconds with return value 0
계속하려면 아무 키나 누르십시오 . . .
*/

정렬 공부하면서 느꼈던 건데 내 입장에서는 단순하게 오름차 or 내림차순으로 정렬하면 되니까 쉽다고 생각되는데 컴퓨터로 구현해보면 생각보다 복잡함.(대충알면 쉽다고 느껴지는데 공부할 수록 때려치고 싶음.) 특히 자료구조 시험을 치면서 느낀건데 대충 정렬 안되어있는 상태에서 오름차순으로 정렬할때까지 몇단계가 필요한가? 이런 문제는 비교적 쉬운데 초기 상태에 숫자들이 많다거나 아니면 어떤수가 어디에 위치되어 있는 경우는 몇단계인가? 이런식의 질문은 많이 화가남. 특히 중간에서 계산실수하면 멘탈나가는거임. 신기한 건 나이를 먹어갈 수록 사칙연산을 못하는 거 같은 느낌 이상하다. 왜 반비례하는 건지 사칙연산은 초등학교 2학년때 가장 잘했던 거 같다.

반응형

'2019~2020 > 자료구조' 카테고리의 다른 글

선택정렬이란  (0) 2019.09.11
버블정렬  (0) 2019.09.11
최댓값 찾기 알고리즘  (0) 2019.09.03
bfs-dfs  (0) 2019.08.26
행렬을 이용한 BFS (c)  (0) 2019.08.20
반응형

선택정렬이란?

주어진 원소 중에서 가장 작은 킷값을 갖는 원소를 선택하여 차례대로 나열하는 정렬방식. 그러니까

처음부터 끝까지 비교해가면서 가장 작은(큰) 수를 찾아 순서대로 만들어 간다.

 

선택정렬의 특징

1. 정렬할 원소의 개수가 일정하다면, 언제나 동일한 수행시간이 걸린다.

2. 안정적이지 않은 정렬이다.(삽입정렬과 반대)

ex) 1 5 30 30 25

-> 1 5 30 30 25 

-> 1 5 30 30 25

-> 1 5 25 30 30

-> 1 5 25 30 30 

정렬이 끝난 시점에 30 30이 30 30으로 순서가 바뀌므로 안정적이지 않은 정렬임.

3. 제자리 정렬이다.

#include<stdio.h>
SelectionSort(int A[],int n){
	int Min, temp, i, j;
	for(i= 0; i<10; i++){
		Min = i; //최솟값 설정   
		for(j=0; j<10; j++){
			if(A[j]<A[Min])
				Min = j; //새로운 최솟값  
		}
		if(Min =! i){ 
		//만약 Min이 i가 아닐때 A[i]와 A[Min] 교환  
			temp = A[i];
			A[i] = A[Min];
			A[Min] = temp;
		}
        printf("%d단계를 출력 :", i);
		for(int k=0; k<n; k++){ //정렬되는 과정 출력 
			printf("%d ", A[k]);
		}
		printf("\n");
	}
}
int main(){
	int A[10];
	printf("입력하세요:");
	for(int i=0; i<10; i++){
		scanf("%d",&A[i]);
	}
	SelectionSort(A, 10);
	for(int i=0; i<10; i++){
		printf("%d",A[i]);
	}
}
/*
입력하세요 :1 3 2 5 4 7 6 0 8 9
0 1 2 3 4 5 6 7 8 9
--------------------------------
Process exited after 1.416 seconds with return value 0
계속하려면 아무 키나 누르십시오 . . .
*/

아마 버블정렬이랑 함께 내가 가장 많이 쓰는 정렬이지 않을까 싶음. 이유는 나도 모르겠음. 근데 C++과 파이썬 그리고 자바 등등으로 넘어가면서 정렬하는 그런 기본적인 코드에 대한 생각을 안한지는 진짜 오래된듯. 그래서 지금 이렇게 보니까 되게 새로움. 그렇다고 다시 공부하겠다거나 그런 생각은 들지 않을 거라 생각하긴 했는데 진짜 신기하기만 하고 그때 열심히 공부했던 게 떠올라서 별로..라는 생각이 드네^^

반응형

'2019~2020 > 자료구조' 카테고리의 다른 글

삽입정렬이란  (0) 2019.09.16
버블정렬  (0) 2019.09.11
최댓값 찾기 알고리즘  (0) 2019.09.03
bfs-dfs  (0) 2019.08.26
행렬을 이용한 BFS (c)  (0) 2019.08.20
반응형

정렬은 오름차순 또는 내림차순으로 이루어지는데, 특별한 언급이 없으면 오름차순 정렬을 기본으로 한다.

 

버블정렬이란?

주어진 리스트의 왼쪽에서부터 모든 인접한 두 원소를 순서대로 비교하면서 자리바꿈을 통해 정렬된 순서를 맞추는 것을 반복함녀서 정렬하는 방식.

 

 - 이름의 유래 -

이웃한 값끼리 비교하여 교환하는 모습이 마치 거품이 보글보글하는 모양과 비슷하다고 해서 붙여진 이름임.

 

버블정렬의 특징 

1. 선택정렬에 비해 원소의 교환이 많이 발생하여 비효율적이다.

2. 안정적인 정렬이다.

- 인접한 두 데이터가 정렬되지 않은 경우에만 교환이 일어나므로 킷값이 같은 겨웅에는 교환이 일어나지 않는다.

3. 제자리 정렬이다.

- 데이터가 움직이는 경우는 두 원소를 서로 교환하는 경우밖에 없으므로, 데이터가 저장된 공간 이외에 별도의 공간을 상수 개만 사용한다. 

#include<stdio.h>
int BubbleSort(int A[],int n){
	int BOUND, temp, top, j;
	BOUND= -1;
	do{
		top = n;
		for(j=top-1; j>BOUND; j--){
			if(A[j]<A[j-1]){
				temp = A[j];
				A[j] = A[j-1];
				A[j-1] = temp;
				top = j;
			}	
            printf("%d단계를 출력 :", i);
			for(int k=0; k<n; k++){ //정렬되는 과정 출력 
				printf("%d ", A[k]);
			}
		printf("\n");
		}
		BOUND = top;
	}while(top<n);
}

int main(){
	
	int n = 10;
	int A[10];
	printf("입력하세요 :");
	for(int i= 0; i<n; i++){
		scanf("%d",&A[i]);
	}
	BubbleSort(A, n);
	for(int i=0; i<n; i++){
		printf("%d ", A[i]);
	}
}
/*
입력하세요 :1 3 2 5 4 7 6 0 8 9
0 1 2 3 4 5 6 7 8 9
--------------------------------
Process exited after 8.36 seconds with return value 0
계속하려면 아무 키나 누르십시오 . . .
*/

선택정렬 다음으로 제일 많이 사용하는 버블정렬.

그렇게까지 효율적이지도 않은데 많이 사용했었음. 이유는 없다. 그냥 이름이 귀여워서 그런가 물론 실제로는 귀엽지 않지만^^ 이름이라도 귀여우니까^^

반응형

'2019~2020 > 자료구조' 카테고리의 다른 글

삽입정렬이란  (0) 2019.09.16
선택정렬이란  (0) 2019.09.11
최댓값 찾기 알고리즘  (0) 2019.09.03
bfs-dfs  (0) 2019.08.26
행렬을 이용한 BFS (c)  (0) 2019.08.20
반응형
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int i;
	int stu, max = 0;
	int height[10] = {176, 168, 182, 175, 162, 173, 188, 163, 173};
	
	for(i=0; i<10; i++){
		if(height[i]>max){
			max = height[i];
			stu = i+1;
		}
	}
	printf("가장 키가 큰 학생은 %d번이고 키는 %d cm입니다.", stu, max);
	return 0;
}
/*
가장 키가 큰 학생은 7번이고 키는 188 cm입니다.
--------------------------------
Process exited after 0.01588 seconds with return value 0
계속하려면 아무 키나 누르십시오 . . .
*/
반응형

'2019~2020 > 자료구조' 카테고리의 다른 글

선택정렬이란  (0) 2019.09.11
버블정렬  (0) 2019.09.11
bfs-dfs  (0) 2019.08.26
행렬을 이용한 BFS (c)  (0) 2019.08.20
연결 리스트 DFS (c)  (0) 2019.08.16
반응형
#include <stdio.h>
#include <stdlib.h>
#define MAX_VERTICES 8 // 노드 최고 개수 8 
#define FALSE 0
#define TRUE 1
typedef struct node *node_point; //선언자  
typedef struct node
{
	int vertex; // 번호 
	node_point link;
};
node_point graph[MAX_VERTICES];
short int visited[MAX_VERTICES]; // 방문기록-배열  
typedef struct queue *queue_point;
typedef struct queue
{
	int vertex;
	queue_point link;
};
node_point createnode(int data);
void bfs (int vertex); // BFS함수 선언 
void addq(queue_point *, queue_point *, int);
int deleteq (queue_point *front); 
int main()
{
	graph[0] = createnode(1);
	graph[0]->link = createnode(2);
	graph[1] = createnode(0);
	graph[1]->link = createnode(3);
	graph[1]->link->link = createnode(4);
	graph[2] = createnode(0);
	graph[2]->link = createnode(5);
	graph[2]->link->link = createnode(6);
	graph[3] = createnode(1);
	graph[3]->link = createnode(7);
	graph[4] = createnode(1);
	graph[4]->link = createnode(7);
	graph[5] = createnode(2);
	graph[5]->link = createnode(7);
	graph[6] = createnode(2);
	graph[6]->link = createnode(7);
	graph[7] = createnode(3);
	graph[7]->link = createnode(4);
	graph[7]->link->link = createnode(5);
	graph[7]->link->link->link = createnode(6);
	printf(" : "); // 정점의 운행 순서
	bfs(0); // 0번 호출
	printf(" \n"); // 끝
}

/* 노드 생성을 위한 함수  */
node_point createnode(int data)
{
	node_point ptr;
	ptr = (node_point)malloc(sizeof(struct node)); //메모리 확보 
	ptr->vertex = data;
	ptr->link = NULL;
	return ptr;
}

void bfs (int v)
{
	node_point w;
	queue_point front, rear;
	front = rear = NULL;
	printf("V%d-> ", v);
	visited[v] = TRUE;
	addq (&front, &rear, v);
	while (front)
	{
		v = deleteq (&front);
		for (w=graph[v]; w;w=w->link)
		if (!visited[w->vertex])
		{
			printf ("V%d-> ", w->vertex);
			addq (&front, &rear, w->vertex);
			visited[w->vertex] = TRUE;
		}	
	}
}
void addq (queue_point *front, queue_point *rear, int data)
{
	queue_point temp;
	temp = (queue_point)malloc(sizeof(struct queue));
	temp->vertex = data;
	temp->link = NULL;
	if (*front)
	(*rear)->link = temp;
	else
	*front = temp;
	*rear = temp;	
}
int deleteq (queue_point *front)
{
	queue_point temp;
	int data;
	temp = *front;
	data = temp->vertex;
	*front = temp->link;
	free(temp);
	return data;
}
/*
 : V0-> V1-> V2-> V3-> V4-> V5-> V6-> V7->

--------------------------------
Process exited after 0.01723 seconds with return value 0
계속하려면 아무 키나 누르십시오 . . .
*/	
반응형

'2019~2020 > 자료구조' 카테고리의 다른 글

버블정렬  (0) 2019.09.11
최댓값 찾기 알고리즘  (0) 2019.09.03
행렬을 이용한 BFS (c)  (0) 2019.08.20
연결 리스트 DFS (c)  (0) 2019.08.16
그래프의 탐색  (0) 2019.08.12
반응형
/*
08/20 BFS(너비 우선 탐색)
큐의 순서대로 나타냄
*/
#include <stdio.h>

int n; // 정점의 최댓값 
int rear, front; // 앞쪽의 뒤쪽을 나타내는 변수 
int map[30][30]; // 인접 행렬 
int queue[30]; // 큐 
int visit[30]; // 방문 여부를 나타내는 배열 

void BFS(int v){
	int i;
	
	visit[v] = 1; // 정점 v를 방문했다고 표시  
	printf("%d에서 시작\n", v);
	queue[rear++] = v; // 큐에 v를 삽입하고 뒤쪽을 1 증가시킴 
	while (front < rear){ //뒤쪽이 앞쪽과 같거나 작으면 루프 탈출
	// 큐의 첫번째에 있는 데이터를 제외하고 제외된 값을 가져오며, 앞쪽 1증가  
		v = queue[front++];
		for (i = 1; i<=n; i++){
			// 정점 v와 정점 i가 만나고, 정점 i를 방분하지 않은 상태일 경우
			if (map[v][i] == 1 && !visit[i]){
				visit[i] = 1; // 정점 i를 방문했다고 표시 
				printf("%d 에서 %d로 이동 \n", v,i);
				queue[rear++] = i; //큐에 i를 삽입하고 후단을 1증가시킴  
			}  
		}
	}
}
int main(){
	int start;// 시작 정점
	int v1,v2;
	
	printf("정점의 총 개수와 시작 정점을 입력하세요. :");
	scanf("%d %d", &n, &start);
	
	while(1){
		printf("연결한 두 정점을 입력하세요. (예 3 4): ");
		scanf("%d %d", &v1, &v2);
		if(v1==-1 && v2==-1) break;
		map[v1][v2] = map[v2][v1] = 1;
	} 
	BFS(start); //DFS 시작! 
	
	return 0;
}
/*
정점의 총 개수와 시작 정점을 입력하세요. :7 0
연결한 두 정점을 입력하세요. (예 3 4): 0 1
연결한 두 정점을 입력하세요. (예 3 4): 0 2
연결한 두 정점을 입력하세요. (예 3 4): 1 3
연결한 두 정점을 입력하세요. (예 3 4): 1 4
연결한 두 정점을 입력하세요. (예 3 4): 2 5
연결한 두 정점을 입력하세요. (예 3 4): 2 6
연결한 두 정점을 입력하세요. (예 3 4): 3 7
연결한 두 정점을 입력하세요. (예 3 4): 4 7
연결한 두 정점을 입력하세요. (예 3 4): 5 7
연결한 두 정점을 입력하세요. (예 3 4): 6 7
연결한 두 정점을 입력하세요. (예 3 4): -1 -1
0에서 시작
0 에서 1로 이동
0 에서 2로 이동
1 에서 3로 이동
1 에서 4로 이동
2 에서 5로 이동
2 에서 6로 이동
3 에서 7로 이동

--------------------------------
Process exited after 70.57 seconds with return value 0
계속하려면 아무 키나 누르십시오 . . .
*/
반응형

'2019~2020 > 자료구조' 카테고리의 다른 글

최댓값 찾기 알고리즘  (0) 2019.09.03
bfs-dfs  (0) 2019.08.26
연결 리스트 DFS (c)  (0) 2019.08.16
그래프의 탐색  (0) 2019.08.12
이진 탐색트리  (0) 2019.06.17
반응형
/*
08/16 DFS
*/
#include <stdio.h>
#include <stdlib.h>
#define MAX_VERTICES 8 // 노드의 최고 개수  
#define FALSE 0 // 매크로 상수 선언  
#define TRUE 1
typedef struct node *node_point; // 임시그래프  
typedef struct node //노드 정의  
{
	int vertex;
	node_point link;
};
node_point graph[MAX_VERTICES]; 
short int visited[MAX_VERTICES]; // 무방향임  
node_point createnode (int data);
void dfs (int vertex); // 함수 선언  
int main( )
{
	/*
	정점?우선순위는 작은 숫자부터  
	*/
	graph[0] = createnode(1); //정점과 연결  
	/* [0] = 정점을 의미 */
	graph[0] -> link = createnode(2); // 정점 1번과 2번 연결  
	graph[1] = createnode(0);
	graph[1] -> link = createnode(3);
	graph[1] -> link->link = createnode(4);
	graph[2] = createnode(0);
	graph[2] -> link = createnode(5);
	graph[2] -> link->link = createnode(6);
	graph[3] = createnode(1);
	graph[3] -> link = createnode(7); graph[4]=createnode(1);
	graph[4] -> link = createnode(7);
	graph[5] = createnode(2);
	graph[5] -> link = createnode(7);
	graph[6] = createnode(2);
	graph[6] -> link = createnode(7);
	graph[7] = createnode(3);
	graph[7] -> link = createnode(4);
	graph[7] -> link -> link = createnode(5);
	graph[7] -> link->link->link = createnode(6);
	printf(" : "); // 정점의 운행 순서 
	dfs (0); //dfs함수 호출  
	printf(" \n"); // 끝  
}

/*  노드 생성을 위한 함수 */
node_point createnode(int data)
{
	node_point ptr; // ptr는 공간  
	ptr = (node_point)malloc(sizeof(struct node)); // 메모리 확보  
	ptr -> vertex = data; // 공간에 data입력  
	ptr -> link = NULL;  
	return ptr;
}

void dfs(int v)
{
	/* v = 그래프의 정점에서 시작하는 깊이 우선 탐색 */
	node_point w;
	visited[v] = TRUE;
	printf("V%d -> ", v);
	for(w = graph[v]; w; w = w -> link) // 링크를 따라가는 반복문  
	// false(NULL)가 될때까지 w는 w링크로 따라감  
		if(!visited[w->vertex])
	dfs(w->vertex); //방문하지 않았다면 dfs호출하여 vertex로 돌아감  
}

/*
 : V0 -> V1 -> V3 -> V7 -> V4 -> V5 -> V2 -> V6 ->

--------------------------------
Process exited after 0.01584 seconds with return value 0
계속하려면 아무 키나 누르십시오 . . .
*/
반응형

'2019~2020 > 자료구조' 카테고리의 다른 글

bfs-dfs  (0) 2019.08.26
행렬을 이용한 BFS (c)  (0) 2019.08.20
그래프의 탐색  (0) 2019.08.12
이진 탐색트리  (0) 2019.06.17
별 출력 수  (0) 2019.06.14
반응형

(1) 깊이 우선 탐색 (DFS)

/*
08/12 그래프 탐색 
*/
#include<stdio.h>

int n; //정점의 총 개수 
int map[30][30]; // 인접행렬 
int visit[30]; //방문 여부를 나타내는 행렬 

void DFS(int v){  
	int i;
	
	visit[v] = 1; // 정점 v를 방문했다고 표시 
	for(i=1; i <= n; i++){
		// 정점 v와 정점 i가 연결 되었고, 정점 i를 방문하지 않는다면  
		if(map[v][i]==1 && !visit[i]){
			printf("%d에서 %d로 이동 \n",v,i);
			DFS(i); // 이동된 정점 i에서 다시 탐색 시작 
		}
	}
}

int main(){
	int start;// 시작 정점
	int v1,v2;
	
	printf("정점의 총 개수와 시작 정점을 입력하세요. :");
	scanf("%d %d", &n, &start);
	
	while(1){
		printf("연결한 두 정점을 입력하세요. (예 3 4): ");
		scanf("%d %d", &v1, &v2);
		if(v1==-1 && v2==-1) break;
		map[v1][v2] = map[v2][v1] = 1;
	} 
	DFS(start); //DFS 시작! 
	
	return 0;	
}
반응형

'2019~2020 > 자료구조' 카테고리의 다른 글

행렬을 이용한 BFS (c)  (0) 2019.08.20
연결 리스트 DFS (c)  (0) 2019.08.16
이진 탐색트리  (0) 2019.06.17
별 출력 수  (0) 2019.06.14
재귀 알고리즘을 사용한 이진 트리 순회  (0) 2019.06.11
반응형
//이진 트리 탐색  
#include<stdio.h>
#include<stdlib.h>

typedef struct Node
{
	Node* Left;
	Node* Right;
	int Data;
} Node;

Node* createNode(int data)
{
	Node* newNode = (Node*)malloc(sizeof(Node));
	newNode->Left = NULL;
	newNode->Right = NULL;
	newNode->Data = data;
	
	return newNode;
}

Node* searchNode(Node* Tree, int findData)
{
	if (Tree == NULL) return NULL;
	if (Tree->Data == findData)
		return Tree;
	else if(Tree->Data > findData)
		searchNode(Tree->Left, findData);
	else
		searchNode(Tree->Right, findData);
}

void insertNode(Node* Tree, Node* newNode)
{
	if(newNode->Data > Tree->Data)
	{
		if (Tree->Right != NULL) insertNode(Tree->Right, newNode);
		else Tree->Right = newNode;
	}
	else if(newNode->Data < Tree->Data)
	{
		if (Tree->Left != NULL)insertNode(Tree->Left, newNode);
		else Tree->Left =  newNode;
	}	
}

Node* findMinNode(Node* Tree)
{
	if(Tree==NULL) return NULL;
	if(Tree->Left !=NULL) return findMinNode(Tree->Left);
	else return Tree;
}

Node* removeNode(Node* Tree, int data)
{
	Node* tempNode;
	if(Tree==NULL) printf("해당하는 노드를 찾을 수 없습니다.\n");
	else if(Tree->Data > data) Tree->Left = removeNode(Tree->Left, data);
	else if(Tree->Data < data) Tree->Right = removeNode(Tree->Right, data);
	else
	{
		if(Tree->Left !=NULL && Tree->Right !=NULL)
		{
			tempNode = findMinNode(Tree->Right);
			Tree->Data = tempNode->Data;
			
			Tree->Right = removeNode(Tree->Right, tempNode->Data);
		}
		else 
		{
			tempNode = Tree;
			if (Tree->Left == NULL) Tree = Tree->Right;
			else if (Tree->Right == NULL) Tree = Tree->Left;
			free(tempNode);
		}
	}
	return Tree;
}

void printTree(Node* Tree)
{
	if(Tree == NULL) return;
	printTree(Tree->Left);
	printf("%d ", Tree->Data);
	printTree(Tree->Right);
}

int main()
{
	Node* Tree = createNode(8);
	Node* findNode;
	int input;
	
	insertNode(Tree, createNode(3));
	insertNode(Tree, createNode(2));
	insertNode(Tree, createNode(5));
	insertNode(Tree, createNode(10));
	insertNode(Tree, createNode(14));
	insertNode(Tree, createNode(11));
	insertNode(Tree, createNode(16));
	
	while(1)
	{
		scanf("%d", &input);
		findNode = searchNode(Tree, input);
		
		if(findNode != NULL)
		{
			printf("해당 노드를 찾았습니다! 노드를 제거합니다. 노드의 위치는 %#x 입니다.\n ", findNode);
			removeNode(Tree, input);
			{
				printf("현재 트리 출력 :");
				printTree(Tree); printf("\n"); 	
			}
		}
		else printf("노드를 찾을 수 없습니다. \n");
	}
	return 0;
}
/*
10
해당 노드를 찾았습니다! 노드를 제거합니다. 노드의 위치는 0x151410 입니다.
 현재 트리 출력 :1 5 6 14 17 21
1
해당 노드를 찾았습니다! 노드를 제거합니다. 노드의 위치는 0x151450 입니다.
 현재 트리 출력 :5 6 14 17 21
5
해당 노드를 찾았습니다! 노드를 제거합니다. 노드의 위치는 0x151430 입니다.
 현재 트리 출력 :6 14 17 21
14
해당 노드를 찾았습니다! 노드를 제거합니다. 노드의 위치는 0x151410 입니다.
 현재 트리 출력 :6 17 21
17
해당 노드를 찾았습니다! 노드를 제거합니다. 노드의 위치는 0x151410 입니다.
 현재 트리 출력 :6 21
21
해당 노드를 찾았습니다! 노드를 제거합니다. 노드의 위치는 0x151410 입니다.
 현재 트리 출력 :6
--------------------------------
Process exited after 14.78 seconds with return value 3221225725
계속하려면 아무 키나 누르십시오 . . .
*/
반응형

'2019~2020 > 자료구조' 카테고리의 다른 글

연결 리스트 DFS (c)  (0) 2019.08.16
그래프의 탐색  (0) 2019.08.12
별 출력 수  (0) 2019.06.14
재귀 알고리즘을 사용한 이진 트리 순회  (0) 2019.06.11
n*n 배열에 저장하여 출력하기  (0) 2019.06.05

+ Recent posts