My last Bool Function

[veasy62]

I do not Understand how to make a function that checks to see if the linked lists are in Ascending order, especially since you can not index in Linked Lists. That is what makes it even harder

Node1.cpp
#include <iostream>
#include <string>
#include <cassert>
#include <cstdlib>
#include "node1.h"

using namespace std;

namespace main_savitch_5
{
	std::size_t list_length(const node* head_ptr)
	{
		const node *cursor;
		size_t answer;
		answer = 0;
		
		for(cursor = head_ptr; cursor != NULL; cursor = cursor ->link())
		{
			++answer;
		}
		return answer;
	}
    void list_head_insert(node*& head_ptr, const node::value_type& entry)
    {
    	head_ptr = new node(entry, head_ptr);
    }
    void list_insert(node* previous_ptr, const node::value_type& entry)
    {
    	node *insert_ptr;

    	insert_ptr = new node;
    	insert_ptr->set_data(entry);
    	insert_ptr->set_link(previous_ptr->link());
    	insert_ptr->set_link(insert_ptr);
    }
    node* list_search(node* head_ptr, const node::value_type& target)
    {
    	node *cursor;

    	for(cursor = head_ptr; cursor != NULL; cursor = cursor ->link())
    	{
    		if(target == cursor->data())
    		{
    			return cursor;
    		}
    	return(NULL);
    	}
    }
    const node* list_search(const node* head_ptr, const node::value_type& target)
    {
    	const node *cursor;

    	for(cursor = head_ptr; cursor != NULL; cursor = cursor->link())
    	{
    		if(target == cursor->data())
    		{
    			return(cursor);
    		}
    	}
    	return(NULL);
    }
    node* list_locate(node* head_ptr, std::size_t position)
    {
    	return(NULL);
    }
    const node* list_locate(const node* head_ptr, std::size_t position)
    {
    	return(NULL);
    }
    void list_head_remove(node*& head_ptr)
    {
    	node *remove_ptr;

    	remove_ptr = head_ptr;
    	head_ptr = head_ptr->link();
    	delete remove_ptr;
    }
    void list_remove(node* previous_ptr)
    {
    	node *remove_ptr;

    	remove_ptr = previous_ptr->link();
    	previous_ptr->set_link(remove_ptr->link());

    }
    void list_clear(node*& head_ptr)
    {
    	while(head_ptr != NULL)
    	{
    		list_head_remove(head_ptr);
    	}
    }
    void list_copy(const node* source_ptr, node*& head_ptr, node*& tail_ptr)
    {
    	head_ptr = NULL;
    	tail_ptr = NULL;

    	if(source_ptr ==NULL)
    	{
    		return;
    	}

    	list_head_insert(head_ptr, source_ptr->data());
    	tail_ptr = head_ptr;

    	source_ptr = source_ptr->link();
    	while(source_ptr != NULL)
    	{
    		list_insert(tail_ptr, source_ptr->data());
    		tail_ptr = tail_ptr->link();
    		source_ptr = source_ptr->link();
    	
       }
    }
//       Precondition: head_ptr is the head pointer of a linked list
//     Precondition: value_type has implemented the operator "<"
//     Postcondition: return value is `true` iff the list items are currently in
//        ascending order.  If there are fewer than two items in the list, return
//        value is `true`.
    bool list_is_ordered(const node* head_ptr)
    {
       int accum;
       while(head_ptr != Null)
          if(head_ptr != head_ptr->link[accum];
             return(false)
          else()
             ++accum
    }

    }
} 

// Node1.h
//   bool list_is_ordered(const node* head_ptr)
//     Precondition: head_ptr is the head pointer of a linked list
//     Precondition: value_type has implemented the operator "<"
//     Postcondition: return value is `true` iff the list items are currently in
//        ascending order.  If there are fewer than two items in the list, return
//        value is `true`.
//     NOTE: The implementation uses the "<" operator for comparing list items.
//
// DYNAMIC MEMORY usage by the toolkit:
//   If there is insufficient dynamic memory, then the following functions throw
//   bad_alloc:
//      - node constructor
//      - list_head_insert
//      - list_insert
//      - list_copy

#ifndef MAIN_SAVITCH_NODE1_H
#define MAIN_SAVITCH_NODE1_H
#include <cstdlib>    // Provides size_t and NULL
#include "Person.h"   // so we can store Person data

namespace main_savitch_5
{
    class node
    {
        public:
        // TYPEDEF
        typedef Person value_type;  // NOTE CHANGE from textbook version

        // CONSTRUCTOR
        node(const value_type& init_data = value_type( ),
             node* init_link = NULL)
        { data_field = init_data; link_field = init_link; }

        // Member functions to set the data and link fields:
            void set_data(const value_type& new_data) { data_field = new_data; }
            void set_link(node* new_link)             { link_field = new_link; }

        // Constant member function to retrieve the current data:
        value_type data( ) const { return data_field; }

        // Two slightly different member functions to retrieve the current link:
        const node* link( ) const { return link_field; }
              node* link( )       { return link_field; }

        private:
            value_type data_field;
            node* link_field;
    };  // end node class

    // FUNCTIONS for the linked list toolkit
    std::size_t list_length(const node* head_ptr);
    void list_head_insert(node*& head_ptr, const node::value_type& entry);
    void list_insert(node* previous_ptr, const node::value_type& entry);
    node* list_search(node* head_ptr, const node::value_type& target);
    const node* list_search(const node* head_ptr, const node::value_type& target);
    node* list_locate(node* head_ptr, std::size_t position);
    const node* list_locate(const node* head_ptr, std::size_t position);
    void list_head_remove(node*& head_ptr);
    void list_remove(node* previous_ptr);
    void list_clear(node*& head_ptr);
    void list_copy(const node* source_ptr, node*& head_ptr, node*& tail_ptr);
    bool list_is_ordered(const node* head_ptr);
}

#endif