dsa-programs/Lecture35.cpp at main · Aadharbindal/dsa-programs · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
#include<iostream>
using namespace std;

// void merge(int *arr, int s, int e) {

//     int mid = (s+e)/2;

//     int len1 = mid - s + 1;
//     int len2 = e - mid;

//     int *first = new int[len1];
//     int *second = new int[len2];

//     //copy values
//     int mainArrayIndex = s;
//     for(int i=0; i<len1; i++) {
//         first[i] = arr[mainArrayIndex++];
//     }

//     mainArrayIndex = mid+1;
//     for(int i=0; i<len2; i++) {
//         second[i] = arr[mainArrayIndex++];
//     }

//     //merge 2 sorted arrays
//     int index1 = 0;
//     int index2 = 0;
//     mainArrayIndex = s;

//     while(index1 < len1 && index2 < len2) {
//         if(first[index1] < second[index2]) {
//             arr[mainArrayIndex++] = first[index1++];
//         }
//         else{
//             arr[mainArrayIndex++] = second[index2++];
//         }
//     }

//     while(index1 < len1) {
//         arr[mainArrayIndex++] = first[index1++];
//     }

//     while(index2 < len2 ) {
//         arr[mainArrayIndex++] = second[index2++];
//     }

//     delete []first;
//     delete []second;

// }

    long merge1(int arr[] , long s , long e){
        long ans = 0;

        int mid = (s + e)/2;

        int l1 = mid - s + 1;
        int l2 = e - mid;

        int *a1 = new int[l1];
        int *a2 = new int[l2];

        int idx = s;

        //copy elements
        for(int i = 0; i < l1; i++){
            a1[i] = arr[s+i];
        }

        for(int i = 0; i < l2; i++){
            a2[i] = arr[mid+i+1];
        }

        int idx1 = 0;
        int idx2 = 0;
        while(idx1 < l1 && idx2 < l2){
            //check for inversions

            if(a1[idx1] > a2[idx2]){
                ans += l1-idx1;
                arr[idx++] = a2[idx2++];
            }
            else {
                arr[idx++] = a1[idx1++];
            }
        }

        while(idx1 < l1){
            arr[idx++] = a1[idx1++];
        }
        while(idx2 < l2){
            arr[idx++] = a2[idx2++];
        }

        return ans;
    }

//                                           merge sort

void mergeSort(int *arr, int s, int e) {

    //base case
    if(s >= e) {
        return;
    }

    int mid = (s+e)/2;

    //left part sort karna h
    mergeSort(arr, s, mid);

    //right part sort karna h
    mergeSort(arr, mid+1, e);

    //merge
    merge(arr, s, e);

}


//                                        inversion count by shraddha didi's video
long count(int *arr, int s, int e) {

    //base case
    if(s >= e) {
        return 0;
    }

    int mid = (s+e)/2;
    long inv = 0;
    inv += count(arr , s , mid);               // count have 2 conditions :- (i < j) and (arr[i] > arr[j])
    inv += count(arr , mid + 1 , e);
    inv += merge1(arr , s , e);

    return inv;
}

int main() {

    int arr[8] = {3,5,6,9,1,2,7,8};
    int n = 8;

    // mergeSort(arr, 0, n-1);

    // for(int i=0;i<n;i++){
    //     cout << arr[i] << " ";
    // } cout << endl;

    count(arr, 0, n-1);

    // for(int i=0;i<n;i++){
    //     cout << arr[i] << " ";
    // } cout << endl;

    cout<<count(arr, 0, n-1)<<endl;

    return 0;
}


// inversion count pending