mathdatech/Python
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/Python.git synced 2024-11-27 15:01:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove unnecessary branch (#4824)

Browse Source 
* Algorithm Optimized

* Update divide_and_conquer/inversions.py

Co-authored-by: John Law <johnlaw.po@gmail.com>

* Update divide_and_conquer/inversions.py

Co-authored-by: John Law <johnlaw.po@gmail.com>

* Update divide_and_conquer/inversions.py

Co-authored-by: John Law <johnlaw.po@gmail.com>

Co-authored-by: John Law <johnlaw.po@gmail.com>
This commit is contained in:
Muhammad Hammad Sani 2021-10-11 21:33:06 +05:00 committed by GitHub
parent fadb97609f
commit e311b02e70
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 10 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
divide_and_conquer/inversions.py
View File

@ -2,31 +2,25 @@
Given an array-like data structure A[1..n], how many pairs Given an array-like data structure A[1..n], how many pairs
(i, j) for all 1 <= i < j <= n such that A[i] > A[j]? These pairs are (i, j) for all 1 <= i < j <= n such that A[i] > A[j]? These pairs are
called inversions. Counting the number of such inversions in an array-like called inversions. Counting the number of such inversions in an array-like
object is the important. Among other things, counting inversions can help object is the important. Among other things, counting inversions can help
us determine how close a given array is to being sorted us determine how close a given array is to being sorted.
In this implementation, I provide two algorithms, a divide-and-conquer In this implementation, I provide two algorithms, a divide-and-conquer
algorithm which runs in nlogn and the brute-force n^2 algorithm. algorithm which runs in nlogn and the brute-force n^2 algorithm.
""" """
def count_inversions_bf(arr): def count_inversions_bf(arr):
""" """
Counts the number of inversions using a a naive brute-force algorithm Counts the number of inversions using a a naive brute-force algorithm
Parameters Parameters
---------- ----------
arr: arr: array-like, the list containing the items for which the number arr: arr: array-like, the list containing the items for which the number
of inversions is desired. The elements of `arr` must be comparable. of inversions is desired. The elements of `arr` must be comparable.
Returns Returns
------- -------
num_inversions: The total number of inversions in `arr` num_inversions: The total number of inversions in `arr`
Examples Examples
--------- ---------
>>> count_inversions_bf([1, 4, 2, 4, 1]) >>> count_inversions_bf([1, 4, 2, 4, 1])
4 4
>>> count_inversions_bf([1, 1, 2, 4, 4]) >>> count_inversions_bf([1, 1, 2, 4, 4])
@ -49,20 +43,16 @@ def count_inversions_bf(arr):
def count_inversions_recursive(arr): def count_inversions_recursive(arr):
""" """
Counts the number of inversions using a divide-and-conquer algorithm Counts the number of inversions using a divide-and-conquer algorithm
Parameters Parameters
----------- -----------
arr: array-like, the list containing the items for which the number arr: array-like, the list containing the items for which the number
of inversions is desired. The elements of `arr` must be comparable. of inversions is desired. The elements of `arr` must be comparable.
Returns Returns
------- -------
C: a sorted copy of `arr`. C: a sorted copy of `arr`.
num_inversions: int, the total number of inversions in 'arr' num_inversions: int, the total number of inversions in 'arr'
Examples Examples
-------- --------
>>> count_inversions_recursive([1, 4, 2, 4, 1]) >>> count_inversions_recursive([1, 4, 2, 4, 1])
([1, 1, 2, 4, 4], 4) ([1, 1, 2, 4, 4], 4)
>>> count_inversions_recursive([1, 1, 2, 4, 4]) >>> count_inversions_recursive([1, 1, 2, 4, 4])
@ -72,40 +62,34 @@ def count_inversions_recursive(arr):
""" """
if len(arr) <= 1: if len(arr) <= 1:
return arr, 0 return arr, 0
else: mid = len(arr) // 2
mid = len(arr) // 2 P = arr[0:mid]
P = arr[0:mid] Q = arr[mid:]
Q = arr[mid:]
A, inversion_p = count_inversions_recursive(P) A, inversion_p = count_inversions_recursive(P)
B, inversions_q = count_inversions_recursive(Q) B, inversions_q = count_inversions_recursive(Q)
C, cross_inversions = _count_cross_inversions(A, B) C, cross_inversions = _count_cross_inversions(A, B)
num_inversions = inversion_p + inversions_q + cross_inversions num_inversions = inversion_p + inversions_q + cross_inversions
return C, num_inversions return C, num_inversions
def _count_cross_inversions(P, Q): def _count_cross_inversions(P, Q):
""" """
Counts the inversions across two sorted arrays. Counts the inversions across two sorted arrays.
And combine the two arrays into one sorted array And combine the two arrays into one sorted array
For all 1<= i<=len(P) and for all 1 <= j <= len(Q), For all 1<= i<=len(P) and for all 1 <= j <= len(Q),
if P[i] > Q[j], then (i, j) is a cross inversion if P[i] > Q[j], then (i, j) is a cross inversion
Parameters Parameters
---------- ----------
P: array-like, sorted in non-decreasing order P: array-like, sorted in non-decreasing order
Q: array-like, sorted in non-decreasing order Q: array-like, sorted in non-decreasing order
Returns Returns
------ ------
R: array-like, a sorted array of the elements of `P` and `Q` R: array-like, a sorted array of the elements of `P` and `Q`
num_inversion: int, the number of inversions across `P` and `Q` num_inversion: int, the number of inversions across `P` and `Q`
Examples Examples
-------- --------
>>> _count_cross_inversions([1, 2, 3], [0, 2, 5]) >>> _count_cross_inversions([1, 2, 3], [0, 2, 5])
([0, 1, 2, 2, 3, 5], 4) ([0, 1, 2, 2, 3, 5], 4)
>>> _count_cross_inversions([1, 2, 3], [3, 4, 5]) >>> _count_cross_inversions([1, 2, 3], [3, 4, 5])