이중 연결 목록을 사용하는 C++ 스택

Question

이중 연결 목록을 사용하여 스택을 구현하려고합니다. 내 스택 클래스 (push, pop) 함수는 이중 링크 목록 클래스의 멤버 함수에 대한 호출을 포함해야하지만 실제로 구현하는 데 문제가 있다는 것을 알고 있습니다.

dlist.cpp :

#include <iostream> 
#include <fstream> 
#include <string> 
#include "dlist.hpp" 

using namespace std; 

void dlist::appendNodeFront(int shares, float pps){ 
    Node *n = new Node(shares, pps); 
    if(front == NULL){ 
    front = n; 
    back = n; 
    } 
    else { 
    front->prev = n; 
    n->next = front; 
    front = n; 
    } 
} 

void dlist::appendNodeBack(int shares, float pps){ 
    Node *n = new Node(shares, pps); 
    if(back == NULL){ 
    front = n; 
    back = n; 
    } 
    else { 
    back->next = n; 
    n->prev = back; 
    back = n; 
    } 
} 

void dlist::display(){ 
    Node *temp = front; 
    cout << "List contents: "; 
    while(temp != NULL){ 
    cout << temp->value << " "; 
    temp = temp->next; 
    } 
    cout << endl; 
} 

void dlist::display_reverse(){ 
    Node *temp = back; 
    cout << "List contents in reverse: "; 
    while(temp != NULL){ 
    cout << temp->value << " "; 
    temp = temp->prev; 
    } 
    cout << endl; 
} 

void dlist::destroyList(){ 
    Node *T = back; 
    while(T != NULL){ 
    Node *T2 = T; 
    T = T->prev; 
    delete T2; 
    } 
    front = NULL; 
    back = NULL; 
} 

stack.cpp :

이

#include <iostream> 
#include <fstream> 
#include <string> 
#include "stack.hpp" 

using namespace std; 

stack::stack(){ 
    int i; 
    for(i = 0; i < 1500; i++){ 
    shares[i] = 0; 
    pps[i] = 0; 
    } 
    first = 0; 
} 

void stack::push(int num, float price){ 
    if(first ==(1500-1)){ 
    cout << "Stack is full" << endl; 
    return; 
    } 
    first++; 
    shares[first] = num; 
    pps[first] = price; 

    return; 
} 

void stack::pop(int *num, float *price){ 
    if(first == -1){ 
    cout << "Stack is empty" << endl; 
    return; 
    } 

    num = &shares[first]; 
    price = &pps[first]; 

    cout << shares[first] << endl; 
    cout << pps[first] << endl; 
    shares[first] = 0; 
    pps[first] = 0; 
    first--; 
    return; 
} 

스택에 푸시 기능은 기본적으로 appendNodeFront() 또는 appendNodeback()를 호출해야 하는가? 어떤 도움이나 조언을 크게 주시면 감사하겠습니다!

Answer 1

스택 클래스를 만든 다음 연결된 목록 클래스를 해당 컨테이너로 사용할 수 있습니다. 연결된 목록 클래스에는 항목 수에 거의 제한이 없으므로 인위적인 제한을 추가하여 스택처럼 작동하게 만듭니다. 연결된 목록에서 항목을 목록의 아무 곳에서나 추가/제거 할 수 있습니다. 꼬리 노드를 추가/제거하는 것만 제한하여 스택처럼 작동하도록 할 수 있습니다. 아래 예제는 사용법을 보여줍니다.

노드는 순전히 프로그래밍 연습입니다. 스택은 이중 링크 목록과 비교하여 상대적으로 원시적입니다. 스택 내부의 링크 된 목록을 캡슐화하는 것은 이점이 없습니다. 또한, 나는이 문제를 단순화하기 위해 public 모든 멤버를 선언 참고, 당신은, 스택의 끝에 요소를 추가한다 protected/private

#include <iostream> 
#include <fstream> 
#include <string> 

using std::cout; 

class Node 
{ 
public: 
    Node *prev; 
    Node *next; 
    int shares; 
    float pps; 
    Node(int vshares, float vpps) 
    { 
     shares = vshares; 
     pps = vpps; 
     prev = next = nullptr; 
    } 
}; 

class dlist 
{ 
public: 
    Node *head; 
    Node *tail; 

    dlist() 
    { 
     head = tail = nullptr; 
    } 
    ~dlist() 
    { 
     destroy(); 
    } 

    void push_back(int shares, float pps) 
    { 
     Node *node = new Node(shares, pps); 
     if (head == NULL) 
     { 
      head = tail = node; 
     } 
     else 
     { 
      tail->next = node; 
      node->prev = tail; 
      tail = node; 
     } 
    } 

    void destroy() 
    { 
     Node *walk = head; 
     while (walk) 
     { 
      Node *node = walk; 
      walk = walk->next; 
      delete node; 
     } 
     head = tail = nullptr; 
    } 
}; 

class stack 
{ 
public: 
    int maxsize; 
    int count; 
    dlist list; 
    stack(int size) 
    { 
     count = 0; 
     maxsize = size; 
    } 

    void push(int num, float price) 
    { 
     if (count < maxsize) 
     { 
      list.push_back(num, price); 
      count++; 
     } 
    } 

    void pop() 
    { 
     Node *tail = list.tail; 
     if (!tail) 
     { 
      //already empty 
      return; 
     } 

     if (tail == list.head) 
     { 
      //only one element in the list 
      delete tail; 
      list.head = list.tail = nullptr; 
      count--; 
     } 
     else 
     { 
      Node *temp = list.tail->prev; 
      delete list.tail; 
      list.tail = temp; 
      list.tail->next = nullptr; 
      count--; 
     } 
    } 

    void display() 
    { 
     Node *walk = list.head; 
     while (walk) 
     { 
      cout << "(" << walk->shares << "," << walk->pps << ") "; 
      walk = walk->next; 
     } 
     cout << "\n"; 
    } 
}; 

int main() 
{ 
    stack s(3); 
    s.push(101, 0.25f); 
    s.push(102, 0.25f); 
    s.push(103, 0.25f); 
    s.push(104, 0.25f); 
    s.display(); 
    s.pop(); 
    s.display(); 
    return 0; 
}