Sorting a linked list

[Immo]

After looking around for some solutions, I haven't encountered any problems with a Node class as a private member of another class. I've tried fiddling around with the implementation of those solutions in order to make it work with this, but the access specification is what hasn't allowed me to do this yet.

If someone could help me figure out what the function call looks like, I'm sure I'd have no problem of figuring it out from there.

  #include <iostream>
#include <cstdlib>

using std::cout;    using std::cin;     using std::endl;

class LinkedList
{
private:
    struct Node
    {
        int data;
        Node* next;
    };
    Node* curr;
    Node* head;
    Node* temp;
public:
    LinkedList();
    ~LinkedList();
    void appendNode(int);
    void deleteNode(int);
    void insertNode(int);
    void print();
    void reverse();
    int search(int);
    void insertAt(int, int);
    void mergeArray(double [], int);
    void sort();
};

LinkedList::LinkedList()
{
    curr = NULL;
    head = NULL;
    temp = NULL;
}

LinkedList::~LinkedList()
{
    Node *nodePtr;
    Node *nextNode;

    nodePtr = head;

    while (nodePtr != NULL)
    {
        nextNode = nodePtr->next;
        delete nodePtr;
        nodePtr = nextNode;
    }

    head = NULL;
}

void LinkedList::appendNode(int num)
{
    Node* n = new Node;
    n->next = NULL;
    n->data = num;

    if (head != NULL)
    {
        temp = head;
        head = n;
        head->next = temp;

        while (n->next != NULL)
            n = n->next;
    }
    else
    {
        head = n;
    }
}

void LinkedList::deleteNode(int m)
{
    Node* delPtr = NULL;
    temp = head;
    curr = head;

    while (curr != NULL && curr->data != m)
    {
        temp = curr;
        curr = curr->next;
    }

    if (curr == NULL)
    {
        cout << m << " not in the list." << endl;
        delete delPtr;
    }
    else if (curr->data == m)
    {
        delPtr = curr;
        curr = curr->next;
        temp->next = curr;

        delete delPtr;

        cout << "Value " << m << " has been removed from the list." << endl;
    }
}

void LinkedList::insertNode(int num)
{
    Node *n;
    n = new Node;
    n->data = num;

    if (head != NULL)
    {
        n->next = head;
        head = n;
    }
    else
    {
        head = n;
        n->next = NULL;
    }
}

void LinkedList::print()
{
    curr = head;

    while (curr != NULL)
    {
        cout << curr->data << endl;
        curr = curr->next;
    }
}

void LinkedList::reverse()
{
    if (head == NULL)
        return;

    Node *previous = NULL;
    Node *current = NULL;
    Node *next = NULL;

    current = head;

    while(current != NULL)
    {
        next = current->next;
        current->next = previous;
        previous = current;
        current = next;
    }

    head = previous;
}

int LinkedList::search(int num)
{
    int position = 0;
    curr = head;

    while (curr != NULL)
    {
        if (curr->data == num)
            return position;
        else if (curr->next == NULL)
            return -1;
        else
            ++position;

        curr = curr->next;
    }

    return 0;
}

void LinkedList::insertAt(int pos, int num)
{
    Node *prev = new Node;
    Node* curr = new Node;
    Node* newNode = new Node;
    newNode->data = num;

    int tempPos = 0;
    curr = head;

    if(head != NULL)
    {
        while(curr->next != NULL && tempPos != pos)
        {
            prev = curr;
            curr = curr->next;
            tempPos++;
        }
        if(pos==0)      // adds to head
            insertNode(num);
        else if(pos > tempPos+1)    // adds to tail
            appendNode(num);
        else
        {
            prev->next = newNode;
            newNode->next = curr;
            cout << "Node added at position " << pos << endl;
        }
    }
    else
    {
        head = newNode;
        newNode->next=NULL;
        cout << "List is empty." << endl;
    }
}

void LinkedList::mergeArray(double ary[], int sz)
{
    for (int i = 0; i < sz; ++i)
        insertNode(ary[i]);

}

void LinkedList::sort()
{
    // ???
}

int main()
{
    LinkedList list;

    list.appendNode(5);
    list.appendNode(8);
    list.appendNode(13);
    list.appendNode(15);
    cout << "Appending Nodes" << endl <<
            "---------------" << endl;
    list.print();

    cout << endl;

    list.deleteNode(8);

    cout << endl;

    list.insertNode(12);
    list.insertNode(3);

    cout << "Deletion and Insertion" << endl <<
            "----------------------" << endl;
    list.print();

    cout << endl;

    list.reverse();

    cout << "Reverse Print" << endl <<
            "-------------" << endl;
    list.print();

    cout << endl;

    cout << "Number 4 was found at position " << list.search(4) << endl;
    cout << "Number 15 was found at position " << list.search(15) << endl;

    cout << endl;

    list.insertAt(0,16);
    list.insertAt(1, 8);
    list.insertAt(3, 4);
    list.insertAt(12,24);

    cout << endl;
    cout << "Insert At Position" << endl <<
            "------------------" << endl;
    list.print();

    cout << endl;

    const int SIZE = 5;
    double ary[SIZE] = {12.69, 1.49, 9.23, 15.65, 5.42};
                        // 13, 1, 9, 16, 5

    cout << "After Merge Array" << endl <<
            "-----------------" << endl;
    list.mergeArray(ary, SIZE);
    // sort will be called here or inside of mergeArray()
    list.print();
}

[Semoirethe]

What kind of sort are you trying to implement? Selection and bubble sort work pretty much exactly the same as in arrays. Insertion sort is a little bit faster for linked lists since things don't need to be moved over(mainly for doubly linked lists though), and merge sort is slower but in place and still O(nlogn).

Are there any speed constraints or does it just need to end up being sorted?

[Immo]

It just needs to be sorted, really.

I saw one example using a bubble sort method on a list, but it wasn't on a Node class done inside another class, just the Node class itself.

Example being: http://www.geeksforgeeks.org/merge-sort-for-linked-list/

How can I make it work for the way I have it set up?