Bubble Sort

void bubble_sort ( vector < int > a ) {

        int n = a.size();

        for (int i = 1; i < n - 1; i++) {

                for (int j = 0; j < n - i; j++) {

                        if (a[j] > a[j+1]) {

                                int temp = a[j];

                                a[j] = a[j+1];

                                a[j+1] = temp;

                        }

                }       

        }

}

Selection sort

void selection_sort ( vector < int > a ) {

    int min_index = -1;

    for (int i = 0; i < n - 1; i++) {

        min = i;

        for (int j = i+1; j< n; j++) {

            if (a[j] < min_index) {

                min_index =  j;

            }

        }

        int temp = a[i];

        a[i] = a[min_index];

        a[min_index] = temp;

    }

}

Insertion Sort

void insertion_sort ( vector <int> arr ) {

    int key = 0;

    int j = 0;

  

    for (int i = 1; i < arr.size(); i++) {

        key = arr[i];

        j = i - 1;

        while(j > = 0 && arr[j] > key) {

            arr[j+1] = arr[j];

        }

        arr[j+1] = key;

    }

}

Longest common subsequence

#include <cmath>

#include <cstdio>

#include <vector>

#include <iostream>

#include <algorithm>

using namespace std;

void lcsutil (vector <int> & first, vector <int> & second, vector <vector <int> > & arr) {

    int m = first.size();

    int n = second.size();

    

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

        arr[0][i] = 0;

    }

    

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

        arr[i][0] = 0;

    }

    

    for (int i = 1; i <= m; i++) {

        for (int j = 1; j <= n; j++) {

            if (first[i-1] == second[j-1]) {

                arr[i][j] = arr[i-1][j-1] + 1;

            } else if (arr[i-1][j] >= arr[i][j-1]) {

                arr[i][j] = arr[i-1][j];

            } else if (arr[i][j-1] > arr[i-1][j]){

                arr[i][j] = arr[i][j-1];

            }

        }

    }

    

    int index = arr[m][n];

    vector <int> longest (index);

    index--;

    

    int i = m;

    int j = n;

    

    while (i > 0 & j > 0) {

        if (first[i-1] == second[j-1]) {

            longest[index] = first[i-1];

            index--;

            i--;

            j--;

        } else if (arr[i-1][j] > arr[i][j-1]) {

            i--;

        } else {

            j--;

        }

    }

    

    for (int i = 0; i < arr[m][n]; i++){

        cout<<longest[i]<<" ";

    }

}

int main() {

    /* Enter your code here. Read input from STDIN. Print output to STDOUT */

    unsigned int m, n;

    

    cin>>m>>n;

    

    vector < int > first(m);

    vector < int > second(n);

    

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

        cin>>first[i];

    }

    

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

        cin>>second[i];

    }

    

    vector < vector <int> > arr ( m + 1 , vector <int> (n + 1));

    

    lcsutil (first, second, arr);

    

    return 0;

}

Djkstra Algorithm

Djsktra algorithm is used to find shortest path between two vertices in a graph

#include <cmath>

#include <cstdio>

#include <vector>

#include <iostream>

#include <algorithm>

#include <climits>

using namespace std;

long long getMinimumIndex (long long start, vector < vector < long long > > &a, vector < long long >  & dis, vector < long long > &spf) {

    

    long long min_index = 1;

    

    for (long long i = 1; i < dis.size(); i++) {

        if (!spf[i]) {

            min_index = i;

            break;

        }

    }

    

    long long min_value = dis[min_index];

    

    for (long long i = 1; i < dis.size(); i++){

        

        if (min_value > dis[i] && !spf[i]) {

            min_value = dis[i];

            min_index = i;

        }

    }

    

    return min_index;

}

void djkstra (vector <vector <long long> > &a, const long long & start, const long long & nodes) {

    

    vector <long long> dis (nodes + 1);

    vector <long long> spf (nodes + 1);

    long long min_index = 0;

    std::fill (dis.begin(), dis.end(), LLONG_MAX);

    std::fill (spf.begin(), spf.end(), 0);

    

    dis[start] = 0;

    

    for (int i = 1; i <= nodes; i++) {

        

        min_index = getMinimumIndex (i, a, dis, spf);

        

        cout<<"\n The selected index is "<<min_index;

        

        spf[min_index] = 1;

        

        for (int j = 1; j <= nodes; j++) {

            if (a[min_index][j]) {

                if (dis[j] > dis[min_index] + a[min_index][j]) {

                    dis[j] = dis[min_index] + a[min_index][j];

                }

            }

        }

        

        /*for (long long i = 1; i <= nodes; i++) {

             if (i != start) {

                 cout<<dis[i]<<" ";

             }

        }*/

    }

    

    for (long long i = 1; i <= nodes; i++){

        if (i != start) {

            if (dis[i] != LLONG_MAX){

                cout<<dis[i]<<" ";

            } else {

                cout<<"-1"<<" ";

            }

        }

    }

}

int main() {

    /* Enter your code here. Read input from STDIN. Print output to STDOUT */

    

    int t;

    cin>>t;

    

    while (t--) {

        

        long long nodes;

        long long edges;

        long long start  = 0;

        

        cin>>nodes>>edges;

        

        vector < vector <long long> > a (nodes + 1, vector < long long > (nodes + 1));

        

        for (long long i = 1; i <= nodes; i++) {

            

            std::fill(a[i].begin(), a[i].end(), 0);

        }

        

        for (long long i = 1; i <= edges; i++) {

            

            long long from, to, dis;

            

            cin>>from>>to>>dis;

            

            if (!a[from][to] || a[from][to] > dis) {

                a[from][to] = dis;

                a[to][from] = dis;

            }

        }

        

        cin>>start;

        

        djkstra (a, start, nodes);

        

        cout<<"\n";

    }

    

    return 0;

}