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;
}
