큐를 이용한 간단한 구직Pro

 

Queue.h

template<typename TYPE>
struct NODE
{
 TYPE data;
 
};

template<typename TYPE>
class Queue
{
private:
 int front;
 int rear;
 int count;
 int maxSize;
 NODE<TYPE>* queueAry;

public:
 Queue(int size = 100);
 ~Queue();
 bool EnQueue(TYPE dataln);
 bool DeQueue(TYPE& dataOut);
 int QueueCount();
 bool QueueFront(TYPE& dataOut);
 bool QueueRear(TYPE& dataOut);
 bool EmptyQueue();
 bool FullQueue();

};

template<typename TYPE>
Queue<TYPE>::Queue(int size=100)
{
 maxSize= size;
 queueAry = new NODE<TYPE> [maxSize];

    if(!queueAry)
 {
  cout << " 큐에 할당할 메모리가 충분치 않습니다."<<endl;
  exit(100);
 }

 front =-1;
 rear = -1;
 count = 0;
}

template<typename TYPE>
Queue<TYPE>::~Queue()
{
 delete [] queueAry;
 queueAry=NULL;
}

template<typename TYPE>
bool Queue<TYPE>::EnQueue(TYPE dataIn)
{
  if(count == maxSize)
  {
   return false;
 
  }
  rear++;
  if(rear == maxSize)
  {
   rear=0;
  }

  queueAry[rear].data=dataIn;

  if(count == 0)
  {
  front = 0;
  }

  count++;
  return true;
 
}

template<typename TYPE>
bool Queue<TYPE>::DeQueue(TYPE& dataOut)
{
 if(count==0)
 {
  return false;
 }

 dataOut = queueAry[front].data;
 front++;

 if(front== maxSize)
 {
 front=0;
 }

 if(count==1)
 {
 rear=front =-1; // 다시 초기화
 }

 count--;
 return true;
}

template<typename TYPE>
int Queue<TYPE>::QueueCount()
{
 return count;
}

template<typename TYPE>
bool Queue<TYPE>::QueueFront(TYPE& dataOut)
{
 if(count==0)
 {
  return false;
  //underflow
 }
 else
 {
  dataOut = queueAry[front].data;
  return true;
 }
}

template<typename TYPE>
bool Queue<TYPE>::QueueRear(TYPE& dataOut)
{
 if(count==0)
 {
  return false;
 }
 else
 {
  dataOut = queueAry[rear].data;
  return true;
 }
}

template<typename TYPE>
bool Queue<TYPE>::EmptyQueue()
{
 return (count==0);
}

template<typename TYPE>
bool Queue<TYPE>::FullQueue()
{
 return (count==maxSize);
}

 

 

main.cpp

#include <iostream>
#include <iomanip> 
#include <ctime>  // 랜덤변수를 넣기 위해
#include "Queue.h"

#include <string>
#include <fstream>

using namespace std;


struct FUNC
{
   char name[100];
   char num[100];
   int time;

};


enum MENU{MENU_ADD,MENU_jobPe, MENU_deQ, MENU_QUIT};

MENU ShowMenu(); //응용

void inPutFUNC(Queue< FUNC >& funclist);
void add(Queue< FUNC >& funclist);
void Pser(Queue< FUNC >& funclist);


int main()
{
 Queue<FUNC> FList;

 inPutFUNC(FList);


 bool flag=false;
 while(true)
 {
  MENU select;
  select=ShowMenu();
 
  switch(select)
  {
  case MENU_ADD:
   {
    add(FList);
    break;
   }
  case MENU_jobPe:
   {
     Pser(FList);
    break;
   }
  case MENU_QUIT:
   {
       cout<<"프로그램종료"<<endl;
    flag=true;
    break;
   }
  }
 if(flag==true)
   {
    break;
   }
 }
 return 0; //소멸자

}


MENU ShowMenu()
{
  while(true)
  {
   cout<< "\n------메뉴-----\n";
   cout<< "1. 추가 \n";
   cout<< "2. 구직서비스 받기 \n";
   cout<< "Q. 프로그램 종료\n";
   cout<<"===================\n";
   cout<<"원하는 작업의 번호를 입력하세요 : ";
 
   char select;
   cin>>select;

   switch(select)
   {
   case '1':
   return MENU_ADD;
   case '2':
    return MENU_jobPe;
   case 'q':
   case 'Q':
      return MENU_QUIT;
   default :
    cout<<"\n올바른 값을 입력해주세요\n";
    break;
     
   }

  }
}


void inPutFUNC(Queue< FUNC >& funclist)
{
 
   int res;
   FUNC func;

  ifstream infile;
  infile.open("in.txt");

  while(infile>>func.name)
  {
  
   infile.getline(func.num,sizeof(func.num));
  
   func.time=time(0);

   res= funclist.EnQueue(func);

   cout<< func.name<<" "<<func.num<<""<<"입력된시간:"<<func.time<<endl;
  
  }
  cout<< "현재 큐에 3명의 학생이 서비스를 기다림"<<endl;
  infile.close();
  
 
}


void add(Queue< FUNC >& funclist)
{
    FUNC func;
 char temp[15];
    bool res;
  
 int count=funclist.QueueCount();

 if(count<5)
 {
     cout<<"이름 입력: ";
  cin>>func.name;
  cin.getline(temp, 10);
 
  cout<<"전화번호입력: ";
  cin.getline(func.num, sizeof(func.num));
  
     func.time=time(0);

  res=funclist.EnQueue(func);
 
 cout<<"성공적으로 추가"<<endl;
 }
 else
 {
   cout <<"최대학생수 5명이 찼습니다"<<endl;
 }
  


}
void Pser(Queue< FUNC >& funclist)
{
  FUNC func;
  srand(time(0));

  int nowTime=time(0);

 

 while(!(funclist.EmptyQueue()))
  {
  bool success=funclist.DeQueue(func);

 
  int inFutTime=func.time;
  int tot= nowTime-inFutTime;


 
  cout<<endl;
  cout<< func.name<<" "<<func.num<<""<<"큐에 들어온 시각"<<func.time<<endl;
  cout <<"서비스 받은 시각:"<<time(0) <<endl;
  cout<< "큐에서 기다린 시간:"<<tot<<"(s)"<<endl;
  cout<<endl;
 

}

}

블로그 이미지

운명을바꾸는자

IT와 함께 살아가는 삶

,


 

queueADT를 이용한 간단한 응용프로그램

 

queueADT.h

template<typename TYPE>
struct NODE
{
 TYPE data;
 NODE<TYPE>* next;
};

template<typename TYPE>
class Queue
{
private:
 NODE<TYPE>* front;
 NODE<TYPE>* rear;
 int count;

public:
 Queue();
 ~Queue();
 bool EnQueue(TYPE dataln);
 bool DeQueue(TYPE& dataOut);
 int QueueCount();
 bool QueueFront(TYPE& dataOut);
 bool QueueRear(TYPE& dataOut);
 bool EmptyQueue();
 bool FullQueue();

};

template<typename TYPE>
Queue<TYPE>::Queue()
{
 front =NULL;
 rear = NULL;
 count = 0;
}

template<typename TYPE>
Queue<TYPE>::~Queue()
{
 NODE<TYPE>* deletePtr;

 while(front!=NULL)
 {
  deletePtr = front;
  front=front->next;
  delete deletePtr;
 }
}

template<typename TYPE>
bool Queue<TYPE>::EnQueue(TYPE dataln)
{

 NODE<TYPE>* newPtr;

 newPtr = new NODE<TYPE>;

 if(newPtr==NULL) //메모리 FULL
 {
  return false;
 }
 
 newPtr->data = dataln;
 newPtr->next = NULL;

 if(count ==0)
 {
  front = newPtr;
 }
 else
 {
  rear->next =  newPtr;
 }
 count++;
 rear = newPtr;
 
 return true;
}

template<typename TYPE>
bool Queue<TYPE>::DeQueue(TYPE& dataOut)
{
 NODE<TYPE>* deleteLoc;

 if(count==0)
 {
  return false;
 }

 dataOut=front->data;
 deleteLoc = front;

 if(count==1)
 {
  rear= NULL;
 }
 
 front = front->next;
 count--;
 delete deleteLoc;
 return true;
}

template<typename TYPE>
int Queue<TYPE>::QueueCount()
{
 return count;
}

template<typename TYPE>
bool Queue<TYPE>::QueueFront(TYPE& dataOut)
{
 if(count==0)
 {
  return false;
  //underflow
 }
 else
 {
  dataOut = front->data;
  return true;
 }
}

template<typename TYPE>
bool Queue<TYPE>::QueueRear(TYPE& dataOut)
{
 if(count==0)
 {
  return false;
 }
 else
 {
  dataOut = rear->data;
  return true;
 }
}

template<typename TYPE>
bool Queue<TYPE>::EmptyQueue()
{
 return(count==0);
}

template<typename TYPE>
bool Queue<TYPE>::FullQueue()
{
 NODE<TYPE>* tempPtr;
 temp = new NODE<TYPE>;

 if(temp!=NULL)
 {
  delete temp;
  return false;
 }
 return true;
}

 

main.cpp

#include <iostream>
#include "queueADT.h"
#include <iomanip>
#include <string>
#include <ctime>  // 랜덤변수를 넣기 위해
using namespace std;

void fillQueues(Queue<int>& q0to9, Queue<int>& q10to19, Queue<int>& q20to29, Queue<int>& qOver29);
void printQueues(Queue<int>& q0to9, Queue<int>& q10to19, Queue<int>& q20to29, Queue<int>& qOver29);
void printQueue(Queue<int>& anyQueue);

int main()
{
 Queue<int> q0to9;
 Queue<int> q10to19;
 Queue<int> q20to29;
 Queue<int> qOver29;

 
 

fillQueues(q0to9, q10to19, q20to29, qOver29);
printQueues(q0to9, q10to19, q20to29, qOver29);

//printQueues(anyQueue);

 return 0;
}

void fillQueues(Queue<int>& q0to9, Queue<int>& q10to19, Queue<int>& q20to29, Queue<int>& qOver29)
{
 srand(time(0));

// srand(time(0)); // 씨앗(현재시간을 기본으로)

 int rnum;
 int category;

 for(int i=0; i<25; i++)
 {
  rnum = rand() % 51;    // 랜덤  0~50 으로 고정하기 위해 %51로 나머지 연산자 사용.
  category = rnum/10;    // 0~50의 수의 categorization
 
  cout<< setw(3) << rnum;
 
  switch(category)
  {
  case 0:
   q0to9.EnQueue(rnum);
   break;
   
  case 1:
   q10to19.EnQueue(rnum);

        break;
  case 2:
   q20to29.EnQueue(rnum);

        break;
  default :
   qOver29.EnQueue(rnum);

        break;
 
  }
 
 }
}
void printQueues(Queue<int>& q0to9, Queue<int>& q10to19, Queue<int>& q20to29, Queue<int>& qOver29)
{
    cout<<endl;
 cout<<endl;
 cout<< "DATA 0~9 : " << endl;
    printQueue(q0to9);
 
    cout<< "DATA 10~19 : " << endl;
 printQueue(q10to19);
 
 cout<< "DATA 20~29 : " << endl;
 printQueue(q20to29);

 cout<< "DATA OVER : " << endl;
    printQueue(qOver29);

}

void printQueue(Queue<int>& anyQueue)
{
  int itemp=0;
  int data;

 while(anyQueue.DeQueue(data))
 {
 if(itemp++ >=10)
 {
  itemp=1;
  cout<<endl;
 }
 cout << setw(3)<<data;
 }
 cout<<endl;

}

'1. IT Story > Development' 카테고리의 다른 글

ChatClient  (0) 2012.03.29
MultiChatServer  (0) 2012.03.29
MultiChatClient  (0) 2012.03.29
큐를 이용한 간단한 구직Pro  (0) 2012.03.29
circularAry 큐를 사용하여 복사하기  (0) 2012.03.29
StackADT를 이용한 중위식구하기  (0) 2012.03.29
배열로 구현한 Stack을 이용한 중위식구하기  (0) 2012.03.29
seqSearch  (0) 2012.03.29
블로그 이미지

운명을바꾸는자

IT와 함께 살아가는 삶

,

 

circularAry 큐를 사용하여 복사하기

 

queueADT_ARY.h

template<typename TYPE>
struct NODE
{
 TYPE data;
 
};

template<typename TYPE>
class Queue
{
private:
 int front;
 int rear;
 int count;
 int maxSize;
 NODE<TYPE>* queueAry;

public:
 Queue(int size = 100);
 ~Queue();
 bool EnQueue(TYPE dataln);
 bool DeQueue(TYPE& dataOut);
 int QueueCount();
 bool QueueFront(TYPE& dataOut);
 bool QueueRear(TYPE& dataOut);
 bool EmptyQueue();
 bool FullQueue();

};

template<typename TYPE>
Queue<TYPE>::Queue(int size=100)
{
 maxSize= size;
 queueAry = new NODE<TYPE> [maxSize];

    if(!queueAry)
 {
  cout << " 큐에 할당할 메모리가 충분치 않습니다."<<endl;
  exit(100);
 }

 front =-1;
 rear = -1;
 count = 0;
}

template<typename TYPE>
Queue<TYPE>::~Queue()
{
 delete [] queueAry;
 queueAry=NULL;
}

template<typename TYPE>
bool Queue<TYPE>::EnQueue(TYPE dataIn)
{
  if(count == maxSize)
  {
   return false;
 
  }
  rear++;
  if(rear == maxSize)
  {
   rear=0;
  }

  queueAry[rear].data=dataIn;

  if(count == 0)
  {
  front = 0;
  }

  count++;
  return true;
 
}

template<typename TYPE>
bool Queue<TYPE>::DeQueue(TYPE& dataOut)
{
 if(count==0)
 {
  return false;
 }

 dataOut = queueAry[front].data;
 front++;

 if(front== maxSize)
 {
 front=0;
 }

 if(count==1)
 {
 rear=front =-1; // 다시 초기화
 }

 count--;
 return true;
}

template<typename TYPE>
int Queue<TYPE>::QueueCount()
{
 return count;
}

template<typename TYPE>
bool Queue<TYPE>::QueueFront(TYPE& dataOut)
{
 if(count==0)
 {
  return false;
  //underflow
 }
 else
 {
  dataOut = queueAry[front].data;
  return true;
 }
}

template<typename TYPE>
bool Queue<TYPE>::QueueRear(TYPE& dataOut)
{
 if(count==0)
 {
  return false;
 }
 else
 {
  dataOut = queueAry[rear].data;
  return true;
 }
}

template<typename TYPE>
bool Queue<TYPE>::EmptyQueue()
{
 return (count==0);
}

template<typename TYPE>
bool Queue<TYPE>::FullQueue()
{
 return (count==maxSize);
}

 

main.cpp

#include <iostream>
#include "queueADT_ARY.h"
#include <iomanip>
#include <string>
#include <ctime>  // 랜덤변수를 넣기 위해
using namespace std;

void fillQueue(Queue<int>& q);
void copyQueue(Queue<int>& q,Queue<int>& q1);

 

int main()
{
 Queue<int> q;
 Queue<int> q1;

 fillQueue(q);
 copyQueue(q,q1);

 return 0;
}

 

void fillQueue(Queue<int>& q)
{
 cout<<"======원본 Q1======"<<endl;

 srand(time(0)); // 씨앗(현재시간을 기본으로)

 int rnum;
 int category;

 for(int i=0; i<25; i++)
 {
  rnum = rand() % 51;    // 랜덤  0~50 으로 고정하기 위해 %51로 나머지 연산자 사용.
  category = rnum/10;    // 0~50의 수의 categorization
 
  cout<<setw(3) << rnum;
 
  q.EnQueue(rnum);
 }
}
 
void copyQueue(Queue<int>& q,Queue<int>& q1)
{
 cout<<endl;
    cout<<"======복사본 Q2======"<<endl;

    int temp=0;
    int data;

 while(q.DeQueue(data))
 {
 
  q1.EnQueue(data);
     temp=1;
    
    
 cout << setw(3)<<data;
     }


    cout<<endl;

}

'1. IT Story > Development' 카테고리의 다른 글

MultiChatServer  (0) 2012.03.29
MultiChatClient  (0) 2012.03.29
큐를 이용한 간단한 구직Pro  (0) 2012.03.29
queueADT를 이용한 간단한 응용프로그램  (0) 2012.03.29
StackADT를 이용한 중위식구하기  (0) 2012.03.29
배열로 구현한 Stack을 이용한 중위식구하기  (0) 2012.03.29
seqSearch  (0) 2012.03.29
AddressListing  (0) 2012.03.29
블로그 이미지

운명을바꾸는자

IT와 함께 살아가는 삶

,

 

StackADT를 이용한 중위식구하기

 

StackADT.h

template<typename TYPE>

struct Node
{
  TYPE data;
  Node<TYPE>* next;
};

template<typename TYPE>

class Stack
{
private:
  int count;
  Node<TYPE>* top;
 
public:
  Stack();
  ~Stack();
  bool pushStack(TYPE dataIn);
  bool popStack(TYPE& dataOut);
  bool stackTop(TYPE& dataOut);
  bool emptyStack();
  bool fullStack();
  int stackCount();

};

template<typename TYPE>

Stack<TYPE>:: Stack()
{
 top=NULL;
 count=0;

}

template<typename TYPE>

Stack<TYPE>:: ~Stack()
{
 Node<TYPE>* temp;

 while(top != NULL)
 {
  temp= top;
  top = top->next;
  delete temp;
 }

 count = 0;

}

 

template<typename TYPE>

bool Stack<TYPE>::pushStack(TYPE dataIn)
 {
    bool success;
 Node<TYPE>* newPtr;

 newPtr = new  Node<TYPE>;

  if(newPtr==NULL)
  {
    success= false;
  }
  else
  {
   newPtr->data = dataIn;
   newPtr->next = top;
   top= newPtr;
   count++;

         success = true;
  }
  return success;
 
 
 }

template<typename TYPE>

bool Stack<TYPE>::popStack(TYPE& dataOut)
 {
    bool success;
 Node<TYPE>* dltPtr;


  if(count==0)
  {
    success= false;
  }
  else
  {
   dltPtr=top;
   dataOut=top->data;
   top=top->next;
   count=count-1;
   delete dltPtr;
   success = true;
  
  
  
         success = true;
  }
  return success;
 
 
 }

 

template<typename TYPE>
bool Stack<TYPE> :: stackTop(TYPE& dataOut)
{
   bool success;
   Node<TYPE>* dltPtr;

   if(count==0)
   {
    success = false;
  
   }
   else
   {
    dltPtr = top;
    dataOut = top->data;
    top= top->next;
    count--;
    delete dltPtr;
    success = true;
   }
   return success;


}

template<typename TYPE>

int Stack<TYPE> :: stackCount()
{

 return count;

}
template<typename TYPE>
bool Stack<TYPE> :: fullStack()
{
 bool success;
 Node<TYPE>* tt;

 tt= new Node<TYPE>;
 
 if(tt==NULL)
 {
  success = false;
 }
 else
 {
  delete tt;
  success = true;
 }
 return success;

}


//스택이 비어 있으면 return true를 한다.

template<typename TYPE>
bool Stack<TYPE>:: emptyStack()
{

 return (count== 0);

}

 

main.cpp

#include <iostream>
#include <iomanip> 

#include "StackADT.h"
#include <string>
using namespace std;

int priority(char c);
char postFixEval(char* postfix);
int calculate(int op1, int op2, char c);

int main()
{
 Stack<char> stack;

 char infix[100];
 char postfix[100];

 cout<<"중위식입력: ";
 cin.getline(infix, sizeof(infix));
 
 int len = strlen(infix);
 char c;
 char token,topToken;
 int j=0;
 

 for(int i=0; i<len; i++)
 {
   c=infix[i];
   cout<< c <<endl;

  
   if(c==' ')
   {
    // do nothing;
  
   }
   else if(c=='(')//여는 괄호
   {
   stack.pushStack(c);
  
   }
   else if(c==')') //닫는괄호
   {
   stack.popStack(token);
   cout<< token<< endl;

   while(token!='(')
   {
    postfix[j] = token;

 j++;
 stack.popStack(token);
   }

   }//else if(c==')') //닫는괄호
   else if(c=='+' || c=='-' || c=='*' || c=='/') //연산자
   {
    stack.stackTop(topToken);
   
    while( !(stack.emptyStack()) && ( priority(c) <= priority(topToken) ))
    {
     stack.popStack(token);
     postfix[j]=token;
     j++;

     stack.stackTop(topToken);
    }
    stack.pushStack(c);
   }//else if(c==) //연산자
   else //피연산자
    {
    postfix[j]=c;
 j++;
  
   }//피연산자
 }//for


 while(!(stack.emptyStack())) // 스택비우기
 {
  stack.popStack(token);
  postfix[j]=token;
  j++;
 }
 postfix[j]='\0';
 cout << postfix <<endl;

int d= postFixEval(postfix);

cout<<"계산값: " << d <<endl;
   return 0;
}


int priority(char c)
{

int p;

 if( (c=='('))
 {
  p=0;
 
 }
 else if(c=='+' || c=='-' )
 {
 p=1;
 
 }
 else if(c=='*' || c=='/')
 {
 p=2;
 }
 return p;

}

char postFixEval(char* postfix)
{
 Stack<int> stack;
 int exprSize= strlen(postfix);
 char c;
 int op1,op2;
 int num;

 for(int index=0; index<exprSize; index++)
 {
  c=postfix[index];

  if(c=='+' || c=='-' || c=='*' || c=='/')// 4개의 연산자
  {
   stack.popStack(op1);
   stack.popStack(op2);
 
   int value = calculate(op1, op2, c);
   stack.pushStack(value);
 
 
  }//if()// 4개의 연산자
 
  else // 피연산자
  {
  int a=c-48;
  stack.pushStack(a);

  //문자 4의 아스키코드값=52
  //52-48=4 -> 숫자 4로 변환됨
  }//else 피연산자

 }//for 스택에 집어 넣는 작업
 int result;
 stack.popStack(result);

 return result;

}

int calculate(int op1, int op2, char c)
{
  int res;

  if(c=='+')
  {
   res= op1+op2;
 
  }
  else if(c=='-')
  {
   res= op1-op2;
 
  }
  else if(c=='*')
  {
   res= op1*op2;
 
  }
  else if(c=='/')
  {
   res= op1/op2;
  }
  else
  {
   return 00;
  }

  return res;

}

블로그 이미지

운명을바꾸는자

IT와 함께 살아가는 삶

,

 

배열로 구현한 Stack을 이용한 중위식구하기

 

StackAry.h

template<typename TYPE>
struct NODE
{
 TYPE data;
};

template<typename TYPE>
class Stack
{
private :
    NODE<TYPE>* stackAry;
 int count;
 int stackMax;
 int top;

public:
 Stack(int size = 100);
 ~Stack();
 bool pushStack(TYPE dataIn);
 bool popStack(TYPE& dataOut);
 bool stackTop(TYPE& dataOut);
 bool emptyStack();
 bool fullStack();
 int stackCount();


};

template<typename TYPE>
Stack<TYPE> :: Stack(int size = 100)
{
 stackMax = size;
 stackAry = new NODE<TYPE> [stackMax];
 
 if(!stackAry)
 {
  cout<< "메모리 넘침"<<endl;
  abort();
 }
 count=0;
 top=-1;
}


template<typename TYPE>
Stack<TYPE>::~Stack()
{
 delete [] stackAry;


}


template<typename TYPE>
bool Stack<TYPE> :: pushStack(TYPE dataIn)
{
 if(count >=stackMax)
 {
 return false;
 }
 count++;
 top++;
 stackAry[top].data=dataIn;
 return true;


}

template<typename TYPE>
bool Stack<TYPE> :: popStack(TYPE& dataOut)
{
  bool success;

  if(count==0)
  {
   success = false;
  }
  else
  {
  
  dataOut = stackAry[top].data;
  top--;
  count--;
  success = true;
  
  }
  return success;


}

template<typename TYPE>
bool Stack<TYPE> :: stackTop(TYPE& dataOut)
{
 bool success;

 if(count==0)
 {
  success = false;
 }
 else
 {
  dataOut = stackAry[top].data;
  success = true;
 }
 return success;
}

template<typename TYPE>
bool Stack<TYPE> ::  emptyStack ()
{
 return (count == 0); // true // false

}

template<typename TYPE>
bool Stack<TYPE> ::  fullStack()
{
 return (count == stackMax);
}


template<typename TYPE>
int Stack<TYPE> :: stackCount()
{
  return count;
}

 

main.cpp

#include <iostream>
#include <iomanip> 
#include <string>
#include "StackAry.h"

using namespace std;

int priority(char c);
char postFixEval(char* postfix);
int calculate(int op1, int op2, char c);

int main()
{
 Stack<char> stack;

 char infix[100];
 char postfix[100];

 cout<<"중위식입력: ";
 cin.getline(infix, sizeof(infix));
 
 int len = strlen(infix);
 char c;
 char token,topToken;
 int j=0;
 

 for(int i=0; i<len; i++)
 {
   c=infix[i];
   cout<< c <<endl;

  
   if(c==' ')
   {
    // do nothing;
  
   }
   else if(c=='(')//여는 괄호
   {
   stack.pushStack(c);
  
   }
   else if(c==')') //닫는괄호
   {
   stack.popStack(token);
   cout<< token<< endl;

   while(token!='(')
   {
    postfix[j] = token;

 j++;
 stack.popStack(token);
   }

   }//else if(c==')') //닫는괄호
   else if(c=='+' || c=='-' || c=='*' || c=='/') //연산자
   {
    stack.stackTop(topToken);
   
    while( !(stack.emptyStack()) && ( priority(c) <= priority(topToken) ))
    {
     stack.popStack(token);
     postfix[j]=token;
     j++;

     stack.stackTop(topToken);
    }
    stack.pushStack(c);
   }//else if(c==) //연산자
   else //피연산자
    {
    postfix[j]=c;
 j++;
  
   }//피연산자
 }//for


 while(!(stack.emptyStack())) // 스택비우기
 {
  stack.popStack(token);
  postfix[j]=token;
  j++;
 }
 postfix[j]='\0';
 cout << postfix <<endl;

int d= postFixEval(postfix);

cout<<"계산값: " << d <<endl;
   return 0;
}


int priority(char c)
{

int p;

 if( (c=='('))
 {
  p=0;
 
 }
 else if(c=='+' || c=='-' )
 {
 p=1;
 
 }
 else if(c=='*' || c=='/')
 {
 p=2;
 }
 return p;

}

char postFixEval(char* postfix)
{
 Stack<int> stack;
 int exprSize= strlen(postfix);
 char c;
 int op1,op2;


 for(int index=0; index<exprSize; index++)
 {
  c=postfix[index];

  if(c=='+' || c=='-' || c=='*' || c=='/')// 4개의 연산자
  {
   stack.popStack(op1);
   stack.popStack(op2);
 
   int value = calculate(op1, op2, c);
   stack.pushStack(value);
 
 
  }//if()// 4개의 연산자
 
  else // 피연산자
  {
  int a=c-48;
  stack.pushStack(a);

  //문자 4의 아스키코드값=52
  //52-48=4 -> 숫자 4로 변환됨
  }//else 피연산자

 }//for 스택에 집어 넣는 작업
 int result;
 stack.popStack(result);

 return result;

}

int calculate(int op1, int op2, char c)
{
  int res;

  if(c=='+')
  {
   res= op1+op2;
 
  }
  else if(c=='-')
  {
   res= op1-op2;
 
  }
  else if(c=='*')
  {
   res= op1*op2;
 
  }
  else if(c=='/')
  {
   res= op1/op2;
  }
  else
  {
   return 00;
  }

  return res;

}

블로그 이미지

운명을바꾸는자

IT와 함께 살아가는 삶

,

seqSearch

1. IT Story/Development 2012. 3. 29. 11:05

 

seqSearch

 

//0~499까지의 숫자를 100개를 randomnum generation하기->배열에 저장
//한줄에 100개씩 출력해서 보이기
//사용자로부터 숫자를 받아서 이숫자가 위 랜덤 넘버 중 있는지를 판정
//판정하는 방법은 함수를 만들어서->seqSearch()
// 함수의 매개변수는 배열,크기,target,찾은 index

#include <iostream>
#include <iomanip>
#include <ctime>

using namespace std;
const int SIZE = 100;

bool seqSearch(int list[], int end, int target, int& locn);

int main()
{
 int list[100];
 int srchArgu;
 int foundLocn;

 cout << "순차적 찾기 프로그램" << endl;

 srand(time(0));

 for(int i = 0; i< SIZE; i++)
 {
  list[i] = rand() % 500;
 }

 cout << "다음과 같은 리스트의 데이터들이 찾아짐" << endl;

 for(int i = 0; i<SIZE; i++)
 {
  if(i%10 == 0)
  {
   cout << endl;
  }
  cout << setw(4) << list[i];
 }
 cout << endl;

 cout << "리스트의 데이터들 중 하나 입력 :" ;
 cin >> srchArgu;
 cout << "Search 직전 : " << time(0) << endl;

 bool b = seqSearch(list, SIZE-1, srchArgu, foundLocn);

 if(b==true)
 {
  cout << "Search 직후 : " << time(0) << endl;  
  cout << "데이터 찾음 : " << list[foundLocn] << " " << "위치" << foundLocn << endl;
 }
 else
 {
  cout << srchArgu << "을(를) 찾지 못하였습니다." << endl;
 }
 return 0;
}

bool seqSearch(int list[], int end, int target, int& locn)
{
 int looker = 0;
 bool found;

 while(looker < end && target != list[looker])
 {
  looker++;
 }
 locn = looker;

 if(target == list[looker])
 {
  found = true;
 }
 else
 {
  found = false;
 }
 return found;
}

블로그 이미지

운명을바꾸는자

IT와 함께 살아가는 삶

,

 

AddressListing

 

#include <iostream>
#include <iomanip>
#include <fstream>
using namespace std;

struct LISTING
{
 char name[31];
 char phone[16];
};

const int MAX_SIZE = 53;
void buildList(LISTING phoneList[], int& last);
void searchList(LISTING phoneList[], int last);
bool seqSearch(LISTING list[], int last, char* target, int& locn);

int main()
{
 LISTING phoneList[MAX_SIZE];
 int last;
 cout << "전화번호부 시작" << endl;
 last = MAX_SIZE - 1;
 buildList(phoneList, last);
 searchList(phoneList, last);
 cout << "전화번호부 끝" << endl;
 return 0;
}

void buildList(LISTING phoneList[], int& last)
{
 ifstream fsPhoneNums;
 int i;
 fsPhoneNums.open("in.txt");
 if(!fsPhoneNums)
 {
  cout << "전화번호 파일을 열 수 없습니다." << endl;
  exit(100);
 }
 i = 0;
 while((i <= last) && (!(fsPhoneNums.eof())))
 {
  fsPhoneNums.getline(phoneList[i].name,
   sizeof(phoneList[0].name), ';');
  fsPhoneNums.getline(phoneList[i].phone,
   sizeof(phoneList[0].phone));
  cout << phoneList[i].name << ";" << phoneList[i].phone << endl;
  i++;
 }
 last = i - 1; // 실질 인덱스
 fsPhoneNums.close();
}
void searchList(LISTING phoneList[], int last)
{
 char srchName[31];
 char more;
 bool found;
 int locn;
 do
 {
  cout << "이름 입력 : ";
  cin>>srchName;
  found = seqSearch(phoneList, last, srchName, locn);
  if(found)
  {
   cout << phoneList[locn].name << "("<< locn <<")" << phoneList[locn].phone << endl;
  }
  else
  {
   cout << srchName << " 은 찾을 수 없는 이름입니다." << endl;
  }
  cout << "다른 번호도 찾을까요? ( Y/N )";
  cin >> more;
 }
 while(more == 'Y' || more == 'y');
}

bool seqSearch(LISTING list[], int last, char* target, int& locn)
{
 int looker = 0;
 while(looker < last && strcmp(strupr(target), strupr(list[looker].name)) != 0)
 {
  looker++;
 }
 locn = looker;
 return(strcmp(strupr(target), strupr(list[looker].name)) == 0);
}

// strupr = 대소문자 변환해서 구분 가능 (소문자)
// strlwr = 대소분자 변환해서 구분 가능 (대문자)

블로그 이미지

운명을바꾸는자

IT와 함께 살아가는 삶

,

 

링크드리스트ADT를 이용한 학생성적관리 Pro

 

LinkedListADT.h

#ifndef LinkedListADT_H
#define LinkedListADT_H

#include <iostream>
using namespace std;

template<typename TYPE>

struct NODE
{
 TYPE data;
 NODE<TYPE>* link;
};

template<typename TYPE, typename KTYPE>

class List
{
private :
  int count;
  NODE<TYPE>* head; // 헤드 노드
  NODE<TYPE>* pos; // 프로세스가 끝난 current 노드

  bool _search(NODE<TYPE>* &pPre, NODE<TYPE>* &pLoc, KTYPE key); //(_내부)
  bool _insert(NODE<TYPE>* pPre, TYPE dataln);
  void _delete(NODE<TYPE>* pPre, NODE<TYPE>* pLoc, TYPE * pDataOut);

public :
   List(); //생성자
   ~List(); //소멸자

   int addNode(TYPE dataIn);
   bool removeNode(KTYPE dltkey, TYPE * pDataOut);
   int listCount();
   bool getNext(int fromWhere, TYPE & dataOut);
};

 

template<typename TYPE, typename KTYPE>

List<TYPE, KTYPE>::List()
{
 count=0;
 head=NULL;
 pos=NULL;
}


template<typename TYPE, typename KTYPE>

List<TYPE, KTYPE>::~List()
{
  NODE<TYPE>* deletePtr;

  if(head != NULL)
  {
    while(count>0)
 {
  deletePtr=head;
  head= deletePtr->link;
  count--;
  delete deletePtr;
 
 }
  }
  cout<<"소멸자 콜"<<endl;
}


template<typename TYPE, typename KTYPE>

bool List<TYPE, KTYPE>::_search(NODE<TYPE>* &pPre, NODE<TYPE>* &pLoc, KTYPE key)
{
  bool found;
 
  if(count==0)
  {
   return false;
  }

  pPre=NULL;
  pLoc= head;
 

 while((pLoc !=NULL) && (key > pLoc->data.key))
 {
  pPre = pLoc;
  pLoc = pLoc->link;
 }

 if(pLoc==NULL)
 {
   found=false;
 }
 else
 {
  if(key == pLoc->data.key)
  {
   found=true;
  }
  else
  {
   found=false;
  }
 }
 return found;
}


template<typename TYPE, typename KTYPE>

bool List<TYPE, KTYPE>::_insert(NODE<TYPE>* pPre,TYPE datain)
{
  NODE<TYPE>* pNew;
  pNew = new NODE<TYPE>;
 
  if(pNew==NULL)
  {
   return false;
  }
 
  pNew->data = datain;
  pNew->link = NULL;
 
  if(pPre==NULL)
  {
    pNew->link=head;
 head=pNew;
  }
  else //중간 또는 끝에 삽입
  {
    pNew->link = pPre-> link;
 pPre->link = pNew;
  }

  count++;

   return true;


}

//연결리스트로부터 데이터를 삭제하고 호출한 모듈의 데이터를 반환한다.

template<typename TYPE, typename KTYPE>

void List<TYPE, KTYPE>::_delete(NODE<TYPE>* pPre, NODE<TYPE>* pLoc, TYPE * pDataOut)
{
  *pDataOut = pLoc->data;
 
  if(pPre==NULL)
  {
   head=pLoc->link;
  }
  else
  {
  pPre->link=pLoc->link;
  }
  count--;

  delete pLoc;

}

 

template<typename TYPE, typename KTYPE>

int List<TYPE, KTYPE>::addNode(TYPE dataln)
{
 bool found;
 bool success;

 NODE<TYPE>* pPre=NULL;
 NODE<TYPE>* pLoc=NULL;

 found = _search(pPre,pLoc,dataln.key);
 
 if(found==true)
 {
  return (+1); // 중복
 }
 else //insertTYPE 할 예정 메모리 넘침주의
 {
   success= _insert(pPre,dataln); // pPre= 벨류~
   if(success==true)
   {
     return (0); //true
   }
   else
   {
    return (-1);
   }
 }

}


template<typename TYPE, typename KTYPE>

bool List<TYPE, KTYPE>::removeNode(KTYPE dltkey, TYPE * pDataOut)
{
  bool found;
  NODE<TYPE> * pPre=NULL;
  NODE<TYPE> * pLoc=NULL;
  found = _search(pPre, pLoc, dltkey);

  if(found==true)
  {
 _delete(pPre,pLoc,pDataOut);
 
 return found;
  }
  else
  {
    return found;
  }
}

 

template<typename TYPE, typename KTYPE>

int List<TYPE, KTYPE>::listCount()
{
 return count;
}

//fromwhere가 0이면 첫 노드의 데이터 값을 전달
//pos는 프로세스가 끝난 노드를 가리킴

template<typename TYPE, typename KTYPE>

bool List<TYPE, KTYPE>::getNext(int fromWhere, TYPE &dataOut)
{
 bool success;

  if(fromWhere==0)
  {
   if(count==0)
   {
    success= false;
   }
   else
   {
    pos = head;
 dataOut=pos->data;
 success=true;
   }

  }
  else
  {
   if(pos->link==NULL)
   {
     success= false;
   }
   else
   {
    pos= pos->link;
    dataOut = pos->data;
    success= true;
   }
  }
   return success;
}


#endif

 

main.cpp

 

#include "LinkedListADT.h"
#include <iostream>
using namespace std;

const int Max_name=51;

struct STUDENT
{
  int key;
  char name[Max_name];
  int kor, eng, math;
  float ave;

};

//==============이하 응용==================


// "_이름" 은 내부함수!!

enum MENU{MENU_ADD_STUDENT,MENU_REMOVE_STUDENT, MENU_SHOW_ALL, MENU_QUIT};

MENU ShowMenu(); //응용

void printstuList(List<STUDENT, int> & studentlist); //응용

void addstu(List<STUDENT, int>& studentlist);
void removeStu(List<STUDENT, int>& studentlist);


int main()
{


 List <STUDENT, int> studentlist; //생성자 콜

 bool flag=false;
 while(true)
 {
  MENU select;
  select=ShowMenu();
 
  switch(select)
  {
  case MENU_ADD_STUDENT:
   {
    addstu(studentlist);
    break;
   }
  case MENU_REMOVE_STUDENT:
   {
    removeStu(studentlist);
    break;
   }
  case MENU_SHOW_ALL:
   {

        printstuList(studentlist);
  break;

   }
  case MENU_QUIT:
   {
       cout<<"프로그램종료"<<endl;
    flag=true;
    break;
   }
  
  
  }
 if(flag==true)
   {
    break;
   }
 }
 return 0; //소멸자

}

 


MENU ShowMenu()
{
  while(true)
  {
   cout<< "\n------메뉴-----\n";
   cout<< "1. 학생 성적 추가 \n";
   cout<< "2. 학생 성적 삭제 \n";
   cout<< "3. 전체 성적 보기\n";
   cout<< "Q. 프로그램 종료\n";
   cout<<"===================\n";
   cout<<"원하는 작업의 번호를 입력하세요 : ";
 
   char select;
   cin>>select;

   switch(select)
   {
   case '1':
   return MENU_ADD_STUDENT;
   case '2':
    return MENU_REMOVE_STUDENT;
   case '3':
      return MENU_SHOW_ALL;
  
   case 'q':
   case 'Q':
      return MENU_QUIT;
   default :
    cout<<"\n올바른 값을 입력해주세요\n";
    break;
     
   }

  }
}

//학생 하나에 대한 정보를 얻기
//학생 구조체만들기
//서버의 addNode함수 호출하기

void addstu(List<STUDENT, int>& studentlist)
{
  STUDENT std;
  cout<<"학번, 이름, 국어, 영어, 수학 점수를 입력: ";

  cin>>std.key>>std.name>>std.kor>>std.eng>>std.math;

  std.ave=float(std.kor+std.eng+std.math)/3.0f;

  int res= studentlist.addNode(std);

  if(res==0)
  {
   cout<<"학생 하나 성공적으로 추가"<<endl;
  }
  else
  {
   if(res==1)
   {
    cout<< "중복된 학번으로 추가 실패"<<endl;
   }
   else
   {
    cout<<"메모리 부족으로 추가 실패"<<endl;
   }
  }
}

//삭제할 학생의 학번 물어보기
//서버의 removeNode함수 콜
void removeStu(List<STUDENT, int>& studentlist)
{
 cout<< "삭제할 학번 : ";
 int sNo;
 cin>> sNo;

 STUDENT std;
   
 bool found =studentlist.removeNode(sNo, &std);
    if(found==true)
 {
  cout<<"학번" <<sNo<<"가 성공적으로 삭제 되었습니다."<<endl;
 }
 else
 {
 cout<<"학번"<<sNo <<"의 학생이 존재하지 않습니다"<<endl;
 }

}

 

void printstuList(List<STUDENT, int>& studentlist)
{
   
 STUDENT std;
 bool success;
   
   
 if(studentlist.listCount()==0)
 {
  cout<< "리스트에 아무도 없음" <<endl;
 
 }
 else
 {
  
  //studentlis의 getNext함수를 호출하여 첫 번쨰 노드의 데이터 값을 가지고 와서 출력

  success=studentlist.getNext(0,std);
     cout<<" 전체 성적보기 "<<endl;
  cout<<" 학번  이름 국어  영어 수학  평균"<<endl;
  cout<< std.key<<"  "<<std.name<<"  "<<std.kor << "  "<< std.eng <<"  "<< std.math <<"  "<<std.ave<<endl;
  
  while(studentlist.getNext(1, std))
  {
     cout<< std.key<<"  "<<std.name<<"  "<<std.kor << "  "<< std.eng <<"  "<< std.math <<"  "<<std.ave<<endl;
  }
      cout<<"리스트의 끝"<<endl;
 }

}

 

'1. IT Story > Development' 카테고리의 다른 글

StackADT를 이용한 중위식구하기  (0) 2012.03.29
배열로 구현한 Stack을 이용한 중위식구하기  (0) 2012.03.29
seqSearch  (0) 2012.03.29
AddressListing  (0) 2012.03.29
insertionSort  (0) 2012.03.28
Heap Tree (보기좋게출력)  (0) 2012.03.28
하노이타워  (0) 2012.03.28
이진찾기  (0) 2012.03.28
블로그 이미지

운명을바꾸는자

IT와 함께 살아가는 삶

,