코딩 공부 일기

접기

#include "stdafx.h"

#include "QueueUsingArray.h"

 

 

QueueUsingArray::QueueUsingArray()

{

        Init();

}

 

 

QueueUsingArray::~QueueUsingArray()

{

}

 

//초기화

void QueueUsingArray::Init(void)

{

        m_Front = 0;

        m_Rear = 0;

}

 

//데이터 삽입

void QueueUsingArray::Put(int data)

{

        //Rear의 다음 위치 계산

        int nextIndex = (m_Rear + 1) % SIZE;

 

        //다음 위치가 Front위치라면 입력 중단->큐가 꽉찬 상태

        if (nextIndex == m_Front)

               return;

 

        //현재 Rear위치에 데이터 입력

        m_Queue[m_Rear] = data;

 

        //Rear를 다음 칸으로 이동

        m_Rear = nextIndex;

}

 

//데이터 추출

int QueueUsingArray::Get(void)

{

        //Front와 Rear가 같은 위치라면 -> 데이터가 없는 상태

        if(m_Front == m_Rear)

               return -99999;

 

        //데이터 저장

        int result = m_Queue[m_Front];

 

        //Front를 한칸 뒤로 이동

        m_Front = (m_Front + 1) % SIZE;

 

        return result;

}

 

//출력

void QueueUsingArray::Print(void)

{

        int index = m_Front;

        printf("FRONT->");    

        while (index != m_Rear)

        {

               printf(" %d ->", m_Queue[index]);

 

               index = (index + 1) % SIZE;

        }

 

        printf("REAR\n");

}

접기

접기

#include "stdafx.h"

#include "Stack.h"

 

 

Stack::Stack()

{

        m_top = new NODE();

        m_bottom = new NODE();

 

        m_top->Next = m_bottom;

        m_bottom->Next = m_bottom;

}

 

 

Stack::~Stack()

{

}

 

void Stack::Push(int data)

{

        //새 노드 생성 및 데이터 입력

        NODE *newNode = new NODE();

        newNode->Data = data;

       

        //새 노드의 Next로 현재 제일 앞에 있는 노드를 지정

        newNode->Next = m_top->Next;

 

        //현재 노드를 제일 앞 노드로 지정

        m_top->Next = newNode;

}

 

int Stack::Pop(void)

{

        //첫 노드가 마지막 노드(m_bottom : 빈노드)면 데이터가 없음

        if (m_top->Next == m_bottom)

               return NULL;

 

        //첫번째 노드 데이터 수령

        NODE *deleteNode = m_top->Next;

        int result = deleteNode->Data;

 

        //2번째 노드를 첫번째 노드로

        m_top->Next = m_top->Next->Next;

 

        //첫번째 노드 삭제

        delete deleteNode;

        deleteNode = NULL;

       

        //결과 반환

        return result;

}

 

void Stack::Print(void)

{

        NODE* indexNode = m_top->Next;

 

        printf("\nPrint : ");

        for (indexNode; indexNode != m_bottom; indexNode = indexNode->Next)

        {

               printf("%d ", indexNode->Data);

        }

        printf("\n\n");

}

접기

접기

#include "stdafx.h"

 

template<typename T>

class tStack

{

private:

        typedef struct _Node

        {

               T Data;

               struct _Node* Next;

 

               _Node()

               {

                       Data = NULL;

                       Next = NULL;

               }

 

               _Node(T data)

               {

                       Data = data;

                       Next = NULL;

               }

        } NODE;

 

private:

        NODE *m_top, *m_bottom;

 

public:

        tStack()

        {

               m_top = new NODE();

               m_bottom = new NODE();

 

               Init();

        }

 

        ~tStack()

        {

               Clear();

 

               delete m_top;

               delete m_bottom;

 

               m_top = NULL;

               m_bottom = NULL;

        }

 

        //스택 비우기

        void Clear(void)

        {

               //비어 있으면 동작 안함

               if (IsEmpty())

                       return;

 

               NODE* indexNode = m_top->Next;

               for (indexNode; indexNode != m_bottom;)

               {

                       NODE* deleteNode = indexNode;

                       indexNode = indexNode->Next;

 

                       delete deleteNode;

                       deleteNode = NULL;

               }

 

               Init();

        }

 

        //입력

        void Push(T data)

        {

               //새 노드 생성 및 데이터 입력

               NODE *newNode = new NODE(data);

 

               //새 노드의 Next로 현재 제일 앞에 있는 노드를 지정

               newNode->Next = m_top->Next;

 

               //현재 노드를 제일 앞 노드로 지정

               m_top->Next = newNode;

        }

 

        //출력

        T Pop(void)

        {

               //첫 노드가 마지막 노드(m_bottom : 빈노드)면 데이터가 없음

               if (IsEmpty())

                       return NULL;

 

               //첫번째 노드 데이터 수령

               NODE *deleteNode = m_top->Next;

               T result = deleteNode->Data;

 

               //2번째 노드를 첫번째 노드로

               m_top->Next = m_top->Next->Next;

 

               //첫번째 노드 삭제

               delete deleteNode;

               deleteNode = NULL;     

 

               //결과 반환

               return result;

        }

 

        //비었는지 확인

        bool IsEmpty(void)

        {

               //첫 노드가 마지막 노드(m_bottom : 빈노드)면 데이터가 없음

               if (m_top->Next == m_bottom)

                       return true;

               else

                       return false;

        }

 

private:

        //초기화

        void Init(void)

        {

               m_top->Next = m_bottom;

               m_bottom->Next = m_bottom;

        }

};

접기

접기

void DoublyLinkedList::Delete(char data)

{

        //최초 검색 노드를 헤더의 Next로 설정

        NODE* deleteNode = m_head->Next;

 

        //현재 노드의  데이터가, 입력받은 데이터와 같다면 반복중단

        for (deleteNode; deleteNode != m_end; deleteNode = deleteNode->Next)

        {

               if (deleteNode->Data == data)

                       break;

        }

 

        //현재 리스트에 입력받은 데이터가 없다면 함수 중단

        if (deleteNode == m_end)

               return;

 

        //삭제할 노드의 전/후 노드 연결

        deleteNode->Next->Prev = deleteNode->Prev;

        deleteNode->Prev->Next = deleteNode->Next;

 

        //노드 삭제

        delete(deleteNode);

}

접기

접기

class DoublyLinkedList

{

private:

        typedef struct _Node {

               char Data;

               struct _Node *Next;

               struct _Node *Prev;

        }NODE;

 

private:

        NODE *m_head, *m_end;

 

public:

        DoublyLinkedList();

        ~DoublyLinkedList();  

 

        void Insert(char data);

        void Delete(char data);

        void Print();

};

접기

접기

#include "stdafx.h"

#include "DoublyLinkedList.h"

 

 

DoublyLinkedList::DoublyLinkedList()

{

        //초기화

        m_head = new NODE();

        m_end = new NODE();

 

        //헤드 세팅

        m_head->Prev = NULL;

        m_head->Next = m_end;

 

        //엔드 세팅

        m_end->Prev = m_head;

        m_end->Next = m_end;

}

 

 

DoublyLinkedList::~DoublyLinkedList()

{

}

 

void DoublyLinkedList::Insert(char data)

{

        // 최초 검색 노드를 헤더로 설정

        NODE* indexNode = m_head;

 

        //현재 노드의 NEXT가 end노드면 반복문 중단

        for (indexNode; indexNode->Next != m_end; indexNode = indexNode->Next)

        {

               if (indexNode->Next->Data > data)

                       break;

        }

 

        //##중복된 데이터 삽입 금지##

        if (indexNode->Data == data)

               return;

 

        //새로운 노드 생성

        NODE* newNode = new NODE();

 

        //새 노드에 데이터 저장

        newNode->Data = data;

        newNode->Prev = indexNode;

        newNode->Next = indexNode->Next;

 

        //현재 노드의 Next와 Next의 Prev로 새 노드를 할당

        indexNode->Next->Prev = newNode;

        indexNode->Next = newNode;

}

 

void DoublyLinkedList::Delete(char data)

{

        //최초 검색 노드를 헤더의 Next로 설정

        NODE* deleteNode = m_head->Next;

 

        //현재 노드의  데이터가, 입력받은 데이터와 같다면 반복중단

        for (deleteNode; deleteNode != m_end; deleteNode = deleteNode->Next)

        {

               if (deleteNode->Data == data)

                       break;

        }

 

        //현재 리스트에 입력받은 데이터가 없다면 함수 중단

        if (deleteNode == m_end)

               return;

 

        //삭제할 노드의 전/후 노드 연결

        deleteNode->Next->Prev = deleteNode->Prev;

        deleteNode->Prev->Next = deleteNode->Next;

 

        //노드 삭제

        delete(deleteNode);

}

 

void DoublyLinkedList::Print()

{

        NODE* indexNode = m_head->Next;

 

        for (indexNode; indexNode != m_end; indexNode = indexNode->Next)

        {

               printf("%c ", indexNode->Data);

        }

        printf("\n");

}

접기