Pookdaddy G fucked around with this message at 05:31 on Dec 12, 2008

Avenging Dentist fucked around with this message at 09:14 on Dec 12, 2008

void quickSort(list<T> &input)
{
    if(input.size() < 2)
        return;

    T pivot = input.front(); input.pop_front();
    // Partition into 2 lists using pivot value
    // ...

    // Recurse
    quickSort(newList1);
    quickSort(newList2);

    // Merge two lists and pivot back into input
    // ...
}

newsomnuke fucked around with this message at 16:43 on Dec 12, 2008

void quicksort(SinglyLL<T> & A, bool (* needSwap)(T &, T &))
{
    SinglyLL<T> befList;
    SinglyLL<T> piv;
    SinglyLL<T> aftList;

// ...

    typename SinglyLL<T>::iterator itr = piv.begin();
    typename SinglyLL<T>::iterator itr2;
    typename SinglyLL<T>::iterator itr3;

    for (itr2 = A.begin(); itr2 != A.end(); ++itr2)
    {
       if ((*needSwap)(*itr, *itr2))
       // ...
     }

     itr2 = befList.begin();
     itr3 = aftList.begin();
	
     quicksort(befList, needSwap(*itr,*itr2));
     quicksort(aftList, needSwap(*itr3,*itr));
}

quicksort(list3, needSwap2);

bool needSwap2(vector<string>* & vec1, vector<string>* & vec2)

Whilst farting I fucked around with this message at 21:35 on Dec 12, 2008

floWenoL fucked around with this message at 22:35 on Dec 12, 2008

template <typename T>
void SinglyLL<T>::appendandclear(SinglyLL<T> & y)
{	
	// Checks to make sure an empty list isn't being appended
	if (!y.empty())
	{
		// Holding variable for the head in case it needs to be reset
		Node *tempHeadNode = head;
		bool notEmpty = false;

		cout << "Size of current list is " << size() << " and size of y is " << y.size() << endl;
		
		// If the original list to which we're appending is not empty to begin 
                // with, flag it as such so we know to restore the head
		if (!empty())
			notEmpty = true;

		// Sets the tail to be equal to 0 so the first item pushed in 
                // becomes the tail
		tail = 0;

		// Pushes each item from one list onto the other
                for (int i = 0; i < y.size(); i++)
                   y.pop_front_push_front_elsewhere(*this);

                // If the list wasn't empty when passed in, restore the head
                if (notEmpty)
                   head = tempHeadNode;
	}
}

// Pops the front node off of the current list and pushes it to the front of list y
template <typename T>
void SinglyLL<T>::pop_front_push_front_elsewhere(SinglyLL<T> & y)
{
    // Check to make sure there is something to pop
    if (!empty())
    {
        // Creates new nodes and T values for storage of the head's
        // information
        Node *popped = head;
        T poppedVal = head->value;

        // If there's only one element left in the list, it's going to be popped off,
	// so make the list empty (the entirety of the empty function is 
        // { return head == 0; }
        if (oneElement())
           head = 0;

        // Otherwise, there is a next node, so set the head equal to that
        else
           head = head->next;

        // Pushes the head of the first list onto the second list
        y.push_front(poppedVal);

        // Deletes the head node - "pops" it
        delete popped;
    }
}

template <typename T>
void SinglyLL<T>::push_front(const T & x)
{
    Node *p = new Node;

    p->value = x;
    p->next = head;
    head = p;

    if (tail == 0)
        tail = head;
}

Whilst farting I fucked around with this message at 04:14 on Dec 14, 2008

Jo fucked around with this message at 05:42 on Dec 14, 2008