0 ratings0% found this document useful (0 votes)
2 views143 pagesSorting Algorithms
The document provides an overview of common sorting algorithms including Bubble, Selection, Insertion, Merge, Quick, and Heap, along with their time complexities. It also includes pseudo code examples for the Merge Sort algorithm in Python. Each sorting algorithm is characterized by its efficiency and stability, with complexities ranging from O(n^2) to O(n log n).
Uploaded by
dshimpi66Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
0 ratings0% found this document useful (0 votes)
2 views143 pagesSorting Algorithms
The document provides an overview of common sorting algorithms including Bubble, Selection, Insertion, Merge, Quick, and Heap, along with their time complexities. It also includes pseudo code examples for the Merge Sort algorithm in Python. Each sorting algorithm is characterized by its efficiency and stability, with complexities ranging from O(n^2) to O(n log n).
Uploaded by
dshimpi66Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 143
--- Block 1 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 2 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 3 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 4 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 5 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 6 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 7 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 8 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 9 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 10 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 11 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 12 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 13 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 14 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 15 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 16 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 17 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 18 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 19 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 20 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 21 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 22 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 23 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 24 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 25 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 26 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 27 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 28 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 29 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 30 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 31 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 32 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 33 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 34 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 35 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 36 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 37 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 38 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 39 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 40 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 41 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 42 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 43 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 44 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 45 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 46 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 47 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 48 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 49 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 50 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 51 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 52 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 53 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 54 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 55 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 56 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 57 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 58 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 59 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 60 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 61 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 62 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 63 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 64 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 65 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 66 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 67 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 68 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 69 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 70 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 71 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 72 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 73 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 74 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 75 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 76 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 77 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 78 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 79 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 80 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 81 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 82 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 83 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 84 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 85 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 86 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 87 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 88 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 89 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 90 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 91 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 92 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 93 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 94 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 95 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 96 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 97 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 98 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 99 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 100 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 101 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 102 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 103 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 104 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 105 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 106 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 107 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 108 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 109 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 110 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 111 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 112 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 113 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 114 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 115 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 116 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 117 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 118 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 119 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 120 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 121 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 122 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 123 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 124 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 125 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 126 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 127 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 128 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 129 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 130 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 131 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 132 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 133 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 134 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 135 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 136 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 137 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 138 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 139 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 140 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 141 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 142 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 143 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 144 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 145 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 146 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 147 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 148 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 149 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 150 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 151 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 152 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 153 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 154 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 155 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 156 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 157 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 158 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 159 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 160 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 161 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 162 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 163 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 164 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 165 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 166 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 167 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 168 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 169 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 170 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 171 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 172 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 173 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 174 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 175 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 176 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 177 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 178 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 179 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 180 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 181 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 182 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 183 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 184 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 185 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 186 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 187 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 188 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 189 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 190 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 191 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 192 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 193 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 194 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 195 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 196 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 197 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 198 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 199 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 200 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 201 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 202 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 203 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 204 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 205 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 206 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 207 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 208 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 209 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 210 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 211 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 212 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 213 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 214 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 215 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 216 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 217 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 218 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 219 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 220 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 221 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 222 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 223 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 224 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 225 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 226 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 227 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 228 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 229 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 230 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 231 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 232 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 233 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 234 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 235 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 236 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 237 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 238 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 239 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 240 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 241 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 242 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 243 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 244 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 245 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 246 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 247 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 248 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 249 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 250 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 251 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 252 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 253 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 254 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 255 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 256 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 257 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 258 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 259 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 260 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 261 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 262 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 263 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 264 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 265 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 266 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 267 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 268 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 269 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 270 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
--- Block 271 ---
Sorting Algorithms Overview
Common sorts: Bubble, Selection, Insertion, Merge, Quick, Heap.
Complexities:
- Bubble: O(n^2)
- Selection: O(n^2)
- Insertion: O(n^2) average, good for nearly-sorted
- Merge: O(n log n), stable
- Quick: O(n log n) average, O(n^2) worst-case
- Heap: O(n log n)
Pseudo and short code examples:
Python - merge sort:
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr)//2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
i=j=0
res=[]
while i<len(left) and j<len(right):
if left[i] <= right[j]:
res.append(left[i]); i+=1
else:
res.append(right[j]); j+=1
res.extend(left[i:]); res.extend(right[j:])
return res
You might also like
- Sorting: What Makes It Hard? Chapter 7 in DS&AA Chapter 8 in DS&PSNo ratings yetSorting: What Makes It Hard? Chapter 7 in DS&AA Chapter 8 in DS&PS20 pages
- C Programming and Data Structures 41394658 2025 06-20-08 20No ratings yetC Programming and Data Structures 41394658 2025 06-20-08 2035 pages
- Data Structures and Algorithms (COMP232)No ratings yetData Structures and Algorithms (COMP232)5 pages
- Data Structures and Algorithms (CS F211) SortingNo ratings yetData Structures and Algorithms (CS F211) Sorting4 pages
- Unit 5 - (Sorting, Higher Order Sort, Merge List)No ratings yetUnit 5 - (Sorting, Higher Order Sort, Merge List)28 pages
- LEARNING MATERIALS-Algorithm-UNIT2 (MODIFIED)No ratings yetLEARNING MATERIALS-Algorithm-UNIT2 (MODIFIED)63 pages
- CSCE 3110 Data Structures & Algorithm Analysis: Rada Mihalcea Sorting (II) Reading: Chap.7, WeissNo ratings yetCSCE 3110 Data Structures & Algorithm Analysis: Rada Mihalcea Sorting (II) Reading: Chap.7, Weiss26 pages
- Comparison of Various Sorting Algorithms - A ReviewNo ratings yetComparison of Various Sorting Algorithms - A Review4 pages
- Week 02 (Complexity of Sorting Algorithms)No ratings yetWeek 02 (Complexity of Sorting Algorithms)62 pages
- CSCE 3110 Data Structures & Algorithm Analysis: Rada Mihalcea Sorting (I) Reading: Chap.7, WeissNo ratings yetCSCE 3110 Data Structures & Algorithm Analysis: Rada Mihalcea Sorting (I) Reading: Chap.7, Weiss28 pages
- Inverse Trigonometric Functions (Trigonometry) Mathematics Question BankFrom EverandInverse Trigonometric Functions (Trigonometry) Mathematics Question BankNo ratings yet
- Unit 2.3 Bucket - Radix - Counting - SortingNo ratings yetUnit 2.3 Bucket - Radix - Counting - Sorting32 pages
- Sorting Techniques: Bubble Sort Insertion Sort Selection Sort Quick Sort Merge Sort100% (2)Sorting Techniques: Bubble Sort Insertion Sort Selection Sort Quick Sort Merge Sort22 pages
- A New Approach To Improve Selection Sort by The Modified Selection SortNo ratings yetA New Approach To Improve Selection Sort by The Modified Selection Sort7 pages
- Lecture-04 05 - Sorting Techniques AnalysisNo ratings yetLecture-04 05 - Sorting Techniques Analysis10 pages
- A New Approach To Sorting Min Max Sorting Algorithm IJERTV2IS50210 PDFNo ratings yetA New Approach To Sorting Min Max Sorting Algorithm IJERTV2IS50210 PDF4 pages
- An Efficient Methodology To Sort Large Volume of DataNo ratings yetAn Efficient Methodology To Sort Large Volume of Data5 pages
- DSA-Chapter 3 - Sorting and Searching AlgorithmsNo ratings yetDSA-Chapter 3 - Sorting and Searching Algorithms42 pages
- Softpanorama: Slightly Skeptical View On Sorting Algorithms0% (1)Softpanorama: Slightly Skeptical View On Sorting Algorithms20 pages
- Chapter 4 Decrease and Conquer HomeworkNo ratings yetChapter 4 Decrease and Conquer Homework10 pages