코딩 공부 일기

#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");

}

        typedef struct _Node

        {

               char Data;             //데이터

               struct _Node *Next;    //다음 노드

        } NODE;

void LinkedList::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 = (NODE*)malloc(sizeof(NODE));

        //새 노드에 데이터 저장

        newNode->Data = data;

        newNode->Next = indexNode->Next;

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

        indexNode->Next = newNode;

}

void LinkedList::Delete(char data)

{

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

        NODE* indexNode = m_head;

        NODE* deleteNode = NULL;

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

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

        {

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

               {

                       deleteNode = indexNode->Next;

                       break;

               }

        }

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

        if (deleteNode == NULL)

               return;

        indexNode->Next = deleteNode->Next;

//매모리 할당 해제 <= malloc으로 매모리를 할당 했으니 free 이용

        free(deleteNode);

}

class LinkedList

{

private:

        typedef struct _Node

        {

               char Data;

               struct _Node *Next;

        } NODE;

private:

        NODE *m_head, *m_end;

public:

        LinkedList();

        ~LinkedList();

        void Insert(char data);

        void Delete(char data);

        void Print();

};

#include "stdafx.h"

#include "LinkedList.h"

LinkedList::LinkedList()

{

        m_head = (NODE*)malloc(sizeof(NODE));

        m_end = (NODE*)malloc(sizeof(NODE));

        m_head->Next = m_end;

        m_end->Next = m_end;

}

LinkedList::~LinkedList()

{

}

void LinkedList::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 = (NODE*)malloc(sizeof(NODE));

        //새 노드에 데이터 저장

        newNode->Data = data;

        newNode->Next = indexNode->Next;

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

        indexNode->Next = newNode;

}

void LinkedList::Delete(char data)

{

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

        NODE* indexNode = m_head;

        NODE* deleteNode = NULL;

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

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

        {

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

               {

                       deleteNode = indexNode->Next;

                       break;

               }

        }

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

        if (deleteNode == NULL)

               return;

        indexNode->Next = deleteNode->Next;

        free(deleteNode);

}

void LinkedList::Print()

{

        for (NODE *node = m_head->Next; node != m_end; node = node->Next)

        {

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

        }

        printf("\n");

}