수다닷컴

ctrl+F5를 눌러서 오류 있는지 확인 해봤습니다 왜 안될까요-------bintreelinkedqueue.h
#ifndef _LINKED_DEQUE_
#define _LINKED_DEQUE_
#include bintree.htypedef struct queueNodeType{
binTree* data;
struct dequeNodeType* pLink;
}queueNode;
typedef struct linkedQueueType{
int currentElementCount;
queueNode* pFrontNode;
queueNode* pRearNode;
}linkedQueue;
linkedQueue* createLinkedQueue();
int enqueueLQ(linkedQueue* pQueue,queueNode element);
queueNode* dequeueLQ(linkedQueue* pQueue);
queueNode* dequeueLQ(linkedQueue* pQueue);
void deleteLinkedQueue(linkedQueue* pQueue);
int isLinkedQueueFull(linkedQueue* pQueue);
int isLinkedQueueEmpty(linkedQueue* pQueue);
#endif
#ifndef _COMMON_QUEUE_DEF_
#define _COMMON_QUEUE_DEF_
#define TRUE 1
#define FALSE 0
#endif
--------------------------------------bintreelinkedstack.h
#ifndef _LINKED_STACK_
#define _LINKED_STACK_
#include bintree.htypedef struct stackNodeType{
binTree *data;
struct stackNodetype *pLink;
}stackNode;
typedef struct LinkedStackNode{
int currentElementCount;
stackNode* pTopElement;
}linkedStack;
linkedStack* createLinkedStack();
int pushLS(linkedStack* pStack,stackNode element);
stackNode* popLS(linkedStack* pStack);
stackNode* peekLS(linkedStack* pStack);
void deleteLinkedStack(linkedStack *pStack);
int isLinkedStackFull(linkedStack* pStack);
int isLinkedStackEmpty(linkedStack* pStack);#endif
#ifndef _COMMON_STACK_DEF_
#define _COMMON_STACK_DEF_
#define TRUE 1
#define FALSE 0
#endif
--------bintreetraversal.h
#ifndef BINTREE_TRAVERSAL_
#define BINTREE_TRAVERSAL_
void preorderTraversalBinTree(binTree *pBinTree);
void inorderTraversalBinTree(binTree *pBinTree);
void postorderTraversalBinTree(binTree *pBinTree);
void levelOrderTraversalBinTree(binTree *pBinTree);
#endif
--------bintree.h
#ifndef _BIN_TREE_
#define _BIN_TREE_
typedef struct BinTreeNodeType
{
char date;
int n;
struct BinTreeNodeType* pLeftChild;
struct BinTreeNodeType* pRightChild;
}binTreeNode;
typedef struct BinTreeType
{
binTreeNode* pbinRootNode;
}binTree;
binTree* makeBinTree(binTreeNode rootNode);
binTreeNode* getRootNodeBT(binTree* pBinTree);
binTreeNode* insertLeftChildNodeBT(binTreeNode* pParentNode,binTreeNode element);
binTreeNode* insertRightChildNodeBT(binTreeNode* pParentNode,binTreeNode element);
binTreeNode* getLeftChildNodeBT(binTreeNode* pNode);
binTreeNode* getRightChildNodeBT(binTreeNode* pNode);
void deleteBinTree(binTree* pBinTree);
void deleteBinTreeNode(binTreeNode* pNode);
#endif
#ifndef _COMMON_TREE_DEF_
#define _COMMON_TREE_DEF_
#define TREE 1
#define FALSE 0
#endif----------------bintree.c
nclude bintree.h
#include stdio.h
#include stdlib.hbinTree* makeBinTree(binTreeNode rootNode){
binTree* pReturn=NULL;
pReturn=(binTree*)malloc(sizeof(binTree));
if(pReturn!=NULL){
pReturn-pbinRootNode=(binTreeNode*)malloc(sizeof(binTreeNode));
if(pReturn-pbinRootNode!=NULL){
*(pReturn-pbinRootNode)=rootNode;
pReturn-pbinRootNode-pLeftChild=NULL;
pReturn-pbinRootNode-pRightChild=NULL;
}
else{
puts(error makeBinTree(pReturn-pbinRootNode=NULL));
pReturn=NULL;
}
}
else{
puts(error makeBinTree(pReturn=NULL));
pReturn=NULL;
}
return pReturn;}
binTreeNode* getRootNodeBT(binTree* pBinTree){
binTreeNode* pReturn=NULL;
if(pBinTree!=NULL)
pReturn=pBinTree-pbinRootNode;
return pReturn;
}
binTreeNode* insertLeftChildNodeBT(binTreeNode* pParentNode,binTreeNode element){
binTreeNode* pReturn=NULL;
if(pParentNode!=NULL){
pParentNode-pLeftChild=(binTreeNode*)malloc(sizeof(binTreeNode));
if(pParentNode-pLeftChild!=NULL){
*(pParentNode-pLeftChild)=element;
pParentNode-pLeftChild-pLeftChild=NULL;
pParentNode-pLeftChild-pRightChild=NULL;
pReturn=pParentNode-pLeftChild;
}
else
puts(error insertLeftChildNodeBT(pParentNode-pLeftChild=NULL));}
else
puts(error insertLeftChildNodeBT(pParentNode=NULL));
return pReturn;
}
binTreeNode* insertRightChildNodeBT(binTreeNode* pParentNode,binTreeNode element){
binTreeNode* pReturn=NULL;
if(pParentNode!=NULL){
pParentNode-pRightChild=(binTreeNode*)malloc(sizeof(binTreeNode));
if(pParentNode-pRightChild!=NULL){
*(pParentNode-pLeftChild)=element;
pParentNode-pRightChild-pLeftChild=NULL;
pParentNode-pRightChild-pRightChild=NUChild=NULL;
pReturn=pParentNode-pRightChild;
}
else
puts(error insertRightChildNodeBT(pParentNode-pRightChild=NULL));}
else
puts(error insertRightChildNodeBT(pParentNode=NULL));
return pReturn;
}
binTreeNode* getLeftChildNodeBT(binTreeNode* pNode){
binTreeNode* pReturn=NULL;
if(pNode!=NULL)
pReturn=pNode-pLeftChild;
return pReturn;
}
binTreeNode* getRightChildNodeBT(binTreeNode* pNode){
binTreeNode* pReturn=NULL;
if(pNode!=NULL)
pReturn=pNode-pRightChild;
return pReturn;
}
void deleteBinTreeNode(binTreeNode* pNode){
if(pNode!=NULL){
deleteBinTreeNode(pNode-pLeftChild);
deleteBinTreeNode(pNode-pRightChild);
free(pNode);
}
}
void deleteBinTree(binTree* pBinTree){
if(pBinTree!=NULL){
deleteBinTreeNode(pBinTree-pbinRootNode);
free(pBinTree);
}
}
------------bintreelinkedqueue.c
#include stdio.h
#include stdlib.h
#include string.h
#include bintreelinkedqueue.h
linkedQueue* createLinkedQueue(){
linkedQueue *pReturn=NULL;
pReturn=(linkedQueue*)malloc(sizeof(linkedQueue));
if(pReturn!=NULL){
memset(pReturn,0,sizeof(linkedQueue));
pReturn-pFrontNode=NULL;
pReturn-pRearNode=NULL;
}
else
puts(error creteLinkedQueue(memory erorr));
return pReturn;
}
int enqueueLQ(linkedQueue* pQueue,queueNode element){
int ret=FALSE;
if(pQueue!=NULL){
queueNode *pNode=NULL;
pNode=(queueNode*)malloc(sizeof(queueNode));
if(pNode!=NULL){
*pNode=element;
pNode-pLink=NULL;
if(pQueue-currentElementCount==0){
pQueue-pFrontNode=pNode;
pQueue-pRearNode=pNode;
}
else{
pQueue-pRearNode-pLink=pNode;
pQueue-pRearNode=pNode;
}
pQueue-currentElementCount++;
ret=TRUE;
}
else
puts(erorr enqueueLQ(pNode=NULL, memory erorr));
}
else
puts(erorr enqueueLQ(pQueue=NULL, memory erorr));
return ret;
}
queueNode* dequeueLQ(linkedQueue* pQueue){
queueNode *pReturn=NULL;
if(pQueue!=NULL){
pReturn=pQueue-pFrontNode;
pQueue-pFrontNode=pQueue-pFrontNode-pLink;
pReturn-pLink=NULL;
pQueue-currentElementCount--;
}
else
puts(erorr dequeueLQ(pQueue=NULL));
return pReturn;
}
void deleteLinkedQueue(linkedQueue* pQueue){
queueNode *pNode=NULL,*pDelNode=NULL;
if(pQueue!=NULL){
pNode=pQueue-pFrontNode;
while(pNode!=NULL){
pDelNode=pNode;
pNode=pNode-pLink;
free(pDelNode);
}
free(pQueue);
}
else
puts(erorr deleteLinkedQueue(pQueue=NULL));
}
int isLinkedQueueFull(linkedQueue* pQueue){
int ret=FALSE;
return ret;
}
int isLinkedQueueEmpty(linkedQueue* pQueue){
int ret=FALSE;
if(pQueue!=NULL){
if(pQueue-currentElementCount==0)
ret=TRUE;
}
else
puts(erorr isLinkedQueueEmpty(pQueue=NULL));
return ret;
}------bintreelinkedstack.c
#include bintreelinkedstack.h
#include stdio.h
#include stdlib.h
#include string.h
linkedStack* createLinkedStack(){
linkedStack* pReturn=NULL;
pReturn=(linkedStack*)malloc(sizeof(linkedStack));
if(pReturn!=NULL){
memset(pReturn,0,sizeof(linkedStack));
pReturn-pTopElement=NULL;
}
else
puts(erorr createLinkedstack(pReturn=NULL));
return pReturn;
}
int pushLS(linkedStack* pStack,stackNode element){
int ret=FALSE;
stackNode* pNode=NULL;
if(pStack!=NULL){
pNode=(stackNode*)malloc(sizeof(stackNode));
*(pNode)=element;
pNode-pLink=pStack-pTopElement;
pStack-pTopElement=pNode;
pStack-currentElementCount++;
ret=TRUE;
}
else
puts(error pushLS(pStack=NULL));
return ret;
}
stackNode* popLS(linkedStack* pStack){
stackNode* pReturn=NULL;
if(pStack!=NULL){
if(isLinkedStackEmpty(pStack)==FALSE){
pReturn=pStack-pTopElement;
pStack-pTopElement=pStack-pTopElement-pLink;
pStack-currentElementCount--;
pReturn-pLink=NULL;
}
else
puts(erorr popLS(Linkedstackisempty));
}
return pReturn;}
stackNode* peekLS(linkedStack* pStack){
stackNode* pReturn=NULL;
if(pStack!=NULL){
if(isLinkedStackEmpty(pStack)=FALSE)
pReturn=pStack-pTopElement;
else
puts(error peekLS(Linkedstackisempty));
}
return pReturn;
}
void deleteLinkedStack(linkedStack *pStack){
stackNode *pNode=NULL,*pDelNode=NULL;
if(pStack!=NULL){
pNode=pStack-pTopElement;
while(pNode!=NULL){
pDelNode=pNode;
pNode=pNode-pLink;
free(pDelNode);
}
free(pStack);
}
}
int isLinkedStackEmpty(linkedStack* pStack){
int ret=FALSE;
if(pStack!=NULL){
if(pStack-currentElementCount==0)
ret=TRUE;
}
else
puts(error isLinkedStackEmpty(pStack=NULL));
return ret;
}
int isLinkedStackFull(linkedStack* pStack){
int ret=FALSE;
return ret;
}-------bintreetraversal.c
#include stdio.h
#include stdlib.h
#include bintree.h
#include bintreelinkedstack.h
#include bintreelinkedqueue.h
#include bintreetraversal.c
int 하는중이 였음

신청하기