/*
* Sort <list> using comparison function <cmp>.
*/
void listSort(List *list, int(*cmp)(const void *, const void *))
{
ListNode *l, *r; /* Current node in l(eft) and r(ight) list. */
List left; /* Left list (<list> is used as the right list). */
int i, len = listLength(list);
/* This is a standard Merge Sort... */
if (len <= 1) return; /* A list with 1 element is already sorted. */
/* Split <list> in two at (or near) the halfway point. */
left.length = len / 2;
list->length -= left.length;
l = listHead(list);
for (i = 0; i < left.length; i++) {
l->list = &left;
l = l->next;
}
left.head = list->head;
left.tail = l->prev;
list->head = l;
l->prev->next = NULL;
l->prev = NULL;
/* At this point <left> is a valid list containing the left half of the
* original <list>, and <list> contains the right half. Call myself
* recursively to sort these two lists. */
listSort(&left, cmp);
listSort(list, cmp);
/* OK, so <left> and <list> are now both sorted. Now pick elements from
* <left> and merge them into <list>. */
l = listHead(&left);
r = listHead(list);
/* As long as we still have an element from <left>... */
while (l) {
/* If we reached the end of <list> *or* <l> should be left of <r>... */
if (r == NULL || cmp(l, r) <= 0) {
f_listRemove(&left, l); /* Remove <l> from <left>... */
f_listInsert(list, l, r); /* Put <l> into <list>, before <r>. */
l = listHead(&left); /* Get the next <l>. */
}
else {
r = f_listNext(r); /* Move onto the next <r>. */
}
}
}
//3. 用递归来sort整个list
Node listSort(Node head) {
Node sorted, l1, l2, item, tem;
if(head->next == NULL) {
return head;
}
else {
//分半
l1 = head;
tem = findMid(head);
l2 = tem->next;
tem->next = NULL;
//sort每半
l1 = listSort(l1);
l2 = listSort(l2);
//merge两半
sorted = mergeSortedList(l1,l2);
return sorted;
}
}
int main() {
Node head = nodeCreate(1);
printf("1. head is %d\n\n\n\n", head->num);
printf("2. The list and the linked list is now:\n");
int array[] = {4, 3, 2, 7, 2, 6, 5, 9, 5, 6, 0, 6, 11, 6};
for(int i = 0; i < 14; i++) {
head = listAppend(head, array[i]);
}
Node item = head;
while(item->next != NULL) {
printf("%d ", item->num);
item = item->next;
}
printf("%d\n\n\n\n", item->num);
printf("3. Now we are testing listSort() function.\n");
Node sorted;
sorted = listSort(head);
printf("The list after sorting is:");
item = sorted;
while(item->next != NULL) {
printf("%d ", item->num);
item = item->next;
}
printf("%d\n\n\n\n", item->num);
printf("4. Now we are testing deleting the duplicated element.\n");
Node headFin = removeDup(sorted);
item = headFin;
while(item->next != NULL) {
printf("%d ", item->num);
item = item->next;
}
printf("%d\n", item->num);
return 0;
}
int main(int argc, char *argv[])
{
List list;
Data *data[6];
int i, errors = 0;
for (i = 0; i < 6; i++) {
data[i] = calloc(1, sizeof(Data));
}
listInitialize(&list);
TEST_INT(listLength(&list), 0);
TEST_INT(listIsEmpty(&list), TRUE);
listAppendTail(&list, data[0]);
listAppendTail(&list, data[1]);
listAppendTail(&list, data[2]);
listAppendTail(&list, data[3]);
TEST_INT(listLength(&list), 4);
TEST_INT(listIsEmpty(&list), FALSE);
TEST_PTR(listHead(&list), data[0]);
TEST_PTR(listTail(&list), data[3]);
TEST_PTR(listNext(data[0]), data[1]);
TEST_PTR(listNext(data[1]), data[2]);
TEST_PTR(listNext(data[2]), data[3]);
TEST_PTR(listNext(data[3]), NULL);
TEST_PTR(listPrev(data[3]), data[2]);
TEST_PTR(listPrev(data[2]), data[1]);
TEST_PTR(listPrev(data[1]), data[0]);
TEST_PTR(listPrev(data[0]), NULL);
TEST_PTR(listContaining(data[0]), &list);
TEST_PTR(listContaining(data[1]), &list);
TEST_PTR(listContaining(data[2]), &list);
TEST_PTR(listContaining(data[3]), &list);
listRemove(&list, data[0]);
listRemove(&list, data[1]);
listRemove(&list, data[2]);
listRemove(&list, data[3]);
TEST_INT(listLength(&list), 0);
TEST_INT(listIsEmpty(&list), TRUE);
TEST_PTR(listContaining(data[0]), NULL);
TEST_PTR(listContaining(data[1]), NULL);
TEST_PTR(listContaining(data[2]), NULL);
TEST_PTR(listContaining(data[3]), NULL);
listInsertHead(&list, data[3]);
listInsertHead(&list, data[2]);
listInsertHead(&list, data[1]);
listInsertHead(&list, data[0]);
TEST_INT(listLength(&list), 4);
TEST_INT(listIsEmpty(&list), FALSE);
TEST_PTR(listHead(&list), data[0]);
TEST_PTR(listTail(&list), data[3]);
TEST_PTR(listNext(data[0]), data[1]);
TEST_PTR(listNext(data[1]), data[2]);
TEST_PTR(listNext(data[2]), data[3]);
TEST_PTR(listNext(data[3]), NULL);
TEST_PTR(listPrev(data[3]), data[2]);
TEST_PTR(listPrev(data[2]), data[1]);
TEST_PTR(listPrev(data[1]), data[0]);
TEST_PTR(listPrev(data[0]), NULL);
TEST_PTR(listRemoveHead(&list), data[0]);
TEST_PTR(listRemoveHead(&list), data[1]);
TEST_PTR(listRemoveTail(&list), data[3]);
TEST_PTR(listRemoveTail(&list), data[2]);
TEST_INT(listLength(&list), 0);
TEST_INT(listIsEmpty(&list), TRUE);
listAppendTail(&list, data[0]);
listAppendTail(&list, data[3]);
listAppend(&list, data[1], data[0]);
listInsert(&list, data[2], data[3]);
TEST_PTR(listRemoveHead(&list), data[0]);
TEST_PTR(listRemoveHead(&list), data[1]);
TEST_PTR(listRemoveTail(&list), data[3]);
TEST_PTR(listRemoveTail(&list), data[2]);
data[0]->i = 3;
data[1]->i = 4;
data[2]->i = 5;
data[3]->i = 1;
data[4]->i = 2;
data[5]->i = 3;
listAppendTail(&list, data[0]);
listAppendTail(&list, data[1]);
listAppendTail(&list, data[2]);
listAppendTail(&list, data[3]);
listAppendTail(&list, data[4]);
listAppendTail(&list, data[5]);
listSort(&list, cmp);
TEST_PTR(listRemoveHead(&list), data[3]);
TEST_PTR(listRemoveHead(&list), data[4]);
TEST_PTR(listRemoveHead(&list), data[0]);
TEST_PTR(listRemoveHead(&list), data[5]);
TEST_PTR(listRemoveHead(&list), data[1]);
TEST_PTR(listRemoveHead(&list), data[2]);
exit(errors);
}
void Foam::GAMGAgglomeration::createTarget
(
const labelgpuList& list,
const labelgpuList& sort,
labelgpuList& target,
labelgpuList& targetStart
)
{
labelgpuList ones(list.size(),1);
labelgpuList tmpTarget(list.size());
labelgpuList tmpSum(list.size());
labelgpuList listSort(list.size());
thrust::copy
(
thrust::make_permutation_iterator
(
list.begin(),
sort.begin()
),
thrust::make_permutation_iterator
(
list.begin(),
sort.end()
),
listSort.begin()
);
target = listSort;
label targetSize =
thrust::unique
(
target.begin(),
target.end()
)
- target.begin();
target.setSize(targetSize);
targetStart.setSize(list.size());
thrust::reduce_by_key
(
listSort.begin(),
listSort.end(),
ones.begin(),
tmpTarget.begin(),
tmpSum.begin()
);
thrust::exclusive_scan
(
tmpSum.begin(),
tmpSum.end(),
targetStart.begin()
);
targetStart.setSize(targetSize+1);
targetStart.set(targetSize,list.size());
}
