값 목록이 증가합니까?

Question

값 목록을보고 증가 또는 증가하는 경우 true 또는 false를 결정하는 메서드를 작성하려고합니다.

예를 들어 head-() (11) (8)이 포함 된 목록 15) (3), isIncreasing()은 false를 반환해야합니다. 그러나 head-() (7) (9) (15)가 포함 된 목록에서 작업 할 때는 true를 반환합니다.

나는이 문제에 점점 더 좌절감을 느낀다. 그리고 그것은 정말로 나를 곤란하게했다. 누군가가 어떤 코드를 조합 할 수 있다면 그것은 놀라운 일이 될 것입니다. 각 세트의 세트를 살펴보고 싶은 상황에서 항상 문제가 발생합니다.

는 어디서

어떤 도움을 시작 나는 아무 생각이 서명

bool List<Object>::isIncreasing() const; 

거기에서와 방법을 쓰기 시작?

감사 톤

편집 구현

#ifndef LIST_CPP 
#define LIST_CPP 

#include "List.h" 

namespace cs20 { 
template <class Object> 
List<Object>::List() { 
    head = new ListNode<Object>; 
} 

template <class Object> 
List<Object>::List(const List<Object>& rhs) { 
    head = new ListNode<Object>; 
    *this = rhs; 
} 

template <class Object> 
List<Object>::~List() { 
    makeEmpty(); 
    delete head; 
} 

template <class Object> 
bool List<Object>::isEmpty() const { 
    return(head->nextIsNull()); 
} 

template <class Object> 
void List<Object>::makeEmpty() { 
    while (!isEmpty()) { 
     remove(first().retrieve()); 
    } 
} 

template <class Object> 
ListIterator<Object> List<Object>::zeroth() const { 
    return(ListIterator<Object>(head)); 
} 

template <class Object> 
ListIterator<Object> List<Object>::first() const { 
    return(ListIterator<Object>(head->getNext())); 
} 

template <class Object> 
void List<Object>::insert(const Object& data, 
          const ListIterator<Object> &iter) { 
    if (iter.isValid()) { 
     ListNode<Object>* newnode = new ListNode<Object>(data, iter.current->getNext()); 
     iter.current->setNext(newnode); 
    } 
} 

template <class Object> 
void List<Object>::insert(const Object& data) { 
    // insert after the header node 
    ListNode<Object>* newnode = new ListNode<Object>(data, head->getNext()); 
    head->setNext(newnode); 
} 

template <class Object> 
ListIterator<Object> List<Object>::findPrevious(const Object& data) const { 
    ListNode<Object>* node = head; 
    while(node->getNext() != NULL && node->getNext()->getElement() != data) { 
     node = node->getNext(); 
    } 
    if (node->getNext() == NULL) { 
     node = NULL; 
    } 
    return ListIterator<Object>(node); 
} 


template <class Object> 
bool List<Object>::isIncreasing() const { 


    } 

template <class Object> 
void List<Object>::insert_back(const Object& data) { 
    ListNode<Object>* newnode = new ListNode<Object>(data, NULL); 
    ListNode<Object>* lastNode = head; 
    while (lastNode->getNext()!= NULL && lastNode->getNext()->getElement() != data) 
     lastNode = lastNode->getNext(); 
    lastNode->setNext(newnode); 

} 

template <class Object> 
void List<Object>::remove(const Object& data) { 
    ListIterator<Object> iter = findPrevious(data); 
    if (iter.isValid()) { 
     ListNode<Object>* node = findPrevious(data).current; 
     if (node->getNext() != NULL) { 
      ListNode<Object> *oldNode = node->getNext(); 
      node->setNext(node->getNext()->getNext()); // Skip oldNode 
      delete oldNode; 
     } 
    } 
} 

// Deep copy of linked list 
template <class Object> 
const List<Object>& List<Object>::operator =(const List<Object>& rhs) { 
    if (this != &rhs) { 
     makeEmpty(); 

     ListIterator<Object> rightiter = rhs.first(); 
     ListIterator<Object> myiterator = zeroth(); 
     while(rightiter.isValid()) { 
      insert(rightiter.retrieve(), myiterator); 
      rightiter.advance(); 
      myiterator.advance(); 
     } 
    } 
    return(*this); 
} 

} 

#endif 

편집이 아래 isIncreasing가 작동하는 방법의 "출력은"

TESTING 팁 :

실행 메소드 : insert (3); 삽입 (2); 삽입 (1); 목록을 인쇄하십시오. 어떻게 생겼을 까? 전화 : isIncreasing(); 무엇을 반환해야합니까? 목록을 인쇄하십시오. 어떻게 생겼을 까? 메소드를 실행하십시오. remove (3); 제거 (2); 목록을 인쇄하십시오. 어떻게 생겼을 까? 전화 : isIncreasing(); 무엇을 반환해야합니까? 목록을 인쇄하십시오. 어떻게 생겼을 까? 메소드를 실행하십시오. remove (1); 메소드를 실행하십시오. insert (7); 삽입 (9); 삽입 부 (11); 목록을 인쇄하십시오. 어떻게 생겼을 까? 전화 : isIncreasing(); 무엇을 반환해야합니까? 목록을 인쇄하십시오. 어떻게 생겼을 까?

Answer 1

뭔가 (테스트하지)이 같은 다음의 의사 코드 같은 약 :

template <class Object> 
bool List<Object>::isIncreasing() const 
{ 
    ListNode<Object>* node= head; 
    while (node->getNext() != NULL) 
    { 
     // Check if the next element is smaller (or the same as)... if so return false. 
     if (node->getNext()->getElement() <= node->getElement()) 
      return false; 
     node = node->getNext(); 
    } 
    // If we get here then all values are increasing 
    return true; 
} 

Answer 2

어떻게

int last_value = std::numeric_limits<int>::min(); 

for (current_node = list_head; current_node != nullptr; current_node = current_node->next) 
{ 
    if (current_node->value > last_value) 
    { 
     last_value = current_node->value; 
    } 
    else 
    { 
     return false; 
    } 
} 

return true; 

Answer 3

또 다른 의사 코드의 가능성 :

node = GetHead(); 
while(node != End()) 
{ 
    nodeBefore = node++; 
    if(node != End() && 
     *nodeBefore >= *node) 
    { 
     break; 
    } 
} 

if(Size() > 0 && node == End()) 
{ 
    bIsAscending = true; 
}