기록

#include<stdio.h>
struct stu
{
	int num;
	char name[20];
	int score;
};

int main()
{
	stu p1, p2;
	
	scanf("%d %s %d", &p1.num, p1.name, p1.score);
	scanf("%d %s %d", &p2.num, p2.name, p2.score);
	
	if(p1.score >= p2.score)
		printf("%d %s %d", &p1.num, p1.name, &p1.score);
	if(p1.score <= p2.score)
		printf("%d %s %d\n", &p2.num, p2.name, &p2.score);
	
}

//이진 트리 탐색  
#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
계속하려면 아무 키나 누르십시오 . . .
*/

//2차원 누적합 만들기
#include<stdio.h>
int n, m, d[20][20], dt[20][20];
int main()
{
	printf("행열 곱의 값은 :");
	scanf("%d %d", &n, &m);
	printf("값을 입력하세요 :\n"); 
	
	for(int i=1; i<=n; i++)
		for(int j=1; j<=m; j++)
			scanf("%d", &d[i][j]);
	
	for(int i=1; i<=n; i++)
		for(int j=1; j<=m; j++)
			dt[i][j]=d[i][j]+dt[i-1][j]+dt[i][j-1]-dt[i-1][j-1];
	printf("누적값은 :\n");
	for(int i=1; i<=n; i++)
	{
		for(int j=1; j<=m; j++)
			printf("%d ", dt[i][j]);
		printf("\n");
	}
}
/*
행열 곱의 값은 :3 4
값을 입력하세요 :
1 4 7 10
2 5 8 11
3 6 9 12
누적값은 :
1 5 12 22
3 12 27 48
6 21 45 78

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

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

typedef struct TreeNode{
	int data;
	struct TreeNode *left, *right;
}TreeNode;

TreeNode n1 = {1, NULL, NULL};
TreeNode n2 = {4, &n1, NULL};
TreeNode n3 = {16, NULL, NULL};
TreeNode n4 = {25, NULL, NULL};
TreeNode n5 = {20, &n3, &n4};
TreeNode n6 = {15, &n2, &n5};
TreeNode *root=&n6;

void inorder(TreeNode *root){ //중위 :LVR 
	if (root){
		inorder(root->left);
		printf("%3d",root->data);
		inorder(root->right);
	}
}
//1 4 15 16 20 25

void preorder(TreeNode *root){ //전위 :VLR
	if (root){
		printf("%3d",root->data);
		preorder(root->left);
		preorder(root->right);
	}	
}
//15 14 1 20 16 25

void postorder(TreeNode *root){ //후위 :LRV 
	if (root){
		postorder(root->left);
		postorder(root->right);
		printf("%3d",root->data);
	}	
}
//1 4 16 25 20 15

int main(){
	inorder(root);
	preorder(root);
	postorder(root);
	printf("\n");
	
	return 0;
}

#include<stdio.h>
int n,d[20][20];
int main()
{
	//가로 행 세로 열
	scanf("%d",&n);
	int i,j;
	for(i=0; i<n; i++)
		for(j=0; j<n; j++)
			scanf("%d", &d[i][j]);
	printf("정순출력:\n");		
	for(i=0; i<n; i++)  
	{
		for(j=0; j<n; j++)
			printf("%d",d[i][j]);
		printf("\n");
	}
	printf("역순출력:\n");
	for(i=n-1; i>=0; i--)  
	{
		for(j=n-1; j>=0; j--)
			printf("%d",d[i][j]);
		printf("\n");
	}
}

/*
3
9 8 7 6 5 4 3 2 1
정순출력:
987
654
321
역순출력:
123
456
789
--------------------------------
Process exited after 7.16 seconds with return value 10
계속하려면 아무 키나 누르십시오 . . .
--------------------------------
Process exited after 9.41 seconds with return value 3
계속하려면 아무 키나 누르십시오 . . .
*/

#include<stdio.h>
char s[100];
int main()
{ 
	int n,m,i;
	scanf("%d ",&n);
	scanf("%d ",&m);
 
	for(i=0; i<n; i++)
		scanf("%c", &s[i]);
	
	for(i=0; i<n; i++){
		if(s[i]>=97)
			printf("%c",(((s[i]-97)+m)%26)+97);
		else
			printf("%c",(((s[i]-65)+m)%26)+65);
	}
	printf("\n");
}
/*
5
3
aDeHz
dGhKc

--------------------------------
Process exited after 12.52 seconds with return value 10
계속하려면 아무 키나 누르십시오 . . .
*/

#include<stdio.h>
char s[10001];
int main() 
{
	int n;
	scanf("%d ",&n); //공백필요 
	
	for(int i=0; i<n; i++)
		scanf("%c",&s[i]);
	
	for(int i=0; i<n; i++)
		printf("%c",s[i]);
	
	printf("\n");
}

#include<stdio.h>
char s[10001];
int main() 
{
	int cnt=0;
	scanf("%s",s); 
	
	for(int i=0; s[i]!='\0'; i++)
		cnt++;

	printf("%s %d\n",s,cnt);
}