{"id":81836,"date":"2021-07-09T09:00:02","date_gmt":"2021-07-09T03:30:02","guid":{"rendered":"https:\/\/techvidvan.com\/tutorials\/?p=81836"},"modified":"2021-07-09T09:00:02","modified_gmt":"2021-07-09T03:30:02","slug":"insertion-sort","status":"publish","type":"post","link":"https:\/\/techvidvan.com\/tutorials\/insertion-sort\/","title":{"rendered":"Insertion Sort in Data Structure"},"content":{"rendered":"

Insertion sort is a comparison-based sorting algorithm mostly suited for small datasets. Insertion sort has wide practical implementations. For example, sorting of play cards is an implementation of insertion sort. Arranging randomly arranged answer sheets in the ascending order of roll numbers is also an example of insertion sort.<\/p>\n

What is Insertion Sort?<\/h3>\n

In insertion sort, there are two lists in the array at every point: A partially sorted list and an unsorted list. Thus, we virtually split the array into sorted and unsorted parts.<\/p>\n

Every time we pick up an element from the unsorted array and place it in the partially sorted array. Thus, we insert the elements from an unsorted array at their correct position in the sorted array. That is why the name Insertion.<\/strong> It is not suitable for very large datasets.<\/p>\n

Insertion sort is a stable element. The order of duplicate elements is preserved after the sorting is performed.<\/p>\n

Insertion Sort Algorithm<\/h3>\n
Step 1: For i = 1 to n-1\nStep 2: Set temp = array[i]\nStep 3: Set j = i-1\nStep 4:  while temp <= array[j]\n             Set array[j + 1] = array[j]\n             Set j = j-1\nStep 5:  Set array[j + 1] = temp\nStep 6: END\n<\/pre>\n
Insertion Sort Pseudo-code<\/h3>\n
Procedure Insertion_sort(int Arr)\n    int insert_at_position, insert_value;\n    for int i = 1 to length.Arr :\n        insert_value = Arr[i]\n        insert_at_position = i\n        while insert_at_position > 0 and Arr[insert_at_position-1] > insert_value:\n         Arr[insert_at_position] = Arr[insert_at_position-1]\n         insert_at_position = insert_at_position -1\n      END while\n      Arr[insert_at_position] = insert_value\n    END for\nEND procedure\n<\/pre>\n
Working of Insertion Sort<\/h3>\n
Let us understand the working of insertion sort with the help of an example. Suppose we wish to sort the elements of the word \u201cTECHVIDVAN\u201d in alphabetical order. Then, we will proceed as follows:<\/p>\n
\"insertion<\/a><\/p>\n
In each iteration, we will bring one element from the unsorted list to the sorted list and place it at its correct position.<\/p>\n
Iteration 1:<\/p>\n
\"insertion<\/a><\/p>\n
Iteration 2:<\/p>\n
\"Insertion<\/a><\/p>\n
Iteration 3:<\/p>\n
\"Insertion<\/a>
\nIteration 4:<\/p>\n
\"Insertion<\/a><\/p>\n
Iteration 5:<\/p>\n
\"Insertion<\/a><\/p>\n
Iteration 6:<\/p>\n
\"Iterations<\/a><\/p>\n
Iteration 7:<\/p>\n
\"Insertion<\/a>
\nIteration 8:<\/p>\n
\"Insertion<\/a><\/p>\n
Iteration 9:<\/p>\n
\"insertion<\/a><\/p>\n
Finally, after the 9th iteration, we have got the sorted array.<\/p>\n
We need to note here that the insertion sort is a stable sorting algorithm. Thus, the order of duplicates is preserved. Here, we have two duplicate elements- \u2018V\u2019. thus, the order of both the \u2018V\u2019s will remain the same before and after sorting.<\/p>\n
Insertion Sort Implementation in C<\/h3>\n
#include <stdio.h>\nvoid Insertion_sort(int Arr[], int n) \n{\n  for (int position=1; position<size; position++) \n  {\n    int val = Arr[position];\n    int j = position - 1;\n    while (val < Arr[j] && j >= 0) \n    {\n      Arr[j+1] = Arr[j];\n      --j;\n    }\n    Arr[j + 1] = val;\n  }\n}\nint main() \n{\n  int Arr[] = {20, 80, 12, 34, 1, 56, 100, 7, 21, 15};\n  int len = sizeof(Arr) \/ sizeof(Arr[0]);\n  Insertion_sort(Arr, len);\n  printf(\"The sorted array is: \\n\");\n  for (int index = 0; index < len; index++) \n    printf(\"%d \", Arr[i]);\n  printf(\"\\n\");\n}\n<\/pre>\n
Insertion Sort Implementation in C++<\/h3>\n
#include <bits\/stdc++.h>\nusing namespace std;\n\nvoid Insertion_sort(int Arr[], int n) \n{\n  for (int position = 1; position<n; position++) \n  {\n    int val = Arr[position];\n    int j = position - 1;\n    while (val < Arr[j] && j >= 0) \n    {\n      Arr[j+1] = Arr[j];\n      --j;\n    }\n    Arr[j + 1] = val;\n  }\n}\nint main() \n{\n  int Arr[] = {20, 80, 12, 34, 1, 56, 100, 7, 21, 15};\n  int len = sizeof(Arr) \/ sizeof(Arr[0]);\n  Insertion_sort(Arr, len);\n  cout << \"Sorted array:\\n\";\n  for (int i = 0; i < len; i++) \n  {\n    cout << \"The sorted arrayis:  \" << Arr[i];\n  }\n  cout << \"\\n\";\n  return 0;\n}\n<\/pre>\n
Implementation of Insertion Sort in Java<\/h3>\n
public class insertionSort \n{\n  void Insertion_sort(int Arr[]) \n  {\n    int len = Arr.length;\n    for (int position = 1; position<len; position++) \n    {\n      int val = Arr[pos];\n      int j = position - 1;\n      while (j >= 0 && val < Arr[j]) \n      {\n        Arr[j + 1] = Arr[j];\n        --j;\n      }\n      Arr[j + 1] = val;\n    }\n  }\n  public static void main(String args[]) \n{\n    int data[] = {20, 80, 12, 34, 1, 56, 100, 7, 21, 15};\n    insertionSort is = new insertionSort();\n    is.Insertion_sort(data);\n    System.out.println(\"The sorted Array is: \");\n    for (int i=0;i<data.length; i++)\n    System.out.print(data[i] + \" \");\n  }\n}\n<\/pre>\n
Insertion Sort Implementation in Python<\/h3>\n
def Insertion_sort(Arr):\n    for position in range(1, len(Arr)):\n        value = Arr[position]\n        j = position - 1\n        \n        while j >= 0 and value < array[j]:\n            Arr[j + 1] = Arr[j]\n            j = j - 1\n        \n        Arr[j + 1] = value\nlist = [20, 80, 12, 34, 1, 56, 100, 7, 21, 15]\nInsertion_sort(list)\nprint('The sorted Array is:')\nprint(list)\n<\/pre>\n
Complexity Analysis of Insertion Sort<\/h3>\n
The time complexity of the insertion sort algorithm is mainly dependent on two operations- the number of comparison operations and the number of swaps.
\nFor insertion sort, the time complexities are:<\/p>\n\n\n\n\n\n\n
Scenario\u00a0<\/b><\/td>\nTime complexity<\/b><\/td>\n<\/tr>\n
Best case<\/span><\/td>\nO(1)<\/span><\/td>\n<\/tr>\n
Average case<\/span><\/td>\nO(n2<\/sup><\/span>)<\/span><\/td>\n<\/tr>\n
Worst case<\/span><\/td>\nO(n2<\/sup><\/span>)<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
The space complexity for insertion sort is O(1).<\/p>\n
Insertion Sort for Singly Linked List<\/h3>\n
A singly-linked list is a linear data structure. Hence, just like an array, we can apply insertion sort on the linked list elements as well.<\/p>\n
The following steps need to be followed:<\/p>\n
1:<\/strong> The first step is to create an empty list, which will always be sorted.<\/p>\n
2:<\/strong> Start traversing the list.<\/p>\n
3:<\/strong> As we traverse the list, insert the current node each time, in a sorted way into the linked list.<\/p>\n
4:<\/strong> Point the head of the given list to that of the sorted linked list.<\/p>\n
Insertion Sort Implementation for Linked List using C++<\/h3>\n
#include <bits\/stdc++.h>\nusing namespace std;\n \nstruct Node {\n    int key;\n    struct Node* Next;\n    Node(int x)\n    {\n        key = x;\n        Next = NULL;\n    }\n};\n \nclass LinkedList {\n \npublic:\n    Node* Head;\n    Node* sorted_list;\n \n    void Push(int key)\n    {\n        Node* New_node = new Node(key);\n        New_node->Next = Head;\n        Head = New_node;\n    }\n    void Insertion_sort(Node* Head_ref)\n    {\n        sorted_list = NULL;\n        Node* current = Head_ref;\n        while (current != NULL) {\n            Node* Next = current->Next;\n            Insert_into_sorted(current);\n            current = Next;\n        }\n        Head = sorted_list;\n    }\n \n  \n    void Insert_into_sorted(Node* New_node)\n    {\n        if (sorted_list == NULL || sorted_list->key >= New_node->key) {\n            New_node->Next = sorted_list;\n            sorted_list = New_node;\n        }\n        else {\n            Node* current = sorted_list;\n            while (current->Next != NULL && current->Next->key < New_node->key) {\n                current = current->Next;\n            }\n            New_node->Next = current->Next;\n            current->Next = New_node;\n        }\n    }\n    void Display_list(Node* Head)\n    {\n        while (head != NULL) {\n            cout << Head->key << \" \";\n            Head = Head->Next;\n        }\n    }\n};\n\nint main()\n{\n    LinkedList list;\n    list.Head = NULL;\n    list.push(10);\n    list.push(40);\n    list.push(8);\n    list.push(7);\n    list.push(52);\n    cout << \"Before sorting, the linked list is: \" << endl;\n    list.Display_list(list.Head);\n    cout << endl;\n    list.Insertion_sort(list.Head);\n    cout << \"Linked List After sorting: \" << endl;\n    list.Display_list(list.Head);\n}\n<\/pre>\n
Implementation of Insertion Sort for Linked List using Java:<\/h3>\n
public class LinkedList\n{\n  node Head;\n  node sorted_list;\n\n  class node\n  {\n    int key;\n    node Next;\n\n    public node(int key)\n    {\n      this.key = key;\n    }\n  }\n\n  void Push(int key)\n  {\n    node New_node = new node(key);\n    New_node.Next = Head;\n    Head = New_node;\n  }\n\n  void Insertion_sort(node Head_ref)\n  {\n    sorted_list = null;\n    node current = Head_ref;\n    while (current != null)\n    {\n      node Next = current.Next;\n      Insert_into_sorted(current);\n      current = Next;\n    }\n    Head = sorted_list;\n  }\n\n  void Insert_into_sorted(node New_node)\n  {\n    if (sorted_list == null || sorted_list.key >= New_node.key)\n    {\n      New_node.Next = sorted_list;\n      sorted_list = New_node;\n    }\n    else\n    {\n      node current = sorted_list;\n      while (current.Next != null && current.Next.key < New_node.key)\n      {\n        current = current.Next;\n      }\n      New_node.Next = current.Next;\n      current.Next = New_node;\n    }\n  }\n\n  void Display_list(node Head)\n  {\n    while (Head != null)\n    {\n      System.out.print(Head.key + \" \");\n      Head = Head.Next;\n    }\n  }\n\n  public static void main(String[] args)\n  {\n    LinkedList list = new LinkedList();\n    list.push(10);\n    list.push(40);\n    list.push(8);\n    list.push(7);\n    list.push(52);\n    System.out.println(\"Linked List before Sorting is:\");\n    list.Display_list(list.Head);\n    list.Insertion_sort(list.Head);\n    System.out.println(\"\\nLinkedList After sorting is:\");\n    list.Display_list(list.Head);\n  }\n}\n<\/pre>\n
Insertion Sort Implementation for Linked List using Python:<\/h3>\n
class Node:\n  def __init__(self, key):\n    self.keya = key\n    self.Next = None\n\ndef Insertion_sort(Head_ref):\n  sorted_list = None\n  current = Head_ref\n  while (current != None):\n    Next = current.Next\n    sorted_list = Insert_into_sorted(sorted_list, current)\n    current = Next\n  Head_ref = sorted_list\n  return Head_ref\n\ndef Insert_into_sorted(Head_ref, New_node):\n\n  current = None\n  if (Head_ref == None or (Head_ref).key >= New_node.key):\n  \n    New_node.Next = Head_ref\n    Head_ref = New_node\n  \n  else:\n    while (current.Next != None and current.Next.key < New_node.key):\n      current = current.Next\n    New_node.Next = current.Next\n    current.Next = New_node\n  return Head_ref\n\ndef Display_list(Head):\n  temp = Head\n  while(temp != None):\n    print( temp.key, end = \" \")\n    temp = temp.Next\n    \ndef push( head_ref, new_data):\n  New_node = Node(0)\n  New_node.key = New_key\n  New_node.Next = (Head_ref)\n  (Head_ref) = New_node\n  return Head_ref\n\na = None\na = push(a, 10)\na = push(a, 40)\na = push(a, 8)\na = push(a, 7)\na = push(a, 52)\n\nprint(\"Linked List before sorting is: \")\nDisplay_list(a)\n\na = Insertion_sort(a)\n\nprint(\"\\nLinked List after sorting is: \")\nDisplay_list(a)\n<\/pre>\n
Applications of Insertion Sort<\/h3>\n
    \n
  • Insertion sort is the best algorithm when the number of elements is small i.e. for a small input size.<\/li>\n
  • Insertion sort is also the best when the data is already sorted. This is because insertion sort takes the least execution time in such a case as compared to other sorting techniques.<\/li>\n
  • When we don\u2019t have access to all the data initially, we use insertion sort. This is because insertion sort never requires all the elements at a time for sorting. Thus, it is best suitable when the data is arriving one by one.<\/li>\n<\/ul>\n
    Conclusion<\/h3>\n
    Insertion sort in another sorting algorithm useful for small input size. It is best suited when we have online data i.e. the data arriving one by one. It is a stable sorting algorithm with a time complexity of O(n2).<\/p>\n
    In this article, we have learned the basic idea behind insertion sort. We have also seen the working and the implementation of insertion sort in various programming languages.<\/p>\n","protected":false},"excerpt":{"rendered":"
    Insertion sort is a comparison-based sorting algorithm mostly suited for small datasets. Insertion sort has wide practical implementations. For example, sorting of play cards is an implementation of insertion sort. Arranging randomly arranged answer...<\/p>\n","protected":false},"author":1,"featured_media":81853,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[3555],"tags":[3751,3752,3753,3754,3755,3756,3757],"class_list":["post-81836","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-data-structure","tag-insertion-sort-algorithm","tag-insertion-sort-applications","tag-insertion-sort-complexity","tag-insertion-sort-implementation","tag-insertion-sort-pseudo-code","tag-what-is-insertion-sort","tag-working-of-insertion-sort"],"yoast_head":"\nInsertion Sort in Data Structure - TechVidvan<\/title>\n<meta name=\"description\" content=\"Learn what is insertion sort with working, algorithm and implementation in various languages. See its applications and complexities.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/techvidvan.com\/tutorials\/insertion-sort\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Insertion Sort in Data Structure - TechVidvan\" \/>\n<meta property=\"og:description\" content=\"Learn what is insertion sort with working, algorithm and implementation in various languages. See its applications and complexities.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/techvidvan.com\/tutorials\/insertion-sort\/\" \/>\n<meta property=\"og:site_name\" content=\"TechVidvan\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/TechVidvan\/\" \/>\n<meta property=\"article:published_time\" content=\"2021-07-09T03:30:02+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2021\/06\/TV-insertion-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=\"TechVidvan Team\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@vidvantech\" \/>\n<meta name=\"twitter:site\" content=\"@vidvantech\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"TechVidvan Team\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"9 minutes\" \/>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Insertion Sort in Data Structure - TechVidvan","description":"Learn what is insertion sort with working, algorithm and implementation in various languages. See its applications and complexities.","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:\/\/techvidvan.com\/tutorials\/insertion-sort\/","og_locale":"en_US","og_type":"article","og_title":"Insertion Sort in Data Structure - TechVidvan","og_description":"Learn what is insertion sort with working, algorithm and implementation in various languages. See its applications and complexities.","og_url":"https:\/\/techvidvan.com\/tutorials\/insertion-sort\/","og_site_name":"TechVidvan","article_publisher":"https:\/\/www.facebook.com\/TechVidvan\/","article_published_time":"2021-07-09T03:30:02+00:00","og_image":[{"width":1200,"height":628,"url":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2021\/06\/TV-insertion-sort-in-DS.jpg","type":"image\/jpeg"}],"author":"TechVidvan Team","twitter_card":"summary_large_image","twitter_creator":"@vidvantech","twitter_site":"@vidvantech","twitter_misc":{"Written by":"TechVidvan Team","Est. reading time":"9 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/techvidvan.com\/tutorials\/insertion-sort\/#article","isPartOf":{"@id":"https:\/\/techvidvan.com\/tutorials\/insertion-sort\/"},"author":{"name":"TechVidvan Team","@id":"https:\/\/techvidvan.com\/tutorials\/#\/schema\/person\/e9c26e74dd3d87421f7ada9433b8cd22"},"headline":"Insertion Sort in Data Structure","datePublished":"2021-07-09T03:30:02+00:00","mainEntityOfPage":{"@id":"https:\/\/techvidvan.com\/tutorials\/insertion-sort\/"},"wordCount":651,"commentCount":0,"publisher":{"@id":"https:\/\/techvidvan.com\/tutorials\/#organization"},"image":{"@id":"https:\/\/techvidvan.com\/tutorials\/insertion-sort\/#primaryimage"},"thumbnailUrl":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2021\/06\/TV-insertion-sort-in-DS.jpg","keywords":["Insertion Sort Algorithm","Insertion Sort applications","Insertion Sort Complexity","Insertion Sort Implementation","Insertion Sort Pseudo-code","What is Insertion Sort?","Working of Insertion Sort"],"articleSection":["Data Structure Tutorials"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/techvidvan.com\/tutorials\/insertion-sort\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/techvidvan.com\/tutorials\/insertion-sort\/","url":"https:\/\/techvidvan.com\/tutorials\/insertion-sort\/","name":"Insertion Sort in Data Structure - TechVidvan","isPartOf":{"@id":"https:\/\/techvidvan.com\/tutorials\/#website"},"primaryImageOfPage":{"@id":"https:\/\/techvidvan.com\/tutorials\/insertion-sort\/#primaryimage"},"image":{"@id":"https:\/\/techvidvan.com\/tutorials\/insertion-sort\/#primaryimage"},"thumbnailUrl":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2021\/06\/TV-insertion-sort-in-DS.jpg","datePublished":"2021-07-09T03:30:02+00:00","description":"Learn what is insertion sort with working, algorithm and implementation in various languages. See its applications and complexities.","breadcrumb":{"@id":"https:\/\/techvidvan.com\/tutorials\/insertion-sort\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/techvidvan.com\/tutorials\/insertion-sort\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/techvidvan.com\/tutorials\/insertion-sort\/#primaryimage","url":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2021\/06\/TV-insertion-sort-in-DS.jpg","contentUrl":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2021\/06\/TV-insertion-sort-in-DS.jpg","width":1200,"height":628,"caption":"Insertion Sort in Data Structure"},{"@type":"BreadcrumbList","@id":"https:\/\/techvidvan.com\/tutorials\/insertion-sort\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/techvidvan.com\/tutorials\/"},{"@type":"ListItem","position":2,"name":"Insertion Sort in Data Structure"}]},{"@type":"WebSite","@id":"https:\/\/techvidvan.com\/tutorials\/#website","url":"https:\/\/techvidvan.com\/tutorials\/","name":"TechVidvan Blogs","description":"","publisher":{"@id":"https:\/\/techvidvan.com\/tutorials\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/techvidvan.com\/tutorials\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/techvidvan.com\/tutorials\/#organization","name":"TechVidvan","url":"https:\/\/techvidvan.com\/tutorials\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/techvidvan.com\/tutorials\/#\/schema\/logo\/image\/","url":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2024\/03\/techvidvan-logo-200x50-1.webp","contentUrl":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2024\/03\/techvidvan-logo-200x50-1.webp","width":200,"height":50,"caption":"TechVidvan"},"image":{"@id":"https:\/\/techvidvan.com\/tutorials\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/TechVidvan\/","https:\/\/x.com\/vidvantech"]},{"@type":"Person","@id":"https:\/\/techvidvan.com\/tutorials\/#\/schema\/person\/e9c26e74dd3d87421f7ada9433b8cd22","name":"TechVidvan Team","description":"The TechVidvan Team delivers practical, beginner-friendly tutorials on programming, Java, Python, C++, DSA, AI, ML, data Science, Android, Flutter, MERN, Web Development, and technology. Our experts are here to help you upskill and excel in today\u2019s tech industry."}]}},"amp_enabled":true,"_links":{"self":[{"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/posts\/81836","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/comments?post=81836"}],"version-history":[{"count":0,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/posts\/81836\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/media\/81853"}],"wp:attachment":[{"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/media?parent=81836"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/categories?post=81836"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/tags?post=81836"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}