List Sort, Table Sort, Sorting Algorithm
Analysis, Hashing Techniques
Mrudang Mehta
List Sorts
When sorting lists with large records, it is
necessary to modify the sorting methods so as to
minimize data movement. ( data movement slows
down the sorting process)
Iterative sort, Merge sort can be modified with the
linked list instead of sequential list
Each record will require an additional link field. So,
Instead of physically moving the record, we
change its link field to reflect the change in the
position of the record in the list.
Rearranging records using
Doubly Linked List
If F is sorted list, then first pointer points to the first record
(node) of the sorted list. All other elements linked to it are
greater or equal to it.
k1
k2
k3
K1<= k2 <= k3 <=kn-1<=kn
kn
void list1(Element *list, const int n, int first)
{// rearrange the sorted chain first so that the records list[1]list[n] are in sorted order.
int prev=0;
for(int current=first; current; current=list[current].linka)
{
//convert chain into doubly list
list[current].linkb=prev;
prev=current;
}
for(int i=1; i<n; i++)// move listfirst to position i while maintaining list
{
if(first !=i){
if(list[i].linka) list[list[i].linka].linkb= first;
list[list[i].linkb].linka=first;
Element a=list[first]; list[first]=list[i]; list[i]=a;
}
first = list[i].linka;
}
}
Example
(a) Linked list of following a List Sort, first=4
(b) Corresponding doubly linked list, first=4
(c) Configuration after first iteration of the for loop of List 1, first=2
(d) Configuration after second iteration, first=6
(e) Configuration after third iteration, first=8
(f) Configuration after forth iteration, first=10
Rearranging Records Using Only
One Link Fields
void List2(Element *list, const int n, int first)
{ // Same function as List1 except that a second link array linkb is not required.
for (int i = 1; i < n; i++)
{// Find correct record to place into ith position. Its index is i as
// records in positions 1, 2, , i 1 are already correctly positioned.
while (first < i) first = list[first].linka;
int q = list[first].linka; // listq is next record in sorted order
if (first != i)
{ // interchange listi and listfirst moving listfirst to its correct spot as
// listfirst has ith smallest key. Also set link from old position of listi to new one
Element t = list[i];
list[i]= list[first]; list[first]=t; list[i].linka = first;
}
first = q;
}
}
Example
(a) Configuration after first iteration of the for loop of List2, first=2
(b) Configuration after second iteration, first=6
(c) Configuration after third iteration, first=8
(d) Configuration after forth iteration, first=10
(e) Configuration after fifth iteration, first=1
Table Sort
The list sort technique is not well suited for quick sort and
heap sort
We can use auxiliary table
At the start of the sort, t[i] i,1 i .nIf the sorting function
requires a swap of a[i] and a[j], then only the table entries
(i.e., t[i] and t[j]) need to be swapped.
At the end of sort, the record with the smallest key is a[t[1]]
and that with the largest key a[t[n]]
Table Sort Program
template <class T>
void Table(T *a, const int n, int *t)
{ // Rearrange a[1:n] to correspond to the sequence a[t[1]], , a[t[1]], n 1.
for (int i = 1; i < n; i++)
if (t[i] != i) { // there is a non-trivial cycle starting at i
T p = a[i];
int j = i;
do {
int k = t[j]; a[j] = a[k]; t[j] = j;
j = k;
} while (t[j] != i)
a[j] = p; // j is position for record p
t[j] = j;
}
}
13
Table Sort Example
(a) Initial configuration
(b) Configuration after rearrangement of first cycle
(c) Configuration after rearrangement of second cycle
14
Summary of Internal Sorting
Comparison of sort methods
Method
Insertion Sort
Heap Sort
Merge Sort
Quick Sort
15
Worst
Average
Average Times for Sort Methods
Times are in milliseconds
Plot of Average Times (milliseconds)
5
Insertion Sort
Heap Sort
Merge Sort
Quick Sort
0
0
500
1000
2000
3000
4000
5000
