void main(int argc, char** argv){ node *head = NULL; node *test = NULL; node *merged = NULL; addNode(5, &head); addNode(6, &head); addNode(7, &head); addNode(10, &head); addNode(4, &test); addNode(8, &test); addNode(11, &test); merged = merge_sorted(head, test); printList(merged); //head->next->next->next->next = head->next; if(detectLoop(head)){ printf("loop found\n"); exit(0); } // printList(head); deleteNode(7, head); // printList(head); head = reverseList(head, NULL); //printList(head); destroyList(head); }
/* Basic recursive mergesort * @param cmp * Comparator used to define the ordering on the data. strcmp style. * @param list * singly linked list node of the list that will be sorted. */ node *merge_sort(comparator cmp, node *list) { /* Lists length 0 and 1 are sorted. */ if(!list || !list->next) return list; /* Find midpoint of list */ node *midp = list; for(node *i = list; i && i->next && i->next->next; i = i->next->next) { midp = midp->next; } node *tail = merge_sort(cmp, midp->next); midp->next = 0; return merge_sorted(cmp, merge_sort(cmp, list), tail); }
void merge_thread(void *arg) { merge_arg_t a, b, c; bool cont, quit; while (true) { cont = false; quit = false; size_t waiting = 0, remaining = 0; while (true) { pthread_mutex_lock(&parts_mutex); waiting = pending_parts.size(); remaining = remaining_parts; pthread_mutex_unlock(&parts_mutex); if (waiting >= 2) { pthread_mutex_lock(&parts_mutex); a = pending_parts.front(); pending_parts.pop(); b = pending_parts.front(); pending_parts.pop(); remaining_parts -= 1; pthread_mutex_unlock(&parts_mutex); break; } else if (waiting + remaining >= 2) { if (pthread_mutex_trylock(&parts_exist_mutex) != 0) { return; } } else { return; } } c.data = merge_sorted(a, b); c.begin = 0; c.end = c.data->size(); c.delete_data_when_done = true; pthread_mutex_lock(&parts_mutex); pending_parts.push(c); if (pending_parts.size() <= 2) { pthread_mutex_trylock(&parts_exist_mutex); pthread_mutex_unlock(&parts_exist_mutex); } pthread_mutex_unlock(&parts_mutex); } }
int main(int argc, char ** argv) { if (argc != 3) { fprintf(stderr, "usage: %s <input> <output>\n", argv[0]); return EXIT_FAILURE; } try { size_t size = get_available_mem_size(); void *p = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, -1, 0); if (p==MAP_FAILED) { throw std::runtime_error( format_message_with_errno( errno, "Allocating %zu bytes of memory", size)); } sort_element::base = p; mem_chunk available_mem = mem_chunk(p, size).aligned(); file_id_t src_file = file_id::create_with_path(argv[1]); file_id_t dest_file = file_id::create_with_path(argv[2]); dest_file->set_auto_unlink(true); std::deque<file_id_t> transient_files; split_and_sort(available_mem, src_file, dest_file, transient_files); merge_sorted(available_mem, src_file, dest_file, transient_files); dest_file->set_auto_unlink(false); return EXIT_SUCCESS; } catch (const std::logic_error &e) { fprintf(stderr, "%s: Internal error: %s\n", argv[0], e.what()); return EXIT_FAILURE; } catch (const std::exception &e) { fprintf(stderr, "%s: %s\n", argv[0], e.what()); return EXIT_FAILURE; } }
void merge(size_t* _FirstArray, size_t _FirstArraySize, size_t* _SecondArray, size_t _SecondArraySize, size_t* _ThirdArray) { merge_sorted(_ThirdArray, _FirstArray, _SecondArray, _FirstArraySize, _SecondArraySize, sizeof(size_t), &compare); /* size_t _Count; size_t _First, _Second, _Third; _First = _Second = 0; for (_Count = 0; _Count < _FirstArraySize + _SecondArraySize; ++_Count) { if (_FirstArray[_First] < _SecondArray[_Second] && _First < _FirstArraySize) { *_ThirdArray++ = _First++; } else if (_FirstArray[_First] > _SecondArray[_Second] && _Second < _SecondArraySize) { *_ThirdArray++ = _Second++; } else if (_First < _FirstArraySize) { *_ThirdArray++ = _First++; } } */ }
void merge_sort(void* _Array, size_t _ArraySize, size_t _ElementSize, int (*_compare)(void*, void*)) { int _Count; void* _ArrayCopy = malloc(_ElementSize * _ArraySize); void* _Buffer = malloc(_ElementSize * _ArraySize); size_t _Size = 1; /* smallest size possible */ size_t _Pairs = _ArraySize / _Size; size_t _Groups = 1; size_t _IncrementSize = 1; /* ***************************************************** */ /* Make a copy of the array */ /* ***************************************************** */ memcpy(_ArrayCopy, _Array, _ArraySize * _ElementSize); while (_IncrementSize * 2 <= _ArraySize) { int _SortLastPair = 0; void* _TempPointer; size_t _Index; _Groups = _Pairs / 2; _IncrementSize *= 2; _IncrementSize % 2 == 0 ? _IncrementSize = _IncrementSize : ++_IncrementSize; if ((_Groups * _IncrementSize) != _ArraySize) { _SortLastPair = 1; } for (_Index = 0; _Index < _ArraySize; _Index += _IncrementSize) { int _FirstEndIndex = _Index + (_IncrementSize / 2) - 1; int _SecondEndIndex = _Index + _IncrementSize - 1; int _FirstBeginningIndex = _FirstEndIndex - (_Size - 1); int _SecondBeginningIndex = _SecondEndIndex - (_Size - 1); if (_SecondEndIndex > _ArraySize - 1) continue; char* _ArrayAsBytes = (char*)_ArrayCopy; char* _BufferAsBytes = (char*)_Buffer; if (_IncrementSize == _Pairs) _SecondEndIndex = _IncrementSize * _Size; merge_sorted((void*)(_BufferAsBytes + (_FirstBeginningIndex * _ElementSize)) , (void*)(_ArrayAsBytes + (_FirstBeginningIndex * _ElementSize)), (void*)(_ArrayAsBytes + (_SecondBeginningIndex * _ElementSize)), _Size, _Size, _ElementSize, _compare); } if (_SortLastPair) { int _EndIndex = _ArraySize - 1; int _BeginningIndex = _EndIndex - (_ArraySize - (_Groups * _IncrementSize)) + 1; int _PreviousBeginningIndex = (_IncrementSize * _Groups) - _IncrementSize; int _PreviousEndingIndex = _PreviousBeginningIndex + _IncrementSize - 1; memcpy((void*)(((char*)_Buffer + (_BeginningIndex * _ElementSize))), (void*)(((char*)_ArrayCopy) + (_BeginningIndex * _ElementSize)), ((_EndIndex - _BeginningIndex) + 1) * _ElementSize); merge_sorted((void*)((char*)(_ArrayCopy + (_PreviousBeginningIndex * _ElementSize))), (void*)((char*)(_Buffer + (_PreviousBeginningIndex * _ElementSize))), (void*)((char*)(_Buffer + (_BeginningIndex * _ElementSize))), _IncrementSize, _EndIndex - _BeginningIndex + 1, _ElementSize, _compare); memcpy((void*)(((char*)_Buffer + (_PreviousBeginningIndex * _ElementSize))), (void*)(((char*)_ArrayCopy) + (_PreviousBeginningIndex * _ElementSize)), ((_EndIndex - _PreviousBeginningIndex) + 1) * _ElementSize); } _TempPointer = _ArrayCopy; _ArrayCopy = _Buffer; _Buffer = _TempPointer; _Size *= 2; /* amount of partitions in the array */ _Pairs = (_Pairs / 2); if (_Size + 1 == _ArraySize) ++_Size; } memcpy(_Array, _ArrayCopy, _ArraySize * _ElementSize); free(_ArrayCopy); free(_Buffer); }
int main() { LinkList La, Lb, Lc; ElemType e; int i; InitList(La); InitList(Lb); InitList(Lc); for ( i = 0; i < 10; i++ ) ListInsert(La, 1, (i+1)% 4); ListTraverse(La, print); delete_x(La, 3); ListTraverse(La, print); ClearList(La); for ( i = 0; i < 10; i++ ) ListInsert(La, 1, i+1); ListTraverse(La, print); reverse_print(La->next); printf("\n"); delete_min(La); ListTraverse(La, print); reverse(La); ListTraverse(La, print); delete_between_min_and_max(La); ListTraverse(La, print); ClearList(La); for ( i = 0; i < 10; i++ ) ListInsert(La, 1, i+1); ListTraverse(La, print); print_and_delete_sorted(La); ClearList(La); for ( i = 0; i < 10; i++ ) ListInsert(La, 1, i+1); ListTraverse(La, print); split(La, Lb); ListTraverse(La, print); ListTraverse(Lb, print); ClearList(La); for ( i = 9; i > 6; i-- ) ListInsert(La, 1, i); for ( i = 7; i > 5; i-- ) ListInsert(La, 1, i); for ( i = 6; i > 4; i-- ) ListInsert(La, 1, i); ListTraverse(La, print); Delete_repeat_sorted(La); ListTraverse(La, print); ClearList(La); ClearList(Lb); for ( i = 10; i > 0; i-- ) { ListInsert(La, 1, i); ListInsert(Lb, 1, i*2); } ListTraverse(La, print); ListTraverse(Lb, print); merge_sorted(La, Lb); ListTraverse(La, print); ClearList(La); InitList(Lb); for ( i = 10; i > 0; i-- ) { ListInsert(La, 1, i); ListInsert(Lb, 1, i*2); } ListTraverse(La, print); ListTraverse(Lb, print); merge_common(La, Lb, Lc); ListTraverse(Lc, print); ClearList(La); ClearList(Lb); for ( i = 10; i > 0; i-- ) ListInsert(La, 1, i); for ( i = 6; i > 2; i-- ) ListInsert(Lb, 1, i); ListTraverse(La, print); ListTraverse(Lb, print); child_sequence(La, Lb); search_k(La, 4); return 0; }