/* Perform a destructive quicksort on the items in SLIST, by repeatedly
calling COMPARE with a pair of items from SLIST along with USERDATA
at every iteration. COMPARE is a function as defined above for
slist_sort_merge(). The value of SLIST is undefined after calling
this function.
e.g. slist = slist_sort (slist, compare, 0); */
SList *
slist_sort (SList *slist, SListCompare *compare, void *userdata)
{
SList *left, *right;
if (!slist)
return slist;
/* Be sure that LEFT and RIGHT never contain the same item. */
left = slist;
right = slist->next;
/* Skip two items with RIGHT and one with SLIST, until RIGHT falls off
the end. SLIST must be about half way along. */
while (right && (right = right->next))
{
if (!right || !(right = right->next))
break;
slist = slist->next;
}
right = slist->next;
slist->next = 0;
/* Sort LEFT and RIGHT, then merge the two. */
return slist_sort_merge (slist_sort (left, compare, userdata),
slist_sort (right, compare, userdata),
compare, userdata);
}
void do_test(unsigned int c)
{
unsigned int i;
struct node *p, *n;
SLIST_HEAD(head);
for (i = 0; i < c; ++i) {
p = (struct node*)malloc(sizeof(*p));
if (!p) {
perror("malloc failed");
exit(1);
}
p->data = c - i;
slist_add(&p->slist, &head);
}
slist_for_each_entry(p, &head, slist) printf("%d ", p->data);
printf("\n");
slist_reverse(&head);
slist_for_each_entry(p, &head, slist) printf("%d ", p->data);
printf("\n");
slist_for_each_entry(p, &head, slist) p->data = (size_t)rand()%100;
printf("before sort: ");
slist_for_each_entry(p, &head, slist) printf("%d ", p->data);
printf("\n");
slist_sort(NULL, &head, int_cmp);
printf("after sort: ");
slist_for_each_entry(p, &head, slist) printf("%d ", p->data);
printf("\n");
slist_for_each_entry_safe(p, n, &head, slist) free(p);
}
int main(int argc, char *argv[])
{
SList *l1=NULL, *l2=NULL, *l3=NULL;
int i;
l1 = slist_prepend(l1, 96);
l1 = slist_prepend(l1, 39);
l1 = slist_prepend(l1, 28);
l1 = slist_prepend(l1, 65);
l1 = slist_prepend(l1, 61);
l1 = slist_prepend(l1, 00);
l1 = slist_prepend(l1, 34);
l1 = slist_prepend(l1, 21);
l1 = slist_prepend(l1, 43);
l1 = slist_prepend(l1, 48);
l2 = slist_prepend(l2, 71);
l2 = slist_prepend(l2, 00);
l2 = slist_prepend(l2, 02);
l2 = slist_prepend(l2, 62);
l2 = slist_prepend(l2, 22);
l2 = slist_prepend(l2, 14);
l2 = slist_prepend(l2, 59);
l2 = slist_prepend(l2, 28);
l2 = slist_prepend(l2, 71);
l2 = slist_prepend(l2, 21);
l2 = slist_prepend(l2, 89);
l2 = slist_prepend(l2, 94);
l3 = slist_prepend(l3, 11);
l3 = slist_prepend(l3, 81);
l3 = slist_prepend(l3, 99);
l3 = slist_prepend(l3, 47);
l3 = slist_prepend(l3, 72);
l3 = slist_prepend(l3, 79);
l3 = slist_prepend(l3, 30);
l3 = slist_prepend(l3, 66);
l3 = slist_prepend(l3, 96);
printf("len(l1) = %i\n", slist_length(l1));
printf("len(l2) = %i\n", slist_length(l2));
printf("len(l3) = %i\n", slist_length(l3));
puts("");
printf("l1 = "); printlist(l1);
printf("l2 = "); printlist(l2);
printf("l3 = "); printlist(l3);
puts("");
/* NOTA:
Si tu función concat modifica las listas pasadas (es decir, hace
que el último nodo de la primera apunte al primero de la segunda),
vas a obtener resultados distintos ya que l1 se estaría modificando.
Cambiar el argumento 'l1' por 'clonar(l1)' para que no se
modifique la lista. */
printf("l1 ++ l2 = "); printlist(slist_concat(l1, l2));
printf("l1 ++ [] = "); printlist(slist_concat(l1, NULL));
printf("[] ++ l2 = "); printlist(slist_concat(NULL, l2));
puts("");
/* Si tu intersect cambia las listas, hacer lo mismo explicado para
concat.. */
printf("l1 <inter> l2 = "); printlist(slist_intersect(l1, l2));
printf("l1 <inter> l3 = "); printlist(slist_intersect(l1, l3));
puts("");
// slist_sort(l1,icmpM);
printf("sort(l1) = "); printlist(slist_sort(l1,icmpM));
puts("");
/* NOTA:
Si tu lista quedó ordenada al revés, o no queda ordenada puede ser
por confusiones en como opera la función de comparación. Lo que debe
cumplir la función de comparación es:
icmp(a, b) > 0 si y solo si a > b
icmp(a, b) == 0 si y solo si a == b
icmp(a, b) < 0 si y solo si a < b
Los valores no son necesariamente 1 y -1. */
return 0;
}
