{"id":96389,"date":"2021-06-11T09:00:20","date_gmt":"2021-06-11T03:30:20","guid":{"rendered":"https:\/\/data-flair.training\/blogs\/?p=96389"},"modified":"2021-06-03T20:43:51","modified_gmt":"2021-06-03T15:13:51","slug":"binary-search","status":"publish","type":"post","link":"https:\/\/data-flair.training\/blogs\/binary-search\/","title":{"rendered":"Binary Search in Data Structure"},"content":{"rendered":"

Suppose you want to search for a word starting with \u2018U\u2019 in a dictionary. A dictionary has thousands of words arranged in ascending order. If you start from the beginning and keep on searching you are going to exhaust soon with probably more than 90% of the dictionary still not looked through.<\/p>\n

The better option is to go to the middle of the dictionary and look for the starting letter of that page. If the starting letter in the middle of the dictionary is lower than \u2018U\u2019 then you need to search only the second half of the Dictionary and if it is higher than \u2018U\u2019, you have to look in the first half of the Dictionary.<\/p>\n

Repeat the same process for the selected half and now you have only a quarter of the dictionary to search from. Continue this process multiple times. In this way, you will find words starting with the letter \u2018U\u2019 in the dictionary. This is how a binary search algorithm works.<\/p>\n

Binary Search<\/h3>\n

Binary search is an efficient searching algorithm with only the requirement that the elements in the array are sorted already.<\/p>\n

It is a great implementation of the divide and conquer algorithm technique. It divides the array at the middle and then selects the first or the second half based on the search element and then repeats the process with the selected half until the search element is found (or not).<\/p>\n

1. Works on the Divide and conquer technique to search for the elements.
\n2. Efficient than linear search algorithm.<\/p>\n

Working of Binary Search<\/h3>\n

Objective: Search of element \u201873\u2019 in the below array<\/strong><\/p>\n

\"Binary<\/a><\/p>\n

Step 1: Find the middle element.
\nmid = low + (high – low) \/ 2<\/p>\n

\"Divide<\/a><\/p>\n

Step 2: Select the second half by changing low to mid+1.
\nlow=mid+1<\/p>\n

\"Binary<\/a><\/p>\n

Step 3: Repeat steps 1 and 2 until the element is found.<\/p>\n

\"Result<\/a><\/p>\n

The element found at location 8.<\/p>\n

Pseudocode for Binary Search<\/h3>\n
Procedure binary_search\r\n   Arr \u2190 sorted array\r\n   len \u2190 size of the array\r\n   se \u2190 search element\r\n\r\n   Set low = 1\r\n   Set high = len\r\n\r\n   while se not found\r\n      if high < low \r\n         EXIT: se does not exist.\r\n   \r\n      set mid = low + ( high - low ) \/ 2\r\n      \r\n      if Arr[mid] < se\r\n         set low = mid + 1\r\n         \r\n      if Arr[mid] > se\r\n         set high = mid- 1 \r\n\r\n      if Arr[mid] = se \r\n         EXIT: se found at mid\r\n   end while\r\n   \r\nend procedure\r\n<\/pre>\n
Algorithm for Binary Search<\/h3>\n
1. Iterative approach for Binary Search<\/h4>\n
Step 1: set low = starting_index, high = last_index, loc = - 1\r\nStep 2: repeat steps 3 and 4 while low <= high\r\nStep 3: set mid = (low + high)\/2\r\nStep 4: if Arr[mid] = se\r\n             set loc = mid\r\n             print \u201c search element is present at location: \u201c + loc\r\n             go to step 6\r\n             else if Arr[mid] < se\r\n             set low = mid + 1\r\n             else\r\n             set high = mid - 1\r\n             [end of if]\r\n             [end of loop]\r\nstep 5: if loc = -1\r\n             print \"search element is not present in the array\"\r\n             [end of if]\r\nstep 6: Stop<\/pre>\n
2. Recursive approach for Binary Search<\/h4>\n
BinarySearch(arr, se, low, high)\r\n        mid = (low + high) \/ 2 \r\n        if se == arr[mid]\r\n            return mid\r\n        else if se > arr[mid]       \r\n            return BinarySearch(arr, se, mid + 1, high)\r\n        else                               \r\n            return BinarySearch(arr, se, low, mid - 1)\r\n\r\n<\/pre>\n
Binary Search Recursive implementation in C<\/h4>\n
#include <stdio.h>\r\nint binarySearch(int arr[], int low, int high, int se)\r\n{\r\n    if (high >= low) {\r\n        int mid = low + (high - low) \/ 2;\r\n        if (arr[mid] == se)\r\n            return mid;\r\n        if (arr[mid] > se)\r\n            return binarySearch(arr, low, mid - 1, se);\r\n        return binarySearch(arr, mid + 1, high, se);\r\n    }\r\n    return -1;\r\n}\r\n \r\nint main(void)\r\n{\r\n    int arr[] = { 7, 18, 26, 38, 42,57,61,73,84,91 };\r\n    int len = sizeof(arr) \/ sizeof(arr[0]);\r\n    int searchelement = 73;\r\n    int result = binarySearch(arr, 0, len - 1, searchelement);\r\n    if(result == -1) \r\n    printf(\"Element is not present in array\");\r\n    else\r\n    printf(\"Element is present at location:  %d \",result+1);\r\n    return 0;\r\n}\r\n<\/pre>\n
Recursive implementation of Binary Search in C++<\/h4>\n
#include <bits\/stdc++.h>\r\nusing namespace std;\r\n\r\nint binarySearch(int arr[], int low, int high, int se)\r\n{\r\n    if (high >= low) {\r\n        int mid = low + (high - low) \/ 2;\r\n        if (arr[mid] == se)\r\n            return mid;\r\n \r\n        if (arr[mid] > se)\r\n            return binarySearch(arr, low, mid - 1, se);\r\n \r\n        return binarySearch(arr, mid + 1, high, se);\r\n    }\r\n    return -1;\r\n}\r\n \r\nint main(void)\r\n{\r\n    int arr[] = { 7, 18, 26, 38, 42,57,61,73,84,91 };\r\n    int searchelement = 73;\r\n    int len = sizeof(arr) \/ sizeof(arr[0]);\r\n    int result = binarySearch(arr, 0, len - 1, searchelement);\r\n    if(result == -1) \r\n    cout << \"Element is not present in array\" ;\r\n    else\r\n    cout << \"Element is present at location: \" << result+1;\r\n    return 0;\r\n}\r\n<\/pre>\n
Binary Search Recursive implementation in Java<\/h4>\n
public class BinarySearch {\r\n    \r\n    int binarySearch(int arr[], int low, int high, int se)\r\n    {\r\n        if (high >= low) {\r\n            int mid = low + (high - low) \/ 2;\r\n            \r\n            if (arr[mid] == se)\r\n                return mid;\r\n \r\n            if (arr[mid] > se)\r\n                return binarySearch(arr, low, mid - 1, se);\r\n\r\n            return binarySearch(arr, mid + 1, high, se);\r\n        }\r\n        return -1;\r\n    }\r\n \r\n    public static void main(String args[])\r\n    {\r\n        BinarySearch ob = new BinarySearch();\r\n        int arr[] = { 7, 18, 26, 38, 42,57,61,73,84,91 };\r\n        int len = arr.length;\r\n        int searchelement = 73;\r\n        int result = ob.binarySearch(arr, 0, len - 1, searchelement);\r\n        if (result == -1)\r\n            System.out.println(\"Element not present\");\r\n        else\r\n            System.out.println(\"Element found at location: \" + result+1);\r\n    }\r\n}\r\n\r\n<\/pre>\n
Recursive implementation of Binary Search in Python<\/h4>\n
def binarySearch (arr, low,high, se):\r\n \r\n    if high >= low:\r\n \r\n        mid = low + (high - low) \/\/ 2\r\n \r\n        if arr[mid] == se:\r\n            return mid\r\n         \r\n        elif arr[mid] > se:\r\n            return binarySearch(arr, low, mid-1, se)\r\n \r\n        else:\r\n            return binarySearch(arr, mid + 1, high, se)\r\n \r\n    else:\r\n        return -1\r\n \r\narr = [ 7, 18, 26, 38, 42,57,61,73,84,91 ]\r\nsearchelement = 73\r\n \r\nresult = binarySearch(arr, 0, len(arr)-1, searchelement)\r\n \r\nif result != -1:\r\n    print (\"Element is present at location % d\" % (result+1))\r\nelse:\r\n    print (\"Element is not present in array\")\r\n<\/pre>\n
Binary Search Iterative implementation in C<\/h4>\n
#include <stdio.h>\r\n \r\nint binarySearch(int arr[], int low, int high, int se)\r\n{\r\n    while (low <= high) {\r\n        int mid = low + (high - low) \/ 2;\r\n \r\n        if (arr[mid] == se)\r\n            return mid;\r\n \r\n        if (arr[mid] < se)\r\n            low = mid + 1;\r\n \r\n        else\r\n            high = mid - 1;\r\n    }\r\n \r\n    return -1;\r\n}\r\n \r\nint main(void)\r\n{\r\n    int arr[] = {7, 18, 26, 38, 42,57,61,73,84,91 };\r\n    int len = sizeof(arr) \/ sizeof(arr[0]);\r\n    int searchelement = 73;\r\n    int result = binarySearch(arr, 0, len - 1, searchelement);\r\n    if(result == -1)\r\n    printf(\"Element is not present\");\r\n    else\r\n    printf(\"Element present at location: %d\",result+1);\r\n    return 0;\r\n}\r\n<\/pre>\n
Iterative implementation of Binary Search in C++<\/h4>\n
#include <bits\/stdc++.h>\r\nusing namespace std;\r\n \r\nint binarySearch(int arr[], int low, int high, int se)\r\n{\r\n    while (low <= high) {\r\n        int mid = low + (high - low) \/ 2;\r\n \r\n        if (arr[mid] == se)\r\n            return mid;\r\n \r\n        if (arr[mid] < se)\r\n            low = mid + 1;\r\n \r\n        else\r\n            high = mid - 1;\r\n    }\r\n \r\n    return -1;\r\n}\r\n \r\nint main(void)\r\n{\r\n    int arr[] = {7, 18, 26, 38, 42,57,61,73,84,91 };\r\n    int len = sizeof(arr) \/ sizeof(arr[0]);\r\n    int searchelement = 73;\r\n    int result = binarySearch(arr, 0, len - 1, searchelement);\r\n    if(result == -1)\r\n    cout << \"Element is not present\" ;\r\n    else\r\n    cout << \"Element present at index \" << result+1;\r\n    return 0;\r\n}\r\n\r\n\r\n\r\n<\/pre>\n
Iterative implementation of Binary Search in Java<\/h4>\n
public class BinarySearch {\r\n\r\n    int binarySearch(int arr[], int se)\r\n    {\r\n        int low = 0, high = arr.length - 1;\r\n        while (low <= high) {\r\n            int mid = low + (high - low) \/ 2;\r\n \r\n            if (arr[mid] == se)\r\n                return mid;\r\n \r\n            if (arr[mid] < se)\r\n                low = mid + 1;\r\n \r\n            else\r\n                high = mid - 1;\r\n        }\r\n \r\n        return -1;\r\n    }\r\n \r\n    public static void main(String args[])\r\n    {\r\n        BinarySearch ob = new BinarySearch();\r\n        int arr[] = { 7, 18, 26, 38, 42,57,61,73,84,91 };\r\n        int searchelement = 73;\r\n        int result = ob.binarySearch(arr, searchelement);\r\n        if (result == -1)\r\n            System.out.println(\"Element not present\");\r\n        else\r\n            System.out.println(\"Element present at location: \" + (result+1));\r\n    }\r\n}\r\n<\/pre>\n
Binary Search Iterative implementation in Python<\/h4>\n
def binarySearch(arr, low, high, se):\r\n \r\n    while low <= high:\r\n \r\n        mid = low + (high - low) \/\/ 2;\r\n       \r\n        if arr[mid] == se:\r\n            return mid\r\n \r\n        elif arr[mid] < se:\r\n            low = mid + 1\r\n \r\n        else:\r\n            high = mid - 1\r\n  \r\n    return -1\r\n \r\narr = [ 7, 18, 26, 38, 42,57,61,73,84,91 ]\r\nsearchelement = 73\r\n \r\nresult = binarySearch(arr, 0, len(arr)-1, searchelement)\r\n \r\nif result != -1:\r\n    print (\"Element present at location: % d\" % (result+1))\r\nelse:\r\n    print (\"Element is not present in array\")\r\n<\/pre>\n
Complexity of Binary Search<\/h3>\n
The best-case scenario for binary search is when the search element is present at the middle location in the first iteration only.<\/span><\/p>\n\n\n\n\n\n\n\n
<\/td>\nScenario<\/b><\/td>\ncomplexity<\/b><\/td>\n<\/tr>\n
Time Complexity<\/b><\/td>\nWorst case<\/span><\/td>\nO(log n)<\/span><\/td>\n<\/tr>\n
Average case<\/span><\/td>\nO(log n)<\/span><\/td>\n<\/tr>\n
Best case<\/span><\/td>\nO(1)<\/span><\/td>\n<\/tr>\n
Space complexity<\/b><\/td>\nWorst case<\/span><\/td>\nO(1)<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Linear search vs Binary search<\/h3>\n\n\n\n\n\n\n\n\n\n
Linear search<\/b><\/td>\nBinary search<\/b><\/td>\n<\/tr>\n
Elements are not required to be in sorted arrangement<\/span><\/td>\nElements are compulsorily required to be in sorted arrangement<\/span><\/td>\n<\/tr>\n
Based on a sequential approach<\/span><\/td>\nBased on the divide and conquer technique<\/span><\/td>\n<\/tr>\n
Compares the search element with each element of the dataset<\/span><\/td>\nCompares the search element with only some elements of the dataset<\/span><\/td>\n<\/tr>\n
Linear search is implementable on any linear data structure like a linked list or array.<\/span><\/td>\nImplementation is possible only on datasets having 2-way traversal<\/span><\/td>\n<\/tr>\n
Preferred for small size input data set<\/span><\/td>\nPreferred for a large input data set<\/span><\/td>\n<\/tr>\n
Worst case scenario O(n)<\/span><\/td>\nWorst case scenario O(log n)<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Applications of Binary Search<\/h3>\n
1. It is used in libraries of programming languages like JAVA, .Net, and C++
\n2. It is used to pinpoint the place of error during debugging.<\/p>\n
Conclusion<\/h3>\n
Binary search is a faster, efficient, and widely used algorithm for searching in a dataset. We have seen the working of binary search and its implementation in this article.<\/p>\n
Binary search is usually preferred for large inputs and unknowingly used by us in daily life. For example, searching for a roll number in a university database can be efficiently done by binary search.<\/p>\n","protected":false},"excerpt":{"rendered":"
Suppose you want to search for a word starting with \u2018U\u2019 in a dictionary. A dictionary has thousands of words arranged in ascending order. If you start from the beginning and keep on searching...<\/p>\n","protected":false},"author":7,"featured_media":96561,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[24020],"tags":[24483,21621,24484],"class_list":["post-96389","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-data-structure-tutorials","tag-binary-search","tag-binary-search-algorithm","tag-binary-search-in-data-structure"],"yoast_head":"\nBinary Search in Data Structure - DataFlair<\/title>\n<meta name=\"description\" content=\"Binary search is an efficient algorithm for finding an item from a sorted list of items. Learn more about it, its algorithm and example.\" \/>\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\/binary-search\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Binary Search in Data Structure - DataFlair\" \/>\n<meta property=\"og:description\" content=\"Binary search is an efficient algorithm for finding an item from a sorted list of items. Learn more about it, its algorithm and example.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/data-flair.training\/blogs\/binary-search\/\" \/>\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-11T03:30:20+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2021\/06\/Binary-Search.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=\"8 minutes\" \/>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Binary Search in Data Structure - DataFlair","description":"Binary search is an efficient algorithm for finding an item from a sorted list of items. Learn more about it, its algorithm and example.","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\/binary-search\/","og_locale":"en_US","og_type":"article","og_title":"Binary Search in Data Structure - DataFlair","og_description":"Binary search is an efficient algorithm for finding an item from a sorted list of items. Learn more about it, its algorithm and example.","og_url":"https:\/\/data-flair.training\/blogs\/binary-search\/","og_site_name":"DataFlair","article_publisher":"https:\/\/www.facebook.com\/DataFlairWS\/","article_published_time":"2021-06-11T03:30:20+00:00","og_image":[{"width":1200,"height":628,"url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2021\/06\/Binary-Search.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":"8 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/data-flair.training\/blogs\/binary-search\/#article","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/binary-search\/"},"author":{"name":"DataFlair Team","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/person\/beb0cab24b7aa54423a3b50e669a9dcd"},"headline":"Binary Search in Data Structure","datePublished":"2021-06-11T03:30:20+00:00","mainEntityOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/binary-search\/"},"wordCount":626,"commentCount":0,"publisher":{"@id":"https:\/\/data-flair.training\/blogs\/#organization"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/binary-search\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2021\/06\/Binary-Search.jpg","keywords":["Binary Search","Binary Search Algorithm","Binary Search in Data Structure"],"articleSection":["Data Structure Tutorials"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/data-flair.training\/blogs\/binary-search\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/data-flair.training\/blogs\/binary-search\/","url":"https:\/\/data-flair.training\/blogs\/binary-search\/","name":"Binary Search in Data Structure - DataFlair","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/#website"},"primaryImageOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/binary-search\/#primaryimage"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/binary-search\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2021\/06\/Binary-Search.jpg","datePublished":"2021-06-11T03:30:20+00:00","description":"Binary search is an efficient algorithm for finding an item from a sorted list of items. Learn more about it, its algorithm and example.","breadcrumb":{"@id":"https:\/\/data-flair.training\/blogs\/binary-search\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/data-flair.training\/blogs\/binary-search\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/data-flair.training\/blogs\/binary-search\/#primaryimage","url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2021\/06\/Binary-Search.jpg","contentUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2021\/06\/Binary-Search.jpg","width":1200,"height":628,"caption":"Binary Search"},{"@type":"BreadcrumbList","@id":"https:\/\/data-flair.training\/blogs\/binary-search\/#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":"Binary Search 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\/96389","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=96389"}],"version-history":[{"count":4,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/96389\/revisions"}],"predecessor-version":[{"id":96567,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/96389\/revisions\/96567"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media\/96561"}],"wp:attachment":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media?parent=96389"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/categories?post=96389"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/tags?post=96389"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}