PYTHON

bubble sort python

def bubble(st):
    for i in range(len(st),1,-1):
        for j in range(0,i-1):
            if st[j]>st[j+1]:
                st[j],st[j+1]=st[j+1],st[j]
            else:
                pass
    print(st)
bubble([64, 34, 25, 12, 22, 11, 90] )

bubble sort python

s= [1,2,3,4,5,6,7,8,9,10]
for i in range(len(s)-1):
    for j in range(len(s)-1-i):
        if s[j]>s[j+1]:
            s[j],s[j+1] = s[j+1],s[j]
print(s)

How to perform Bubble sort in Python?

"""
Bubble sort sorts a list by repeatedly
swapping adjacent out-of-order values.
The process continues until the list
becomes sorted. 
"""


def bubble_sort(array):
    isSorted = False
    passes = 0
    length = len(array)
    while not isSorted:
        isSorted = True
        # perform a pass through the array
        # excluding already sorted positions
        for i in range(length-1-passes):
            if array[i] > array[i+1]:
                swap(i, i+1, array)
                # array is not sorted yet
                isSorted = False
        passes += 1
    return array


def swap(i, j, array):
    # Swap values at indexes i and j
    array[i], array[j] = array[j], array[i]


arr = [1, 9, 3, 2]
print(bubble_sort(arr))  # [1, 2, 3, 9]

python bubble sort

def bubble_sort(li_to_sort):
    # Looping from size of array from last index[-1] to index [0]
    for n in range(len(li_to_sort)-1, 0, -1):
        for i in range(n):
            if li_to_sort[i] > li_to_sort[i + 1]:
                # swapping data if the element is less than next element in the array
                li_to_sort[i], li_to_sort[i + 1] = li_to_sort[i + 1], li_to_sort[i]


li = [39, 12, 18, 85, 72, 10, 2, 18]

print("Unsorted list: ", li)
bubble_sort(li)
print("Sorted List: ", li)

Bubble sort python

for i in range(x - 1):
  for j in range(x - 1 - i):
    if s[j]>s[j + 1]:
      s[j],s[j + 1] = s[j + 1],s[j]
print(*s, sep=' ')

bubble sort in python

arr = [12,1,6,23,234,456,2,35,687,34]
# arry consists of 9 elements

n = len(arr)
#conts the element of the arry 

for j in range(n-1):            #this is for list to get shorted properly && you dont need to go full as it may take more steps to exicute
    for i in range(n-j-1):      #if left with n the there will be array error because it will try to add 1 to n in below leading to array being bigger                                             
        if arr[i]>arr[i+1]:                                         
            arr[i],arr[i+1]=arr[i+1],arr[i]
        else:
            pass
#       arry starts from last and eventually decrease the number lower and lower which leads to lesser steps
#       #above took 125 steps to eully exicute
#################################################################        
#       #this takes 217 steps to run and end code
# for i in range(n):
#     if arr[i]>arr[i+1]:
#         arr[i],arr[i+1]=arr[i+1],arr[i]        
#     else:
#         pass
#################################################################    
print("the sorted array is : "arr)

bubble sort in python

def bubble_sort(nums):
    n = len(nums)
    for i in range(n):
        swapped = False
        for j in range(1, n - i):
            if nums[j] < nums[j - 1]:
                nums[j], nums[j - 1] = nums[j - 1], nums[j]
                swapped = True
        if not swapped: break
    return nums
print(bubble_sort([9, 8, 7, 6, 5, 4, 3, 2, 1]))

bubble sort in python

def bubbleSort(lis):
    length = len(lis)
    for i in range(length):
        for j in range(length - i):
            a = lis[j]
            if a != lis[-1]:
                b = lis[j + 1]
                if a > b:
                    lis[j] = b
                    lis[j + 1] = a
    return lis

bubble python

"""Bubblesort
"""
## Un-optimised--------------------------------------------------------------
def bubble_1(lst):
    n = len(lst) - 1
    for i in range(n):
        # Within the unsorted portion
        for j in range(n - i):
            # If curr > next, swap
            if lst[j] > lst[j+1]:
                lst[j], lst[j+1] = lst[j+1], lst[j]
    return lst # for easy testing

def bubble_2(lst):
    n = len(lst) - 1
    # Within the unsorted portion, except the last number
    for unsorted in range(n, 0, -1):
        for i in range(unsorted):
            # If curr > next, swap
            if lst[i] > lst[i+1]:
                lst[i], lst[i+1] = lst[i+1], lst[i]
    return lst # for easy testing

## Optimised-----------------------------------------------------------------
def bubble_3(lst):
    n = len(lst) - 1
    
    # Within the unsorted portion, except the last number
    for unsorted in range(n, 0, -1):
        swapped = False
        for i in range(unsorted):
            # If curr > next, swap
            if lst[i] > lst[i+1]:
                lst[i], lst[i+1] = lst[i+1], lst[i]
                swapped = True
        
        # Check if its sorted by this time
        if not swapped:
            break
    return lst # for easy testing

bubble sort python

# Python3 Optimized implementation
# of Bubble sort
 
# An optimized version of Bubble Sort
def bubbleSort(arr):
    n = len(arr)
  
    # Traverse through all array elements
    for i in range(n):
        swapped = False
 
        # Last i elements are already
        #  in place
        for j in range(0, n-i-1):
  
            # traverse the array from 0 to
            # n-i-1. Swap if the element
            # found is greater than the
            # next element
            if arr[j] > arr[j+1] :
                arr[j], arr[j+1] = arr[j+1], arr[j]
                swapped = True
 
        # IF no two elements were swapped
        # by inner loop, then break
        if swapped == False:
            break
          
# Driver code to test above
arr = [64, 34, 25, 12, 22, 11, 90]
  
bubbleSort(arr)
  
print ("Sorted array :")
for i in range(len(arr)):
    print ("%d" %arr[i],end=" ")
 
# This code is contributed by Shreyanshi Arun

how to import bubble sort in python

def bubble_sort(our_list):
    # We go through the list as many times as there are elements
    for i in range(len(our_list)):
        # We want the last pair of adjacent elements to be (n-2, n-1)
        for j in range(len(our_list) - 1):
            if our_list[j] > our_list[j+1]:
                # Swap
                our_list[j], our_list[j+1] = our_list[j+1], our_list[j]