суббота, 2 декабря 2023 г.

sort linked list

 #include <iostream>

#include <stdlib.h>

struct node {
    int item;
    node *next;

    node(int x, node *t){
        item = x;
        next = t;
    }
};

typedef node *link;

void printList(link list){
    while(list != nullptr){
        std::cout << list->item << " -> ";
        list = list->next;
    }

    std::cout << "(null)" << std::endl;
}

link getInsertPosition(link sortedList, int valueToSearch);
void insertAfter(link insertPosition, link node);

link generateList(int listLength){

    link head = new node(0, nullptr);
    link tail = head;

    for(int i = 0; i < listLength; i++){
        tail->next = new node(rand() % 1000, nullptr);
        tail = tail->next;
    }

    return head;
}

/// @param nonSortedList - несортированный список, с фиктивным узлом вначале
link sortList(link nonSortedList){

    link headOfSorted = new node(0, nullptr);

    link currentNonSorted = nonSortedList->next;

    while(true){

        if (currentNonSorted == nullptr){
            break;
        }

        link nextNonSorted = currentNonSorted->next;

        link firstGreater = getInsertPosition(headOfSorted, currentNonSorted->item);
        insertAfter(firstGreater, currentNonSorted);

        currentNonSorted = nextNonSorted;
    }

    return headOfSorted;
/*
    link headOfSorted = new node(0, nullptr);
    link nextNonSorted;

    for(link currentNonSorted = nonSortedList->next; currentNonSorted != nullptr;){

        nextNonSorted = currentNonSorted->next;

        link currentSorted;

        for(currentSorted = headOfSorted; currentSorted->next != nullptr; currentSorted = currentSorted->next){
            if (currentSorted->next->item > currentNonSorted->item) { break; }
        }

        currentNonSorted->next = currentSorted->next;
        currentSorted->next = currentNonSorted;

        currentNonSorted = nextNonSorted;
    }

    return headOfSorted;
*/
}

/// @param sortedList сортированный список, с фиктивным узлом вначале
/// @param valueToSearch - узел для поиска
link getInsertPosition(link sortedList, int valueToSearch){

    while(true){
        if (sortedList->next == nullptr){
            break;
        }

        if (sortedList->next->item > valueToSearch){
            break;
        }

        sortedList = sortedList->next;
    }

    return sortedList;
}

void insertAfter(link insertPosition, link node){
    node->next = insertPosition->next;
    insertPosition->next = node;
}

int main(int argc, char *argv[]){
    int listLength = atoi(argv[1]);

    link notSortedList = generateList(listLength);
    printList(notSortedList);

    link sortedList = sortList(notSortedList);
    printList(sortedList);

    return 0;
}

суббота, 11 ноября 2023 г.

coupling alg

 /*quick weighted union with path compression*/

#include <stdio.h>

#include <iostream>

#define N 10


int get_root(int id[], int element){

    while(id[element] != element){

        element = id[element];

    }

    return element;

}


int main(){

    int id[N];

    int size[N];


    for (int i = 0; i < N; i++){

        id[i] = i;

        size[i] = 1;

    }


    int p;

    int q;


    while(std::cin >> p >> q){

        int pRoot = get_root(id, p);

        int qRoot = get_root(id, q);


        if (qRoot == pRoot) {

            continue;

        }


        if (size[pRoot] > size[qRoot]){

            id[qRoot] = id[q] = pRoot;

            size[pRoot] += size[qRoot];

        }

        else {

            id[pRoot]= id[p] = qRoot;

            size[qRoot] += size[pRoot];

        }


        printf("%d %d\n", p, q);


    }


    for(int i =0; i < N; i++){

        printf("%d \t", id[i]);

    }

    printf("\n");


    for(int i =0; i < N; i++){

        printf("%d \t", size[i]);

    }

    printf("\n");


    return 0;

}

//---------------------------------

/*quick weighted union with max path length */

#include <stdio.h>

#include <iostream>


#define N 10


int get_root(int id[], int element){


    while(id[element] != element){

        element = id[element];

    }


    return element;

}


int main(){


    int id[N];

    int size[N];


    for (int i = 0; i < N; i++){

        id[i] = i;

        size[i] = 1;

    }


    int p;

    int q;


    while(std::cin >> p >> q){

        int pRoot = get_root(id, p);

        int qRoot = get_root(id, q);


        if (qRoot == pRoot) {

            continue;

        }


        if (size[pRoot] >= size[qRoot]){

            id[qRoot] = pRoot;


            if (size[pRoot] == size[qRoot]){

                size[pRoot] += 1;

            }

        }

        else {

            id[pRoot] = qRoot;

        }


        printf("%d %d\n", p, q);


    }


    for(int i =0; i < N; i++){

        printf("%d \t", id[i]);

    }

    printf("\n");


    for(int i =0; i < N; i++){

        printf("%d \t", size[i]);

    }

    printf("\n");


    return 0;

}