I am kind of hitting a wall on this problem and I was wondering if some fresh brains could help me out.
I have a large list of four element tuples in the format:
(ID number, Type, Start Index, End Index) 
Previously in the code, I have searched through thousands of blocks of text for two specific types of substrings. These tuples store in which large chunk of text the substring was found, which of the two types of substrings it is, and the start and end index of this substring.
The final goal is to look through this list to find all instances where a type 1 substring occurs before a type 2 substring in a block of text with the same ID. Then I would like to store these objects in the format (ID, Type 1, Start, End, Type2, Start, End).
I've tried to mess around with a bunch of stuff that was super inefficient. I have the list sorted by ID then Start Index, and if been trying varying ways of popping the items off the list for comparisons. I have to imagine there is a more elegant solution. Any brilliant people out there wish to assist my tired brain???
Thanks in advance
I don't know how many types you have.  But If we assume you have only type 1 and type 2, then it sounds like a problem similar to a merge sort.  Doing it with a merge sort, you make a single pass through the list. 
Take two indexes, one for type 1 and one for type 2 (I1, I2).  Sort the list by id, start1.  Start I1 as the first instance of type1, and I2 as zero.  If I1.id < I2.Id then increment I1.  If I2.id < I1.id then increment I2.   If I1.id = I2.id then check iStart. 
I1 can only stop on a type one record and I2 can only stop on a type 2 record.  Keep incrementing the index till it lands on an appropriate record.
You can make some assumptions to make this faster.  When you find an block that succeeds, you can move I1 to the next block.  Whenever I2 < I1, you can start I2 at I1 + 1 (WOOPS MAKE SURE YOU DONT DO THIS, BECAUSE YOU WOULD MISS THE FAILURE CASE!)  Whenever you detect an obvious failure case, move I1 and I2 to the next block (on appropriate recs of course).
Efficient Tuple List Comparisons