Python/sorts/insertion_sort.py at master · PreciousJac0b/Python · 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
"""
A pure Python implementation of the insertion sort algorithm

This algorithm sorts a collection by comparing adjacent elements.
When it finds that order is not respected, it moves the element compared
backward until the order is correct. It then goes back directly to the
element's initial position resuming forward comparison.

For doctests run following command:
python3 -m doctest -v insertion_sort.py

For manual testing run:
python3 insertion_sort.py
"""

fromcollections.abcimportMutableSequence
fromtypingimportAny, Protocol, TypeVar


classComparable(Protocol):
def__lt__(self, other: Any, /) ->bool:
 ...


T=TypeVar("T", bound=Comparable)


definsertion_sort(collection: MutableSequence[T]) ->MutableSequence[T]:
"""A pure Python implementation of the insertion sort algorithm

 :param collection: some mutable ordered collection with heterogeneous
 comparable items inside
 :return: the same collection ordered by ascending

 Examples:
 >>> insertion_sort([0, 5, 3, 2, 2])
 [0, 2, 2, 3, 5]
 >>> insertion_sort([]) == sorted([])
 True
 >>> insertion_sort([-2, -5, -45]) == sorted([-2, -5, -45])
 True
 >>> insertion_sort(['d', 'a', 'b', 'e', 'c']) == sorted(['d', 'a', 'b', 'e', 'c'])
 True
 >>> import random
 >>> collection = random.sample(range(-50, 50), 100)
 >>> insertion_sort(collection) == sorted(collection)
 True
 >>> import string
 >>> collection = random.choices(string.ascii_letters + string.digits, k=100)
 >>> insertion_sort(collection) == sorted(collection)
 True
 """

forinsert_indexinrange(1, len(collection)):
insert_value=collection[insert_index]
whileinsert_index>0andinsert_value<collection[insert_index-1]:
collection[insert_index] =collection[insert_index-1]
insert_index-=1
collection[insert_index] =insert_value
returncollection


if__name__=="__main__":
fromdoctestimporttestmod

testmod()

user_input=input("Enter numbers separated by a comma:\n").strip()
unsorted= [int(item) foriteminuser_input.split(",")]
print(f"{insertion_sort(unsorted) =}")
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
"""
A pure Python implementation of the insertion sort algorithm

This algorithm sorts a collection by comparing adjacent elements.
When it finds that order is not respected, it moves the element compared
backward until the order is correct. It then goes back directly to the
element's initial position resuming forward comparison.

For doctests run following command:
python3 -m doctest -v insertion_sort.py

For manual testing run:
python3 insertion_sort.py
"""

fromcollections.abcimportMutableSequence
fromtypingimportAny, Protocol, TypeVar


classComparable(Protocol):
def__lt__(self, other: Any, /) ->bool:
 ...


T=TypeVar("T", bound=Comparable)


definsertion_sort(collection: MutableSequence[T]) ->MutableSequence[T]:
"""A pure Python implementation of the insertion sort algorithm

 :param collection: some mutable ordered collection with heterogeneous
 comparable items inside
 :return: the same collection ordered by ascending

 Examples:
 >>> insertion_sort([0, 5, 3, 2, 2])
 [0, 2, 2, 3, 5]
 >>> insertion_sort([]) == sorted([])
 True
 >>> insertion_sort([-2, -5, -45]) == sorted([-2, -5, -45])
 True
 >>> insertion_sort(['d', 'a', 'b', 'e', 'c']) == sorted(['d', 'a', 'b', 'e', 'c'])
 True
 >>> import random
 >>> collection = random.sample(range(-50, 50), 100)
 >>> insertion_sort(collection) == sorted(collection)
 True
 >>> import string
 >>> collection = random.choices(string.ascii_letters + string.digits, k=100)
 >>> insertion_sort(collection) == sorted(collection)
 True
 """

forinsert_indexinrange(1, len(collection)):
insert_value=collection[insert_index]
whileinsert_index>0andinsert_value<collection[insert_index-1]:
collection[insert_index] =collection[insert_index-1]
insert_index-=1
collection[insert_index] =insert_value
returncollection


if__name__=="__main__":
fromdoctestimporttestmod

testmod()

user_input=input("Enter numbers separated by a comma:\n").strip()
unsorted= [int(item) foriteminuser_input.split(",")]
print(f"{insertion_sort(unsorted) =}")
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
"""
A pure Python implementation of the insertion sort algorithm

This algorithm sorts a collection by comparing adjacent elements.
When it finds that order is not respected, it moves the element compared
backward until the order is correct. It then goes back directly to the
element's initial position resuming forward comparison.

For doctests run following command:
python3 -m doctest -v insertion_sort.py

For manual testing run:
python3 insertion_sort.py
"""

fromcollections.abcimportMutableSequence
fromtypingimportAny, Protocol, TypeVar


classComparable(Protocol):
def__lt__(self, other: Any, /) ->bool:
 ...


T=TypeVar("T", bound=Comparable)


definsertion_sort(collection: MutableSequence[T]) ->MutableSequence[T]:
"""A pure Python implementation of the insertion sort algorithm

 :param collection: some mutable ordered collection with heterogeneous
 comparable items inside
 :return: the same collection ordered by ascending

 Examples:
 >>> insertion_sort([0, 5, 3, 2, 2])
 [0, 2, 2, 3, 5]
 >>> insertion_sort([]) == sorted([])
 True
 >>> insertion_sort([-2, -5, -45]) == sorted([-2, -5, -45])
 True
 >>> insertion_sort(['d', 'a', 'b', 'e', 'c']) == sorted(['d', 'a', 'b', 'e', 'c'])
 True
 >>> import random
 >>> collection = random.sample(range(-50, 50), 100)
 >>> insertion_sort(collection) == sorted(collection)
 True
 >>> import string
 >>> collection = random.choices(string.ascii_letters + string.digits, k=100)
 >>> insertion_sort(collection) == sorted(collection)
 True
 """

forinsert_indexinrange(1, len(collection)):
insert_value=collection[insert_index]
whileinsert_index>0andinsert_value<collection[insert_index-1]:
collection[insert_index] =collection[insert_index-1]
insert_index-=1
collection[insert_index] =insert_value
returncollection


if__name__=="__main__":
fromdoctestimporttestmod

testmod()

user_input=input("Enter numbers separated by a comma:\n").strip()
unsorted= [int(item) foriteminuser_input.split(",")]
print(f"{insertion_sort(unsorted) =}")
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
"""
A pure Python implementation of the insertion sort algorithm

This algorithm sorts a collection by comparing adjacent elements.
When it finds that order is not respected, it moves the element compared
backward until the order is correct. It then goes back directly to the
element's initial position resuming forward comparison.

For doctests run following command:
python3 -m doctest -v insertion_sort.py

For manual testing run:
python3 insertion_sort.py
"""

fromcollections.abcimportMutableSequence
fromtypingimportAny, Protocol, TypeVar


classComparable(Protocol):
def__lt__(self, other: Any, /) ->bool:
 ...


T=TypeVar("T", bound=Comparable)


definsertion_sort(collection: MutableSequence[T]) ->MutableSequence[T]:
"""A pure Python implementation of the insertion sort algorithm

 :param collection: some mutable ordered collection with heterogeneous
 comparable items inside
 :return: the same collection ordered by ascending

 Examples:
 >>> insertion_sort([0, 5, 3, 2, 2])
 [0, 2, 2, 3, 5]
 >>> insertion_sort([]) == sorted([])
 True
 >>> insertion_sort([-2, -5, -45]) == sorted([-2, -5, -45])
 True
 >>> insertion_sort(['d', 'a', 'b', 'e', 'c']) == sorted(['d', 'a', 'b', 'e', 'c'])
 True
 >>> import random
 >>> collection = random.sample(range(-50, 50), 100)
 >>> insertion_sort(collection) == sorted(collection)
 True
 >>> import string
 >>> collection = random.choices(string.ascii_letters + string.digits, k=100)
 >>> insertion_sort(collection) == sorted(collection)
 True
 """

forinsert_indexinrange(1, len(collection)):
insert_value=collection[insert_index]
whileinsert_index>0andinsert_value<collection[insert_index-1]:
collection[insert_index] =collection[insert_index-1]
insert_index-=1
collection[insert_index] =insert_value
returncollection


if__name__=="__main__":
fromdoctestimporttestmod

testmod()

user_input=input("Enter numbers separated by a comma:\n").strip()
unsorted= [int(item) foriteminuser_input.split(",")]
print(f"{insertion_sort(unsorted) =}")
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
"""
A pure Python implementation of the insertion sort algorithm

This algorithm sorts a collection by comparing adjacent elements.
When it finds that order is not respected, it moves the element compared
backward until the order is correct. It then goes back directly to the
element's initial position resuming forward comparison.

For doctests run following command:
python3 -m doctest -v insertion_sort.py

For manual testing run:
python3 insertion_sort.py
"""

fromcollections.abcimportMutableSequence
fromtypingimportAny, Protocol, TypeVar


classComparable(Protocol):
def__lt__(self, other: Any, /) ->bool:
 ...


T=TypeVar("T", bound=Comparable)


definsertion_sort(collection: MutableSequence[T]) ->MutableSequence[T]:
"""A pure Python implementation of the insertion sort algorithm

 :param collection: some mutable ordered collection with heterogeneous
 comparable items inside
 :return: the same collection ordered by ascending

 Examples:
 >>> insertion_sort([0, 5, 3, 2, 2])
 [0, 2, 2, 3, 5]
 >>> insertion_sort([]) == sorted([])
 True
 >>> insertion_sort([-2, -5, -45]) == sorted([-2, -5, -45])
 True
 >>> insertion_sort(['d', 'a', 'b', 'e', 'c']) == sorted(['d', 'a', 'b', 'e', 'c'])
 True
 >>> import random
 >>> collection = random.sample(range(-50, 50), 100)
 >>> insertion_sort(collection) == sorted(collection)
 True
 >>> import string
 >>> collection = random.choices(string.ascii_letters + string.digits, k=100)
 >>> insertion_sort(collection) == sorted(collection)
 True
 """

forinsert_indexinrange(1, len(collection)):
insert_value=collection[insert_index]
whileinsert_index>0andinsert_value<collection[insert_index-1]:
collection[insert_index] =collection[insert_index-1]
insert_index-=1
collection[insert_index] =insert_value
returncollection


if__name__=="__main__":
fromdoctestimporttestmod

testmod()

user_input=input("Enter numbers separated by a comma:\n").strip()
unsorted= [int(item) foriteminuser_input.split(",")]
print(f"{insertion_sort(unsorted) =}")
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
"""
A pure Python implementation of the insertion sort algorithm

This algorithm sorts a collection by comparing adjacent elements.
When it finds that order is not respected, it moves the element compared
backward until the order is correct. It then goes back directly to the
element's initial position resuming forward comparison.

For doctests run following command:
python3 -m doctest -v insertion_sort.py

For manual testing run:
python3 insertion_sort.py
"""

fromcollections.abcimportMutableSequence
fromtypingimportAny, Protocol, TypeVar


classComparable(Protocol):
def__lt__(self, other: Any, /) ->bool:
 ...


T=TypeVar("T", bound=Comparable)


definsertion_sort(collection: MutableSequence[T]) ->MutableSequence[T]:
"""A pure Python implementation of the insertion sort algorithm

 :param collection: some mutable ordered collection with heterogeneous
 comparable items inside
 :return: the same collection ordered by ascending

 Examples:
 >>> insertion_sort([0, 5, 3, 2, 2])
 [0, 2, 2, 3, 5]
 >>> insertion_sort([]) == sorted([])
 True
 >>> insertion_sort([-2, -5, -45]) == sorted([-2, -5, -45])
 True
 >>> insertion_sort(['d', 'a', 'b', 'e', 'c']) == sorted(['d', 'a', 'b', 'e', 'c'])
 True
 >>> import random
 >>> collection = random.sample(range(-50, 50), 100)
 >>> insertion_sort(collection) == sorted(collection)
 True
 >>> import string
 >>> collection = random.choices(string.ascii_letters + string.digits, k=100)
 >>> insertion_sort(collection) == sorted(collection)
 True
 """

forinsert_indexinrange(1, len(collection)):
insert_value=collection[insert_index]
whileinsert_index>0andinsert_value<collection[insert_index-1]:
collection[insert_index] =collection[insert_index-1]
insert_index-=1
collection[insert_index] =insert_value
returncollection


if__name__=="__main__":
fromdoctestimporttestmod

testmod()

user_input=input("Enter numbers separated by a comma:\n").strip()
unsorted= [int(item) foriteminuser_input.split(",")]
print(f"{insertion_sort(unsorted) =}")
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
"""
A pure Python implementation of the insertion sort algorithm

This algorithm sorts a collection by comparing adjacent elements.
When it finds that order is not respected, it moves the element compared
backward until the order is correct. It then goes back directly to the
element's initial position resuming forward comparison.

For doctests run following command:
python3 -m doctest -v insertion_sort.py

For manual testing run:
python3 insertion_sort.py
"""

fromcollections.abcimportMutableSequence
fromtypingimportAny, Protocol, TypeVar


classComparable(Protocol):
def__lt__(self, other: Any, /) ->bool:
 ...


T=TypeVar("T", bound=Comparable)


definsertion_sort(collection: MutableSequence[T]) ->MutableSequence[T]:
"""A pure Python implementation of the insertion sort algorithm

 :param collection: some mutable ordered collection with heterogeneous
 comparable items inside
 :return: the same collection ordered by ascending

 Examples:
 >>> insertion_sort([0, 5, 3, 2, 2])
 [0, 2, 2, 3, 5]
 >>> insertion_sort([]) == sorted([])
 True
 >>> insertion_sort([-2, -5, -45]) == sorted([-2, -5, -45])
 True
 >>> insertion_sort(['d', 'a', 'b', 'e', 'c']) == sorted(['d', 'a', 'b', 'e', 'c'])
 True
 >>> import random
 >>> collection = random.sample(range(-50, 50), 100)
 >>> insertion_sort(collection) == sorted(collection)
 True
 >>> import string
 >>> collection = random.choices(string.ascii_letters + string.digits, k=100)
 >>> insertion_sort(collection) == sorted(collection)
 True
 """

forinsert_indexinrange(1, len(collection)):
insert_value=collection[insert_index]
whileinsert_index>0andinsert_value<collection[insert_index-1]:
collection[insert_index] =collection[insert_index-1]
insert_index-=1
collection[insert_index] =insert_value
returncollection


if__name__=="__main__":
fromdoctestimporttestmod

testmod()

user_input=input("Enter numbers separated by a comma:\n").strip()
unsorted= [int(item) foriteminuser_input.split(",")]
print(f"{insertion_sort(unsorted) =}")
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
"""
A pure Python implementation of the insertion sort algorithm

This algorithm sorts a collection by comparing adjacent elements.
When it finds that order is not respected, it moves the element compared
backward until the order is correct. It then goes back directly to the
element's initial position resuming forward comparison.

For doctests run following command:
python3 -m doctest -v insertion_sort.py

For manual testing run:
python3 insertion_sort.py
"""

fromcollections.abcimportMutableSequence
fromtypingimportAny, Protocol, TypeVar


classComparable(Protocol):
def__lt__(self, other: Any, /) ->bool:
 ...


T=TypeVar("T", bound=Comparable)


definsertion_sort(collection: MutableSequence[T]) ->MutableSequence[T]:
"""A pure Python implementation of the insertion sort algorithm

 :param collection: some mutable ordered collection with heterogeneous
 comparable items inside
 :return: the same collection ordered by ascending

 Examples:
 >>> insertion_sort([0, 5, 3, 2, 2])
 [0, 2, 2, 3, 5]
 >>> insertion_sort([]) == sorted([])
 True
 >>> insertion_sort([-2, -5, -45]) == sorted([-2, -5, -45])
 True
 >>> insertion_sort(['d', 'a', 'b', 'e', 'c']) == sorted(['d', 'a', 'b', 'e', 'c'])
 True
 >>> import random
 >>> collection = random.sample(range(-50, 50), 100)
 >>> insertion_sort(collection) == sorted(collection)
 True
 >>> import string
 >>> collection = random.choices(string.ascii_letters + string.digits, k=100)
 >>> insertion_sort(collection) == sorted(collection)
 True
 """

forinsert_indexinrange(1, len(collection)):
insert_value=collection[insert_index]
whileinsert_index>0andinsert_value<collection[insert_index-1]:
collection[insert_index] =collection[insert_index-1]
insert_index-=1
collection[insert_index] =insert_value
returncollection


if__name__=="__main__":
fromdoctestimporttestmod

testmod()

user_input=input("Enter numbers separated by a comma:\n").strip()
unsorted= [int(item) foriteminuser_input.split(",")]
print(f"{insertion_sort(unsorted) =}")