물마시니의 구구절절

이번에 이산수학 과제로 나온 최소 비용 신장 트리……

그래프 알고리즘에서 꽤나 많이 쓰인다는데……

(물론 다양하게 응용 가능?!)

이게 꽤나 머리를 써야 만드는 알고리즘이라서

일단 이해 하면서 외우는 방향으로 코딩하였다.

에휴 이런 알고리즘을 듣자마자 바로 짤수 있다면 얼마나 좋을까?

신이시여 나에게 천재적 재능을 제발;;;;;

자세한 소스는 밑에서 계속~

[spoiler]

#include <stdio.h>

#include <malloc.h>

typedef struct edge // 간선을 나타내는 구조체

{

int vertex[2]; // 시작점과 끝점

int cost; // 가중치

}Edge;

int **make_array(int n);// 배열 만들기

void read_array(FILE *file, int *G[], int n);// 파일에서 배열값 읽기

void convert_array_to_edge(int* G[], Edge E[], int n);// 배열을 간선으로 변환

void convert_edge_to_array(int* G[], Edge E[], int n, int m);// 간선을 배열로 변환

void print_edgy(Edge E[], int n);// 간선 집합 출력

void kruskal(int n, int m, Edge E[], Edge F[]);// 크루스칼 알고리즘

void bubble_sort(Edge E[], int m);// 거품 정렬

void find_merge(int p, int q, int U[]);// 집합을 합치는 함수

int find_set(int i, int U[]);// 해당 정점이 어떤 집합에 속하는지 찾는 함수

int main()

{

int n, m; // n개의 정점과 m개의 간선을 저장할 변수

int **G; // 더블 포인터로 동적 배열을 생성할 변수 선언

int **result; // 최소신장 트리를 인접배열로 나타내기 위한 변수 선언


Edge *E, *F;

FILE* file;

file = fopen(”kruskal_array.txt”, “r”);

if(file == NULL) {

perror(”File open error”);

return 0;

}

fscanf(file, “%d %d”, &n, &m); // 파일로부터 m, n을 입력 받는다

E = (Edge *) malloc(sizeof(Edge)*(m-1)); // 처음 입력 받은 배열을 간선으로 저장하기 위한 Edge

F = (Edge *) malloc(sizeof(Edge)*(n-2)); // 최소비용 신장트리 결과를 저장할 Edge

G = make_array(n); // 배열 만들기

result = make_array(n);

read_array(file, G, n); // 파일에서 배열 정보 읽기

convert_array_to_edge(G, E, n); // 배열 정보를 간선 정보로 변환

printf(”\n## Kruskal 최소 비용 신장 트리 ##\n”); // 크루스칼 알고리즘을 돌린 최소 비용 신장 트리를 F 간선 집합에 삽입

kruskal(n, m, E, F); // 최소 비용 신장 트리 결과 출력

printf(”\n최소 비용 신장 트리 결과\n”);

print_edgy(F, n);

printf(”\n최소 비용 신장 트리 결과(인접 배열)\n”);

convert_edge_to_array(result, F, n, m); // n-1개의 간선이 F에 포함되므로

fclose(file);

return 0;

}

void print_edgy(Edge E[], int n) // 간선 집합 출력

{

int i;

for(i = 0; i < n; i++) {

if(E[i].cost != 0)

printf(”v%d -> v%d, 가중치 = %d\n”, E[i].vertex[0]+1, E[i].vertex[1]+1, E[i].cost);

}

}

int** make_array(int n) // N x N 배열 만들기

{

int i, j;

int** array; // N x N 동적 배열을 할당받을 더블 포인터 변수를 선언

n–;

array = (int**)malloc(sizeof(int*)*n);

for(i = 0; i <= n; i++) {

array[i] = (int*)malloc(sizeof(int)*n);

}


for (i = 0; i <= n; i++) {

for (j = 0; j <= n; j++) {

array[i][j] = 0;

}

}


return array; // array의 주소값을 반환해준다

}

void read_array(FILE *file, int *G[], int n) // 파일에서 배열 값을 읽어 배열 G에 저장

{

int i, j;

for(i = 0; i < n; i++) {

for(j = 0; j < n; j++) {

fscanf(file, “%d”, &G[i][j]);

}

}

}

void convert_array_to_edge(int *G[], Edge E[], int n)// 배열 정보를 간선 정보로 변환

{

int i, j, num = 0;

for(i = 0; i < n; i++) { // 배열의 정보를 간선 구조체에 삽입

for(j = i; j < n; j++) {

if( G[i][j] != 0 && G[i][j] != 99 ) { // 가중치의 값이 1에서 99 사이로 존재할때

E[num].vertex[0] = i; // i를 배열 첫번째 요소에 넣는다(간선의 시작점)

E[num].vertex[1] = j; // j를 배열 두번째 요소에 넣는다(간선의 끝점)

E[num].cost = G[i][j]; // 가중치를 넣는다

num++; // E의 다음배열을 증가시켜준다

}

}

}

}

void convert_edge_to_array(int* G[], Edge F[], int n, int m)

{

int i, j;

int sum = 0;

int num = 0;

while (num < m) {

for (i = 0; i < n; i++) {

if (F[num].vertex[0] == i) {

for (j = 0; j < n; j++) {

if (F[num].vertex[1] == j) {

G[j][i] = F[num].cost;

G[i][j] = F[num].cost;

sum += F[num].cost;

continue;

}

}

}

}

num++;

}

for (i = 0; i < n; i++) {

for (j = 0; j < n; j++) {

printf(”%2d “, G[i][j]);

}

printf(”\n”);

}

printf(”총비용 : %d\n”, sum);

}

void kruskal(int n, int m, Edge E[], Edge F[]) // 크루스칼 알고리즘

{

int start_vertex, end_vertax, i, current_edge;

int p, q; // 서로소 체크를 위한 집합을 가리키는 변수

int num = 0;

int* U = (int*)malloc(sizeof(int)*(n-1)); // 집합 선언

Edge edge_temp;

printf(”\n정렬 전 Edge E\n”);

print_edgy(E, m);

bubble_sort(E, m); // E에 속한 m개의 간선을 가중치가 작은 것부터 차례로 정렬

printf(”\n정렬 후 Edge E\n”);

print_edgy(E, m);

for (i = 0; i < n; i++) {// 집합 Initialize

U[i] = i;

}

current_edge = 0;

while(num < n-1) { // 간선의 수가 n-1보다 작을 동안

edge_temp = E[current_edge]; // 아직 고려하지 않은 간선 중 가중치가 최소인 간선

start_vertex = E[current_edge].vertex[0]; // i, j = e에 연결된 정점

end_vertax = E[current_edge].vertex[1];

p = find_set(start_vertex, U); // start_vertax가 속하는 집합을 p에 저장

q = find_set(end_vertax, U); // end_vertax가 속하는 집합을 q에 저장

if(p != q ) { // p와 q 가 서로 속한 집합이 다르다면

find_merge(p, q, U); // p, q가 속한 집합을 합침

F[num] = edge_temp; // edge_temp를 F에 추가

num++;

}

current_edge++;

}

}

int find_set(int i, int U[]) // i가 집합 U의 어느 집합에 속하나?

{

int j;

j = i;

while(U[j] != j) {

j = U[j];

}

return j;

}

void find_merge(int p, int q, int U[]) // p, q를 집합 U에 합칩

{

if (p < q) { // p는 합병된 집합을 가리키는 포인터

U[q] = p; // q는 더 이상 집합을 가리키는 포인터가 아님

}

else {

U[p] = q;

}

}

void bubble_sort(Edge E[], int m) // E 엣지 집합의 가중치를 정렬하기 위한 함수

{

int i, Sorted = 0;

Edge tmp;

while( !S
orted ) {// 정렬이 완료되지 않았으면

Sorted = 1;

for(i = 1; i < m; i++) {

if( E[i-1].cost > E[i].cost ) {

tmp = E[i-1];

E[i-1] = E[i];

E[i] = tmp;

Sorted = 0;

}

}

}

}

[/spoiler]

이번에 만든 프로그램은 링크드 리스트를 이용한

간단한? 입,퇴원 및 병실 및 병동 입원현황을 알수 있도록 만드는 것이다.

파일로부터 입력받은 환자와 병실 목록을 이용해서

병실 정보 안에 링크드리스트로 입원중인 환자를 추가하는 게

기본적인 아이디어다.

퇴원은 반대로 링크드리스트에서 제외하는것.

환자 목록은 현재 입원중인 환자와 퇴원한 환자 2가지 경우로 나누어

생각했기 때문에 목록을 각각 따로 만들어주었다.

그렇기 때문에 입원 및 퇴원시 각각 목록으로 옮겨주어야 되는 단점이 있지만

따로 관리 하기 때문에 더 편리한 부분이 있다.

[spoiler "소스 내용"]

#include <iostream>

#include <fstream>

#include <stdlib.h>

#include <string>

#include <time.h>

using namespace std;

#pragma warning(disable:4996) // warning 을 감춰주는 매크로

#define MAX_PATIENTS 100 // 최대 환자수

#define MAX_ROOMS 100 // 최대 방수

#define MAX_CLINICAL_PARTS 10 // 최대 진료부서수

#define MAX_LENGTH 20 // 최대길이

#define MAX_DATE_LEN 9 // “yyyymmdd”

#define EMPTY “”

#define EMPTY_DATE “0″ // empty data of in_date or out_date

#define EMPTY_ROOM -1

#define EMPTY_PATIENT -1

#define DUMMY_P_ID -999 // 병실 입원 환자 목록 더미노드의 Patient ID 값

#define SUCCESS 1

#define NOT_FOUND -1

#define CHECKED_IN -2 // 입원중인 환자

#define CHECKED_OUT -3 // 퇴원한 환자

#define WANT_TO_QUIT -999

#define TRUE 1

#define FALSE 0

// menu constants

#define CHECK_IN 1

#define CHECK_OUT 2

#define INQUIRY 3

#define EXIT 4

void get_date(char date[]);

int get_menu();

//환자 관련 클래스

class Patient {

int patient_id; // 고유 번호

char patient_name[MAX_LENGTH];

char sex; // F:female, M:male

int age;

char insurance; // Y:가입, N:미가입

char clinic_part;

char in_date[MAX_DATE_LEN]; // yyyymmdd

int room_no; // 현재 입원중인 환자: 병실번호, 퇴원환자:NULL

char out_date[MAX_DATE_LEN]; // 현재 입원중인 환자: EMPTY, 퇴원환자:퇴원일

public:

Patient() { // 생성자

patient_id=EMPTY_PATIENT; strcpy(patient_name, “”);

sex=0; age=0; insurance=’N';

clinic_part=0;

strcpy(in_date, “”);

room_no = EMPTY_ROOM, strcpy(out_date, “”);

}

Patient(int p_id, char *p_name, char p_sex, int p_age, char p_insurance, char p_clinic_part, char *p_in_date, int r_no, char *p_out_date) { // 생성자 오버라이딩

patient_id=p_id;

strncpy(patient_name, p_name, MAX_LENGTH);

sex=p_sex;

age=p_age;

insurance=p_insurance;

clinic_part=p_clinic_part;

strncpy(in_date, p_in_date, MAX_DATE_LEN);

room_no = r_no;

strncpy(out_date, p_out_date, MAX_DATE_LEN);

}

~Patient() { } // 파괴자

void setPatientId(int p_id) { patient_id = p_id; } //환자 ID 저장

int getPatientId() { return patient_id; } //환자 ID 반환

char* getPatientName() { return patient_name; } //환자 이름반환

char getSex() { return sex; } //환자 성별 반환

int getAge() { return age; } // 환자 나이 반환

char getInsurance() { return insurance; } // 환자 보험여부 반환

char getClinicPartId() { return clinic_part; } // 진료부서 반환

char* getInDate() { return in_date; } // 입원일자 반환

int getRoomNo() { return room_no; } // 입원병실 반환

char* getOutDate() { return out_date;} // 퇴원일자 반환

void setRoomNo(int room) { room_no = room; }

void SetOutDate(char date[]) { strcpy(out_date, date); }

};

// 환자 목록 클래스

class PatientList {

int max_number;

int patient_count;

Patient *patient_list; // 환자 목록의 배열

public:

PatientList() {max_number=MAX_PATIENTS; patient_count=0; patient_list = new Patient[MAX_PATIENTS];}

PatientList(int n) {max_number=n; patient_count=0; patient_list = new Patient[n];}

~PatientList() { delete[] patient_list;}

int getMaxNumber() { return max_number; }

int getPatientCount() { return patient_count; }

Patient *getPatientList() { return patient_list;}

Patient getPatient(int index) {return patient_list[index];}

void InsertPatient(Patient p);

void deletePatient(int p_index);

int findPatientByIndex(int p_id); // ID를 이용해 환자 목록 검색후 배열의 인덱스를 반환

void SortPatientList();

};

// 환자 정보 헨들링 클래스

class PatientDataHandler {

ifstream in;

ofstream out; // 파일 출력용 out을 선언

void OpenPatientFile(char *fname) {in.open(fname);}

void SavePatientFile(char *fname) {out.open(fname);}

void ClosePatientFile() {in.close();}

void CloseSavePatientFile() {out.close();}

Patient getPatientFromFile(); // 환자 정보를 파일로부터 불러온다.

public:

PatientDataHandler() {}

~PatientDataHandler() {}

int getPatientIdFromKeyboard(); // 키보드로부터 환자ID를 입력받아 반환해줌

Patient getPatientDataFromKeyboard(int p_id); // 키보드로부터 환자정보를 입력받음

void getPatientsFromFile(char *fname, PatientList *in_p_list, PatientList *out_p_list); //파일로부터 환자목록을 입력받음

void savePatientToFile(char *fname, PatientList *in_p_list, PatientList *out_p_list); // 환자 목록을 파일로 저장함

};

// 병실 정보에 연결될 환자 NODE 클래스

class PatientNode

{

int patient_id;

PatientNode * pNext; // 링크드 리스트를 위한 포인터

public:

PatientNode() {}

PatientNode(int p_id) {patient_id = p_id; pNext = NULL; }

~PatientNode() {};

int getPatientId() { return patient_id; }

PatientNode* getPatientNodepNext() { return pNext;}

void SetPatientNodepNext(PatientNode *p_pNext) { pNext = p_pNext;}

};

// 진료부서 클래스

class ClinicPart

{

char part_id; // 진료부서 코드

char part_name[MAX_LENGTH]; // 진료부서 이름

int ward_no; // 병동 인덱스

public:

ClinicPart() {part_id = 0; strcpy(part_name, “”); ward_no=0;}

ClinicPart(int p_id, char *p_name, int w_no) {part_id = p_id; strcpy(part_name, p_name); ward_no = w_no; }

~ClinicPart(){}

char getPartId() {return part_id;}

char* getPartName() {return part_name;}

int getWardNo() {return ward_no;}

};

// 진료부서 목록 클래스

class ClinicPartTable

{

int count; // 현재 진료부서의 수

ClinicPart * clinicPartTable; // 진료부서 배열

public:

ClinicPartTable();

~ClinicPartTable() { delete[] clinicPartTable; }

ClinicPart getClinicPartId(char pId); // 진료부서 코드에 해당하는 진료부서 객체를 반환하는 메소드

ClinicPart getClinicPartId(int roomNo); // 병실 번호에 해당하는 진료부서 객체를 반환하는 메소

};

// 병실 정보 클래스

class Room

{

int room_no; // 병실번호

int capacity; // 수용인원

char sex; // B:both, F:female, M:male

int count; // 현재 입원 환자 수

public:

PatientNode *p_list; // 해당 병실 입원환자 목록에 대한 포인터, 더미 노드 사용

public:

Room() { room_no=EMPTY_ROOM; capacity=0; sex=’ ‘; count=0; p_list=new PatientNode(DUMMY_P_ID); }

Room(int r_no, int r_capa, char r_sex) { room_no=r_no; capacity=r_c
apa; sex=r_sex, count=0; p_list=new PatientNode(DUMMY_P_ID); }

~Room(){}

int getRoomNo() { return room_no; }

int getCapacity() { return capacity; }

char getSex() { return sex;}

int getCount() { return count; }

PatientNode * getPatinetList() { return p_list; }

void insertPatient(PatientNode* p); // 환자 노드를 병실 정보에 삽입

int deletePatient(int p_id); // 넘겨받은 ID로 환자 정보 삭제

};

// 병실 목록 클래스

class RoomList

{

int max_number; // 최대 병실 갯수

int count; // 현재 병실의 갯수

Room *room_list; // 병실 목록의 배열

public:

RoomList() {max_number = MAX_ROOMS; count = 0; room_list = new Room[MAX_ROOMS]; };

RoomList(int n) {max_number = n; count = 0; room_list = new Room[n]; };

~RoomList(){}

int getCount() { return count;}

int getRoomIndex(int room_no);

Room * getRoom(int index) { return &room_list[index];}

void loadPatientsIntoRoom(PatientList &in_p_list); // 읽어온 환자 정보를 병실에 삽입

int findRoomIndexForCheckIn(char clinicPart_id, char sex); // 성별과 진료부서에 맞는 병실을 찾아 병동번호를 반환

void insertRoom(Room r); // 병실 정보를 삽입

};

// 병실 정보 핸들러 클래스

class RoomDataHandler

{

ifstream in;

void openRoomFile(char *fname) { in.open(fname); }

void closeRoomFile() { in.close(); }

Room getRoomFromFile(); // 파일로부터 병실 정보를 읽어온후 반환한다

public:

RoomDataHandler(){}

~RoomDataHandler(){}

int getClinicPartIdIdFromKeyboard(); // 진료부서를 키보드로부터 입력받는다.

void getRoomListFromFile(char *fname, RoomList *r_list); // 파일로부터 병실 정보를 읽어와 병실 목록을 만든다

};

// 사용자로 부터 입력받은 메뉴를 진행

class RoomListProcessor {

public :

RoomListProcessor() {};

~RoomListProcessor() {};

void checkInHandler(PatientList &in_p_list, PatientList &out_p_list, RoomList &room_list);

void checkOutHandler(PatientList &in_p_list, PatientList &out_p_list, RoomList &room_list);

void inquiryHandler(PatientList &in_p_list, PatientList &out_p_list, RoomList &room_list);

};

// ===== Class 정의 시작======

void PatientList::InsertPatient(Patient p)

{

if(patient_count >= max_number) {

cout << “환자 정보를 저장할 공간이 부족합니다.\n” << endl;

exit(1);

}

patient_list[patient_count] = p;

patient_count++;

}

void PatientList::deletePatient(int p_index)

{

int i;

if (patient_count == 0) {

cout << “Patient List Empty!!” << endl;

return;

}

for (i = p_index; i < patient_count; i++) {

patient_list[i] = patient_list[i+1];

}

patient_count–;

}

// ID를 이용해 환자 목록 검색후 배열의 인덱스를 반환

int PatientList::findPatientByIndex(int p_id)

{

for(int i=0; i<patient_count; i++ )

if(p_id == patient_list[i].getPatientId()) return i;

return NOT_FOUND;

}

// 버블 sort 알고리즘을 이용한 정렬

void PatientList::SortPatientList()

{

Patient temp; // 스왑을 위한 temp

for(int i=0; i<patient_count; i++) {

int min = i;

for(int j=i+1; j<patient_count; j++)

if(patient_list[j].getPatientId() < patient_list[min].getPatientId())

min = j;

if(min != i) {

temp = patient_list[i];

patient_list[i] = patient_list[min];

patient_list[min]= temp;

}

}

}

int PatientDataHandler::getPatientIdFromKeyboard()

{

int p_id;

cout << “\nType patient id, (quit to ” << WANT_TO_QUIT << ” )==> “;

cin >> p_id;

return p_id;

}

// 환자 정보를 키보드로부터 입력받는다

Patient PatientDataHandler::getPatientDataFromKeyboard(int p_id)

{

char name[MAX_LENGTH];

char sex; // F:female, M:male

int age;

char insurance; // Y:가입, N:미가입

char clinic_part;

char in_date[MAX_DATE_LEN];

char out_date[MAX_DATE_LEN];

// ID를 제외한 나머지 정보를 키보드로 부터 입력받는다.

cout << “\nType a patient name ==> “;

cin >> name;

cout << “\nType sex of patient. (F:female, M:male) ==> “;

cin >> sex;

cout << “\nType age of patient ==> “;

cin >> age;

cout << “\nType insurance. (0:미가입, 1:가입) ==> “;

cin >> insurance;

cout << “\nType a clinical part id. ==> “;

cin >> clinic_part;

get_date(in_date); // 입원일자를 현재날짜로 입력받는다.

strcpy(out_date, “”); // 퇴원일자에 “”를 넣어준다.

Patient p(p_id, name, sex, age, insurance, clinic_part, in_date, EMPTY_ROOM, out_date); // 입력받은 값으로 Patient 클래스를 생성

return p; // Patient 클래스를 반환해준다.

}

// 환자 정보를 파일로부터 저장받고 저장받은 값을 반환한다.

Patient PatientDataHandler::getPatientFromFile()

{

int id;

char name[MAX_LENGTH];

char sex; // F:female, M:male

int age;

char insurance; // Y:가입, N:미가입

char clinic_part;

char in_date[MAX_LENGTH];

int room_no;

char out_date[MAX_LENGTH];

if( in.eof() ) {

Patient p(EMPTY_PATIENT,”", 0, 0, 0, 0, “”, 0, “”);

return p;

}

in >> id >> name >> sex >> age >> insurance >> clinic_part >> in_date >> room_no >> out_date;

Patient p(id, name, sex, age, insurance, clinic_part, in_date, room_no, out_date);

return p;

}

// 파일로부터 읽어들인 환자 정보를 가지고 환자 목록을 만든다

void PatientDataHandler::getPatientsFromFile(char *fname, PatientList *in_p_list, PatientList *out_p_list)

{

Patient p;

OpenPatientFile(fname);

while(1) { // 파일로 부터 읽어온 환자 정보가 NULL 값을 가질때까지 반복

p = getPatientFromFile();

if (p.getPatientId() == EMPTY_PATIENT) break;

if ( strcmp(p.getOutDate(), EMPTY_DATE) == 0) in_p_list->InsertPatient(p); // 입원환자 목록을 만든다

else out_p_list->InsertPatient(p); // 퇴원환자 목록을 만든다

}

ClosePatientFile();

}

void PatientDataHandler::savePatientToFile(char *fname, PatientList *in_p_list, PatientList *out_p_list)

{

Patient p;

SavePatientFile(fname);

int i;

for (i = 0; i < in_p_list->getPatientCount(); i++) {

p = in_p_list->getPatient(i);

out << p.getPatientId() <<” “<< p.getPatientName() << ” ” << p.getSex() << ” ” << p.getAge() << ” ” << p.getInsurance() << ” ” << p.getClinicPartId() << ” ” << p.getInDate() << ” ” << p.getRoomNo() << ” ” << “0″ << endl;

}

for (i = 0; i < out_p_list->getPatientCount(); i++) {

p = out_p_list->getPatient(i);

out << p.getPatientId() <<” “<< p.getPatientName() << ” ” << p.getSex() << ” ” << p.getAge() << ” ” << p.getInsurance() << ” ” << p.getClinicPartId() << ” ” << p.getInDate() << ” ” << p.getRoomNo() << ” ” << p.getOutDate() << endl;

}

CloseSavePatientFile();

}

// 진료부서 테이블을 만든다

ClinicPartTable::ClinicPartTable()

{

cli
nicPartTable = new ClinicPart[5];

clinicPartTable[0] = ClinicPart(’A', “내과”, 61);

clinicPartTable[1] = ClinicPart(’B', “외과”, 62);

clinicPartTable[2] = ClinicPart(’C', “신경과”, 63);

clinicPartTable[3] = ClinicPart(’D', “소아과”, 64);

clinicPartTable[4] = ClinicPart(’E', “산부인과”, 65);

count = 5;

}

ClinicPart ClinicPartTable::getClinicPartId(char pId)

{

for(int i=0; i<count; i++)

if(clinicPartTable[i].getPartId() == pId) return clinicPartTable[i];

return ClinicPart(NOT_FOUND, NULL, 0); // NOT_FOUND

}

ClinicPart ClinicPartTable::getClinicPartId(int roomNo)

{

for(int i=0; i<count; i++)

if( clinicPartTable[i].getWardNo() == (roomNo/10) ) return clinicPartTable[i];

return ClinicPart(NOT_FOUND, NULL, 0); // NOT_FOUND

}

// 환자 노드를 연결해준다.(링크드 리스트)

void Room::insertPatient(PatientNode* p)

{

PatientNode *ptr = p_list;

// 더미 다음 Node로 연결

p->SetPatientNodepNext(ptr->getPatientNodepNext());

ptr->SetPatientNodepNext(p);

count++;

}

// 환자 노드를 삭제한다.

int Room::deletePatient(int p_id)

{

PatientNode *ptr = p_list;

PatientNode *trail;

while(ptr != NULL) {

if(ptr->getPatientId()== p_id) {

trail->SetPatientNodepNext(ptr->getPatientNodepNext());

delete ptr; // ptr 을 메모리 해제 해줌

count–; // 현재 환자수를 -1 해줌

return SUCCESS;

}

trail = ptr;

ptr = ptr->getPatientNodepNext();

}

return NOT_FOUND;

}

void RoomList::loadPatientsIntoRoom(PatientList &in_p_list)

{

int p_list_count = in_p_list.getPatientCount();

for(int i=0; i<p_list_count; i++) {

// 환자 데이터 하나 선택

Patient p = in_p_list.getPatient(i);

// 기존 입원 병실을 선택

int roomNo = p.getRoomNo();

int r_index = getRoomIndex(roomNo);

if( r_index == NOT_FOUND) {

cout << “존재하지 않는 병실 번호입니다.” << endl;

continue;

}

Room *room = getRoom(r_index);

if( room->getCount() >= room->getCapacity() ) {

cout << “입원 가능 환자수를 초과하여 ” << p.getPatientId() << “환자는 처리 할 수 없습니다.” << endl;

continue;

}

// 환자 노드 만들어서 병실에 환자 삽입

PatientNode *pNode = new PatientNode(p.getPatientId());

room->insertPatient(pNode);

}

}

int RoomList::findRoomIndexForCheckIn(char clinicPart_id, char sex)

{

ClinicPartTable clinicPartTable;

ClinicPart clinicPart;

Room room;

char r_sex;

clinicPart = clinicPartTable.getClinicPartId(clinicPart_id);

// 입원 가능한 병실을 찾는 조건 검사

for(int i=0; i<count; i++) {

room = room_list[i];

if( room.getRoomNo()/10 != clinicPart.getWardNo() ) continue;

r_sex = room.getSex();

if( r_sex != ‘B’ && r_sex != sex ) continue;

if( room.getCount() >= room.getCapacity()) continue;

return i;

}

return NOT_FOUND;

}

int RoomList::getRoomIndex(int room_no)

{

for(int i=0; i<count; i++)

if(room_list[i].getRoomNo() == room_no) return i;

return NOT_FOUND;

}

void RoomList::insertRoom(Room r)

{

if( count >= max_number) {

cout << “병실 데이터를 저장할 공간이 부족합니다.\n” << endl;

exit(1);

}

room_list[count] = r;

count++;

}

Room RoomDataHandler::getRoomFromFile()

{

int room_no; // 병실번호

int capacity; // 수용인원

char sex; // B:both, F:female, M:male

Room nullRoom;

if( in.eof()) return nullRoom;

in >> room_no >> capacity >> sex;

Room r(room_no, capacity, sex);

return r;

}

void RoomDataHandler::getRoomListFromFile(char *fname, RoomList *r_list)

{

Room r;

openRoomFile(fname);

while(1) { // 병실 정보가 NULL 일때까지 반복

r = getRoomFromFile();

if( r.getRoomNo() == EMPTY_ROOM ) break;

r_list->insertRoom(r);

}

closeRoomFile();

}

int RoomDataHandler::getClinicPartIdIdFromKeyboard()

{

int r_no;

cout << “\nType Room Number, (quit to ” << WANT_TO_QUIT << ” )==> “;

cin >> r_no;

return r_no;

}

void RoomListProcessor::checkInHandler(PatientList &in_p_list, PatientList &out_p_list, RoomList &room_list)

{

Patient p;

int p_id;

int p_index; // index for patient list

int r_index; // index for room list

PatientDataHandler pdh;

while(1) {

// 환자 코드를 받는다.

p_id = pdh.getPatientIdFromKeyboard();

// 종료를 원하면 종료

if( p_id == WANT_TO_QUIT) return ;

// 입원 환자 목록에서 p_id 에 해당하는 index 얻어 입원 환자 인지 확인

p_index = in_p_list.findPatientByIndex(p_id);

if( p_index != NOT_FOUND ) {

cout << “입원중인 환자입니다. ” << endl;

continue ;

}

// 퇴원 환자 목록에서 p_id 에 해당하는 index 얻어 기존 환자 데이터가 있는지 확인

p_index = out_p_list.findPatientByIndex(p_id);

if( p_index == NOT_FOUND )

p = pdh.getPatientDataFromKeyboard(p_id); // 새 환자 입력

else

p = out_p_list.getPatient(p_index); // existing patient

// 진료과 코드에 해당하는 병실 목록에서 입원 할 수 있는 병실의 index 찾기

r_index = room_list.findRoomIndexForCheckIn(p.getClinicPartId(), p.getSex());

if( r_index == NOT_FOUND) {

cout << “해당 진료 부서에는 입원 가능한 병실이 없습니다.”;

continue;

}

// 해당 병실에 환자 노드 삽입

Room *room = room_list.getRoom(r_index);

p.setRoomNo(room->getRoomNo());

cout << room->getRoomNo() << ” 병실에 입원” << endl;

// 입원 환자 목록에 환자 데이터 삽입

in_p_list.InsertPatient(p);

PatientNode *pNode = new PatientNode(p.getPatientId());

room->insertPatient(pNode);

}

}

// 퇴원 프로세서 미구현

void RoomListProcessor::checkOutHandler(PatientList &in_p_list, PatientList &out_p_list, RoomList &room_list)

{

PatientDataHandler pdh;

Patient p;

int p_id;

int p_index;

int r_index;

char out_date[MAX_DATE_LEN];

while (1) {

// 환자 번호 입력

p_id = pdh.getPatientIdFromKeyboard();

// 종료를 입력했을 경우

if (p_id == WANT_TO_QUIT) return ;

// 입원 환자 목록에서 p_id에 해당하는 index를 얻어 입원 환자인지 확인

p_index = in_p_list.findPatientByIndex(p_id);

if (p_index == NOT_FOUND) {

cout << “입원중인 환자가 아닙니다.” << endl;

continue;

}

// 반환받은 환자목록 index를 가지고 환자 정보를 반환받음

p = in_p_list.getPatient(p_index);

// 퇴원일자를 현재 날짜로

get_date(out_date);

p.SetOutDate(out_date);

r_index = room_list.getRoomIndex(p.getRoomNo());

out_p_list.InsertPatient(p);

in_p_list.deletePatient(p_index);

Room *room = room_list.getRoom(r_index);

room->deletePatient(p_id);

}

//

}

// 입원환자 현황 프로세서

void RoomListProcessor::inquiryHandler(PatientList &in_p_list, PatientList &out_p_list, RoomList &room_list)

{

Patient p;

Room *r_node;

PatientNode *p_node;

<
p>ClinicPartTable *c_temp = new ClinicPartTable();

ClinicPart c;

int r_no; // 병실번호 입력을 위한 변수

int r_index; // 병실 목록 배열을 반환받을 변수

RoomDataHandler rdh;

while (1) {

// 병실 번호 입력

r_no = rdh.getClinicPartIdIdFromKeyboard();

// 사용자가 종료를 선택했을 시

if (r_no == WANT_TO_QUIT) return ;

// 입력받은 병실번호로 배열 인덱스를 반환받는다

r_index = room_list.getRoomIndex(r_no);

// 반환받은 배열 인덱스로 입력받은 병실을 r_node에 저장한다.

r_node = room_list.getRoom(r_index);

c = c_temp->getClinicPartId(r_no);

cout << “병동 : ” << c.getWardNo() << endl;

cout << “병실번호 환자코드 환자성명 성별 나이” << endl;

// p_node에 PatientNode->pNext 값을 넣고 NULL 일때까지 반복

for (p_node = r_node->p_list->getPatientNodepNext(); p_node; p_node = p_node->getPatientNodepNext()) {

// 환자 정보를 Patient p에 대입

p = in_p_list.getPatient(in_p_list.findPatientByIndex(p_node->getPatientId()));

// 환자 정보 출력

cout << r_node->getRoomNo() << ” ” << p.getPatientId() << ” ” <<p.getPatientName() << ” ” << p.getSex() << ” ” << p.getAge() << endl;

}

}

}

// === 클래스 정의 부분 끝 ===

// 오늘의 날짜를 가져오는 함수

void get_date(char date[])

{

time_t timer;

struct tm *t;

timer = time(NULL); // 현재 시각을 초 단위로 얻기

t = localtime(&timer); // 초 단위의 시간을 분리하여 구조체에 저장

// date에 “YYYYMMDD” 형식으로 저장

sprintf(date, “%0.4d%0.2d%0.2d”, t->tm_year+1900, t->tm_mon+1, t->tm_mday);

}

// get a menu for user

int get_menu()

{

int menu;

while(1) {

// 메뉴 출력

printf(” ***menu***\n”);

printf(”1) Check In\n”);

printf(”2) Check Out\n”);

printf(”3) Inquiry\n”);

printf(”4) Exit\n”);

// 메뉴 선택

printf(”\nMENU ==> “);

scanf(”%d”,&menu);

if(menu >= CHECK_IN && menu <= EXIT)

return menu;

// 잘못된 입력일 경우

printf(”\nInvalid menu!! Retry!!”);

}

}

int main()

{

PatientList in_p_list;

PatientList out_p_list;

RoomList room_list;

PatientDataHandler patient_data_handler;

RoomDataHandler room_data_handler;

RoomListProcessor roomListProcessor;

int menu;

patient_data_handler.getPatientsFromFile(”patient.dat”, &in_p_list, &out_p_list);

in_p_list.SortPatientList();

out_p_list.SortPatientList();

room_data_handler.getRoomListFromFile(”room.dat”, &room_list);

// 병실목록에 기존 입원 환자목록 로드

room_list.loadPatientsIntoRoom(in_p_list);

// 사용자로부터 메뉴 입력을 받는다.

while(1)

{

menu = get_menu();

if(menu == EXIT) {

patient_data_handler.savePatientToFile(”patient.dat”, &in_p_list, &out_p_list);

break;

}

switch(menu) {

case CHECK_IN:

roomListProcessor.checkInHandler(in_p_list, out_p_list, room_list);

break;

case CHECK_OUT:

roomListProcessor.checkOutHandler(in_p_list, out_p_list, room_list);

break;

case INQUIRY:

roomListProcessor.inquiryHandler(in_p_list, out_p_list, room_list);

break;

}

}

}

[/spoiler]

하지만 어제 오후 1시 30분에 시작한 수업이

아직까지 끝나지 않았다는거……

후새드.. 게다가 난 10점 만점에 8점 밖에 못 받았다는거……

 (함수 구조적인 면에서 -1점 …… 자료구조 설계 부분에서 -1점….)

오 쉣!! 9점 받은 학우들도 많고

 그 중에서는 교수님이 인정할 정도로 잘한 애들도 몇명 있었다……

도대체 난 언제쯤이면 그정도로 프로그램을 짤수 있을지……

너무 슬프다 흑흑……

짤방은 자료구조 발표중 사진…..

말로만 듣던 임은기 교수님의 자료구조 과제 검사……

 실제로 겪어보니 일단 정신을 놓을 정도의 압박…-_-;;

 아휴 이거 언제 끝나려나……?

내가 만든 코드를 보고 교수님이 쓰레기라고 하지는 않을지 걱정;;

잘하는 사람들도 기본적으로는 감점이 되고 있는 상황이다 ㄲㄲ

솔직히 내가봐도 내 코드에 쓸모없는 과정도 좀 있고……

교수님이 원하는 자료구조에 부합되는 건 아닌거 같다.

그래도 일단 과제를 완성했고 발표자 명단에 이름이 올라가 있다는것에

의의를 가지고……

이번 과제 발표를 계기로 지적받은 사항은

다음 과제 발표때에는 모두 고칠수 있도록 해야겠다…

(과연 오늘은 언제 끝날지..??)