{"id":96533,"date":"2021-06-14T09:00:33","date_gmt":"2021-06-14T03:30:33","guid":{"rendered":"https:\/\/data-flair.training\/blogs\/?p=96533"},"modified":"2021-06-26T19:29:05","modified_gmt":"2021-06-26T13:59:05","slug":"bubble-sort","status":"publish","type":"post","link":"https:\/\/data-flair.training\/blogs\/bubble-sort\/","title":{"rendered":"Bubble Sort in Data Structure"},"content":{"rendered":"

Ever witnessed a car racing tournament? There are multiple laps in a race. While the race is in progress, let\u2019s say team A is in 4th position. Team B is just behind team A and Team C is ahead of Team A. Now, in lap 1, if team A is faster than team C, it will overtake it. In other words, teams A and C swap their positions. Similarly, if team E is faster than team F, they will swap positions. In the next lap, Team B and C might swap positions depending on their speed comparisons.<\/p>\n

A bubble sort algorithm works in a similar manner. Consider each lap as one iteration. It swaps all the places not in order in a single iteration and moves to the next iteration. Here, we will learn the working of the bubble sort algorithm, and an optimized approach for the same.<\/p>\n

Bubble sort<\/h3>\n

Bubble sort is the simplest sorting algorithm. Sorting is the process of arranging the elements in a dataset either in ascending or descending order. In this comparison-based sorting algorithm, each pair of adjacent elements is compared. If the elements are not found to be in the required order, they are swapped.<\/p>\n

1. After each iteration, the largest remaining element is at the highest index. (while arranging in ascending order.)
\n2. Swaps adjacent elements only.<\/p>\n

Working of bubble sort<\/h4>\n

1. Start for the starting index. Compare the current element to the next element.
\n2. If the current element and next element are not in order, swap them.
\n3. Repeat step 2 until you reach the end of the array. This is the end of iteration 1.
\n4. Repeat steps 1, 2, 3 until the array is sorted.<\/p>\n

Bubble Sort Algorithm<\/h4>\n
Step 1: Repeat For i = 0 to N-1\r\nStep 2: Repeat For j = i + 1 to N - I\r\nStep 3: If Arr[ j ] > Arr[ i ]\r\n             swap Arr[ j ] and Arr[ i ]\r\n             [end of step 2]\r\n             [end of step 1]\r\nStep 4: stop\r\n\r\n<\/pre>\n
Bubbel Sort Pseudocode<\/h4>\n
procedure bubbleSort( array)\r\n\r\n   len = array.length;\r\n   \r\n   for i = 0 to loop-1 do:\r\n    \r\n      for j = 0 to loop-1 do:\r\n        \r\n         if list[j] > list[j+1] then\r\n            swap( list[j], list[j+1] )\t\t \r\n         end if\r\n         \r\n      end for      \r\n   end for\r\n return array\r\nend procedure\r\n\r\n<\/pre>\n
Example of Bubble Sort<\/h4>\n
Let\u2019s sort the characters in the word \u201cDATAFLAIR\u201d by the bubble sort technique.<\/p>\n
\"Bubble<\/a><\/p>\n
ITERATION 1<\/h5>\n
\"Swapping<\/a><\/p>\n
\"Swap<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
\"Working<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
 <\/p>\n
 <\/p>\n
After iteration 1 \u2018T\u2019, the largest element is set at the last position.<\/p>\n
ITERATION 2<\/h5>\n
\"Bubble<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
ITERATION 3<\/h5>\n
\"Bubble<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
 <\/p>\n
 <\/p>\n
ITERATION 4<\/h5>\n
\"Bubble<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
ITERATION 5<\/h5>\n
\"Bubble<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
ITERATION 6<\/h5>\n
\"Bubble<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
ITERATION 7<\/h5>\n
\"Bubble<\/a><\/p>\n
\"Bubble<\/a><\/p>\n
 <\/p>\n
ITERATION 8<\/h5>\n
\"Bubble<\/a><\/h3>\n
Stability of Bubble sort algorithm<\/h3>\n
The stability of sorting algorithms comes into the picture when the same element is present more than once in a dataset. If the same elements in the unsorted dataset appear in the same order in the sorted dataset, then the algorithm is said to be a stable algorithm.<\/p>\n
In the above example, the letter \u2018A\u2019 appears three times in the original array in the order RED, GREEN, and YELLOW. In the final sorted array after iteration 8, the order of A\u2019s is the same as in the original. Hence, we can say that bubble sort is a stable sorting algorithm.<\/p>\n
Implementation of Bubble sort in C<\/h4>\n
#include <stdio.h>\r\n\r\nvoid main() \r\n{\r\n   int arr[] = {34,8,25,45,13,70,54,68,100,3,92,86};\r\n  \r\n   int len = 12;\r\n for (int i = 0; i < len - 1; i++) \r\n  {\r\n      \r\n    for (int j = 0; j < len - i - 1; j++) \r\n    {\r\n    \r\n      if (arr[j] > arr[j + 1]) \r\n      {\r\n      \r\n       int temp = arr[j];\r\n        arr[j] = arr[j + 1];\r\n        arr[j + 1] = temp;\r\n      }\r\n    }\r\n  }\r\n  printf(\"Sorted Array:\\n\");\r\n   for (int i = 0; i < len - 1; i++) \r\n  {\r\n      printf(\"%d \",arr[i]);\r\n  }\r\n}\r\n<\/pre>\n
Bubble sort Implementation in C++<\/h4>\n
#include <iostream>\r\nusing namespace std;\r\n\r\nint main() \r\n{\r\n   int arr[] = {34,8,25,45,13,70,54,68,100,3,92,86};\r\n  \r\n   int len = 12;\r\n for (int i = 0; i < len - 1; i++) \r\n  {\r\n      \r\n    for (int j = 0; j < len - i - 1; j++) \r\n    {\r\n    \r\n      if (arr[j] > arr[j + 1]) \r\n      {\r\n      \r\n       int temp = arr[j];\r\n        arr[j] = arr[j + 1];\r\n        arr[j + 1] = temp;\r\n      }\r\n    }\r\n  }\r\n  cout << \"Sorted Array:\\n\";\r\n   for (int i = 0; i < len - 1; i++) \r\n  {\r\n      cout << \" \" << arr[i];\r\n  }\r\n}\r\n<\/pre>\n
Bubble sort Implementation in Java<\/h4>\n
public class Bubblesort \r\n{\r\n  static void bubbleSort(int arr[]) \r\n  {\r\n      int i,j,len;\r\n      len = arr.length;\r\n      Boolean swap;\r\n    for (i = 0; i < len - 1; i++)\r\n{\r\n      for (j = 0; j < len - i - 1; j++)\r\n{\r\n        if (arr[j] > arr[j + 1]) \r\n        {\r\n          int temp = arr[j];\r\n          arr[j] = arr[j + 1];\r\n          arr[j + 1] = temp;\r\n        }\r\n      \r\n    }\r\n}\r\nSystem.out.println(\"Sorted Array:\");\r\n\r\n      for (i = 0; i < len - 1; i++)\r\n      System.out.print(arr[i]+\" \");\r\n  }\r\n\r\n  public static void main(String args[]) \r\n  {\r\n      \r\n    int[] data = {34,8,25,45,13,70,54,68,100,3,92,86 };\r\n    Bubblesort.bubbleSort(data);\r\n  }\r\n}\r\n<\/pre>\n
Implementation of Bubble sort in Python<\/h4>\n
def bubbleSort(array):\r\n   \r\n  for i in range(len(array)):\r\n\r\n    for j in range(0, len(array) - i - 1):\r\n\r\n      if array[j] > array[j + 1]:\r\n\r\n        temp = array[j]\r\n        array[j] = array[j+1]\r\n        array[j+1] = temp\r\n\r\n\r\ndata = [34,8,25,45,13,70,54,68,100,3,92,86]\r\n\r\nbubbleSort(data)\r\n\r\nprint('Sorted Array:')\r\nprint(data)\r\n<\/pre>\n
Optimized Bubble sort<\/h3>\n
In the example we discussed above, you can clearly see that even if the array is sorted, all the comparisons and iterations are still performed. This results in higher execution time, and more comparisons that are useless since the array is already sorted. The last swap in the above example is done in iteration 4. But still, the program continues to compare until iteration 8 which is useless and inefficient.<\/p>\n
To counter this problem, we introduce a binary variable that is set to a false value. If even one swap is made in the array during sorting, it changes to true, else it remains false. If after any iteration, it is not changed, then the array is sorted and no need for further comparisons.<\/p>\n
In the above example, if we apply optimized bubble sort, then the execution will be stopped after iteration 5 since no swap is made there.<\/p>\n
Algorithm of Optimized Bubble Sort<\/h4>\n
Step 1: Repeat For i = 0 to N-1\r\n             Swap = false\r\nStep 2: Repeat For j = i + 1 to N - I\r\nStep 3: If Arr[ j ] > Arr[ i ]\r\n             swap Arr[ j ] and Arr[ i ]\r\n             swap = true\r\n             [end of step 2]\r\n             If swap == false\r\n             Goto step 4\r\n             [end of step 1]\r\nStep 4: stop\r\n<\/pre>\n
Optimized Bubble Sort Pseudocode<\/h4>\n
procedure bubbleSort( array)\r\n\r\n   len = array.length;\r\n   \r\n   for i = 0 to loop-1 do:\r\n      swap =false\t\r\n      for j = 0 to loop-1 do:\r\n        \r\n         if list[j] > list[j+1] then\r\n            swap( list[j], list[j+1] )\t\r\n            swap = true\t \r\n         end if         \r\n      end for \r\n      If swap = = false\r\n      break; \r\n   end for\r\n return array\r\nend procedure\r\n<\/pre>\n
Implementation of Optimized bubble sort in C<\/h4>\n
#include <stdio.h>\r\n\r\nvoid main() \r\n{\r\n   int arr[] = {34,8,25,45,13,70,54,68,100,3,92,86};\r\n  \r\n   int len = 12, swap;\r\n for (int i = 0; i < len - 1; i++) \r\n  {\r\n      swap=0;\r\n    for (int j = 0; j < len - i - 1; j++) \r\n    {\r\n    \r\n      if (arr[j] > arr[j + 1]) \r\n      {\r\n      \r\n       int temp = arr[j];\r\n        arr[j] = arr[j + 1];\r\n        arr[j + 1] = temp;\r\n       swap =1;\r\n      }\r\n    }\r\nif (swap == 0)\r\nbreak;\r\n  }\r\n  printf(\"Sorted Array:\\n\");\r\n   for (int i = 0; i < len - 1; i++) \r\n  {\r\n      printf(\"%d \",arr[i]);\r\n  }\r\n}<\/pre>\n
Optimized bubble sort Implementation in C++<\/h4>\n
#include <iostream>\r\nusing namespace std;\r\n\r\nint main() \r\n{\r\n   int arr[] = {34,8,25,45,13,70,54,68,100,3,92,86};\r\n  \r\n   int len = 12,swap;\r\n for (int i = 0; i < len - 1; i++) \r\n  {\r\n      swap=0;\r\n    for (int j = 0; j < len - i - 1; j++) \r\n    {\r\n    \r\n      if (arr[j] > arr[j + 1]) \r\n      {\r\n      \r\n       int temp = arr[j];\r\n        arr[j] = arr[j + 1];\r\n        arr[j + 1] = temp;\r\n       swap =1;\r\n      }\r\n    }\r\nif (swap ==0)\r\nbreak;\r\n  }\r\n  cout << \"Sorted Array:\\n\";\r\n   for (int i = 0; i < len - 1; i++) \r\n  {\r\n      cout << \" \" << arr[i];\r\n  }\r\n}\r\n<\/pre>\n
Optimized bubble sort Implementation in Java<\/h4>\n
public class Bubblesort \r\n{\r\n  static void bubbleSort(int arr[]) \r\n  {\r\n      int i,j,len;\r\n      len = arr.length;\r\n      Boolean swap;\r\n    for (i = 0; i < len - 1; i++)\r\n{\r\n      swap = false;\r\n      for (j = 0; j < len - i - 1; j++)\r\n{\r\n        if (arr[j] > arr[j + 1]) \r\n        {\r\n          int temp = arr[j];\r\n          arr[j] = arr[j + 1];\r\n          arr[j + 1] = temp;\r\n          swap = true;\r\n        }\r\n      \r\n    }\r\nif (swap==false)\r\nbreak;\r\n}\r\nSystem.out.println(\"Sorted Array:\");\r\n\r\n      for (i = 0; i < len - 1; i++)\r\n      System.out.print(arr[i]+\" \");\r\n  }\r\n\r\n  public static void main(String args[]) \r\n  {\r\n      \r\n    int[] data = {34,8,25,45,13,70,54,68,100,3,92,86 };\r\n    Bubblesort.bubbleSort(data);\r\n  }\r\n}\r\n}\r\n<\/pre>\n
Implementation of Optimized bubble sort in Python<\/h4>\n
def bubbleSort(array):\r\n   \r\n  for i in range(len(array)):\r\n    swap = false\r\n    for j in range(0, len(array) - i - 1):\r\n\r\n      if array[j] > array[j + 1]:\r\n\r\n        temp = array[j]\r\n        array[j] = array[j+1]\r\n        array[j+1] = temp\r\n        swap = true;\r\n    if swap==false:\r\n        break;\r\n\r\ndata = [34,8,25,45,13,70,54,68,100,3,92,86]\r\n\r\nbubbleSort(data)\r\n\r\nprint('Sorted Array:')\r\nprint(data)\r\n<\/pre>\n
Complexity of Bubble Sort<\/h3>\n
In Bubble sort, adjacent elements are compared.<\/p>\n\n\n\n\n\n\n\n\n\n\n
iteration<\/span><\/td>\ncomparisons<\/span><\/td>\n<\/tr>\n
1<\/span><\/td>\n(n-1)<\/span><\/td>\n<\/tr>\n
2<\/span><\/td>\n(n-2)<\/span><\/td>\n<\/tr>\n
3<\/span><\/td>\n(n-3)<\/span><\/td>\n<\/tr>\n
.<\/span><\/td>\n.<\/span><\/td>\n<\/tr>\n
.<\/span><\/td>\n.<\/span><\/td>\n<\/tr>\n
.<\/span><\/td>\n.<\/span><\/td>\n<\/tr>\n
n-1<\/span><\/td>\n1<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Total number of comparison :\u00a0<\/span><\/p>\n
(n-1) + (n-2) + (n-3) \u2026\u2026\u2026. + 1<\/span><\/p>\n
= n(n-1)\/2 \u2248 n^<\/span>2<\/span> \u00a0 ( complexity)\u00a0<\/span><\/p>\n
Best Case Complexity:<\/b> When elements are already sorted.<\/span><\/p>\n
Average Case Complexity:<\/b> When elements are jumbled i.e. they are neither in ascending or descending order.<\/span><\/p>\n
Worst Case Complexity:<\/b>\u00a0 When elements are sorted in the opposite of the required order.<\/span><\/p>\n
Space complexity:<\/b> One extra variable, temp,\u00a0 is used to swap the variables.<\/span><\/p>\n\n\n\n\n\n\n\n
Scenario<\/b><\/td>\nComplexity<\/b><\/td>\n<\/tr>\n
Worst case<\/span><\/td>\nO(n^<\/span>2<\/span>)<\/span><\/td>\n<\/tr>\n
Average case<\/span><\/td>\nO(n)<\/span><\/td>\n<\/tr>\n
Best case<\/span><\/td>\nO(n^<\/span>2<\/span>)<\/span><\/td>\n<\/tr>\n
space<\/span><\/td>\nO(1)<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Advantages of Bubble sort<\/b><\/h3>\n
1. Used in computer graphics since it can detect very small errors and can fix it in O(2n) time.<\/span><\/p>\n
2. Easy to Understand.<\/span><\/p>\n
3. Minimum space requirement as compared to other sorting algorithms.<\/span><\/p>\n
Disadvantages of bubble sort<\/b><\/h3>\n
1. Not suitable for large datasets.<\/span><\/p>\n
Conclusion<\/b><\/h3>\n
Bubble sort is the easiest sorting algorithm. Bubble sort is a stable algorithm where the order of the same elements remains unchanged. <\/span><\/p>\n
Though the worst-case complexity of this algorithm does not make this suitable for very large datasets, by using the optimized version of the bubble, the execution time can be improved to some extent for small datasets. We have also seen the working and implementation of the bubble sort algorithm.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"
Ever witnessed a car racing tournament? There are multiple laps in a race. While the race is in progress, let\u2019s say team A is in 4th position. Team B is just behind team A...<\/p>\n","protected":false},"author":7,"featured_media":96571,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[24020],"tags":[24493,2182,24494],"class_list":["post-96533","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-data-structure-tutorials","tag-bubble-sort","tag-bubble-sort-algorithm","tag-bubble-sort-in-data-structure"],"yoast_head":"\nBubble Sort in Data Structure - DataFlair<\/title>\n<meta name=\"description\" content=\"Bubble Sort is the simplest sorting algorithm that works by repeatedly swapping the adjacent elements if they are in wrong order. Learn more.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/data-flair.training\/blogs\/bubble-sort\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Bubble Sort in Data Structure - DataFlair\" \/>\n<meta property=\"og:description\" content=\"Bubble Sort is the simplest sorting algorithm that works by repeatedly swapping the adjacent elements if they are in wrong order. Learn more.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/data-flair.training\/blogs\/bubble-sort\/\" \/>\n<meta property=\"og:site_name\" content=\"DataFlair\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/DataFlairWS\/\" \/>\n<meta property=\"article:published_time\" content=\"2021-06-14T03:30:33+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2021-06-26T13:59:05+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2021\/06\/Bubble-sort-in-DS.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"1200\" \/>\n\t<meta property=\"og:image:height\" content=\"628\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"DataFlair Team\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@DataFlairWS\" \/>\n<meta name=\"twitter:site\" content=\"@DataFlairWS\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"DataFlair Team\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"15 minutes\" \/>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Bubble Sort in Data Structure - DataFlair","description":"Bubble Sort is the simplest sorting algorithm that works by repeatedly swapping the adjacent elements if they are in wrong order. Learn more.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/data-flair.training\/blogs\/bubble-sort\/","og_locale":"en_US","og_type":"article","og_title":"Bubble Sort in Data Structure - DataFlair","og_description":"Bubble Sort is the simplest sorting algorithm that works by repeatedly swapping the adjacent elements if they are in wrong order. Learn more.","og_url":"https:\/\/data-flair.training\/blogs\/bubble-sort\/","og_site_name":"DataFlair","article_publisher":"https:\/\/www.facebook.com\/DataFlairWS\/","article_published_time":"2021-06-14T03:30:33+00:00","article_modified_time":"2021-06-26T13:59:05+00:00","og_image":[{"width":1200,"height":628,"url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2021\/06\/Bubble-sort-in-DS.jpg","type":"image\/jpeg"}],"author":"DataFlair Team","twitter_card":"summary_large_image","twitter_creator":"@DataFlairWS","twitter_site":"@DataFlairWS","twitter_misc":{"Written by":"DataFlair Team","Est. reading time":"15 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/data-flair.training\/blogs\/bubble-sort\/#article","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/bubble-sort\/"},"author":{"name":"DataFlair Team","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/person\/beb0cab24b7aa54423a3b50e669a9dcd"},"headline":"Bubble Sort in Data Structure","datePublished":"2021-06-14T03:30:33+00:00","dateModified":"2021-06-26T13:59:05+00:00","mainEntityOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/bubble-sort\/"},"wordCount":851,"commentCount":0,"publisher":{"@id":"https:\/\/data-flair.training\/blogs\/#organization"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/bubble-sort\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2021\/06\/Bubble-sort-in-DS.jpg","keywords":["Bubble Sort","Bubble sort algorithm","Bubble Sort in data structure"],"articleSection":["Data Structure Tutorials"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/data-flair.training\/blogs\/bubble-sort\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/data-flair.training\/blogs\/bubble-sort\/","url":"https:\/\/data-flair.training\/blogs\/bubble-sort\/","name":"Bubble Sort in Data Structure - DataFlair","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/#website"},"primaryImageOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/bubble-sort\/#primaryimage"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/bubble-sort\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2021\/06\/Bubble-sort-in-DS.jpg","datePublished":"2021-06-14T03:30:33+00:00","dateModified":"2021-06-26T13:59:05+00:00","description":"Bubble Sort is the simplest sorting algorithm that works by repeatedly swapping the adjacent elements if they are in wrong order. Learn more.","breadcrumb":{"@id":"https:\/\/data-flair.training\/blogs\/bubble-sort\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/data-flair.training\/blogs\/bubble-sort\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/data-flair.training\/blogs\/bubble-sort\/#primaryimage","url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2021\/06\/Bubble-sort-in-DS.jpg","contentUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2021\/06\/Bubble-sort-in-DS.jpg","width":1200,"height":628,"caption":"Bubble sort"},{"@type":"BreadcrumbList","@id":"https:\/\/data-flair.training\/blogs\/bubble-sort\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Blog Home","item":"https:\/\/data-flair.training\/blogs\/"},{"@type":"ListItem","position":2,"name":"Data Structure Tutorials","item":"https:\/\/data-flair.training\/blogs\/category\/data-structure-tutorials\/"},{"@type":"ListItem","position":3,"name":"Bubble Sort in Data Structure"}]},{"@type":"WebSite","@id":"https:\/\/data-flair.training\/blogs\/#website","url":"https:\/\/data-flair.training\/blogs\/","name":"DataFlair","description":"Learn Today. Lead Tomorrow.","publisher":{"@id":"https:\/\/data-flair.training\/blogs\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/data-flair.training\/blogs\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/data-flair.training\/blogs\/#organization","name":"DataFlair","url":"https:\/\/data-flair.training\/blogs\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/logo\/image\/","url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2016\/07\/Data-Flair.png","contentUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2016\/07\/Data-Flair.png","width":106,"height":48,"caption":"DataFlair"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/DataFlairWS\/","https:\/\/x.com\/DataFlairWS","https:\/\/www.linkedin.com\/company\/dataflair-web-services-pvt-ltd\/","https:\/\/www.youtube.com\/user\/DataFlairWS"]},{"@type":"Person","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/person\/beb0cab24b7aa54423a3b50e669a9dcd","name":"DataFlair Team","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/c322416204232f4dd97ef3901b0a499a5d34d7ba7fe333f4bfe53a907873d293?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/c322416204232f4dd97ef3901b0a499a5d34d7ba7fe333f4bfe53a907873d293?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/c322416204232f4dd97ef3901b0a499a5d34d7ba7fe333f4bfe53a907873d293?s=96&d=mm&r=g","caption":"DataFlair Team"},"description":"DataFlair Team specializes in creating clear, actionable content on programming, Java, Python, C++, DSA, AI, ML, data Science, Android, Flutter, MERN, Web Development, and technology. Backed by industry expertise, we make learning easy and career-oriented for beginners and pros alike.","url":"https:\/\/data-flair.training\/blogs\/author\/dfteam3\/"}]}},"amp_enabled":true,"_links":{"self":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/96533","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/users\/7"}],"replies":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/comments?post=96533"}],"version-history":[{"count":5,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/96533\/revisions"}],"predecessor-version":[{"id":97809,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/96533\/revisions\/97809"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media\/96571"}],"wp:attachment":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media?parent=96533"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/categories?post=96533"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/tags?post=96533"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}