feat:<Insertion sort> insertion sort content

Author: raj-rathod

src/app/components/Algorithms/sorting/insertion-sort/insertion-sort.component.html

@@ -1 +1,10 @@
-<h1 class="text-center"> Coming soon</h1>
+<h1 class="text-center">Insertion Sort</h1>
+<div class="mt-md-4 mt-3" [innerHtml]="insertionSortMetaData.defination"></div>
+<div class="mt-md-4 mt-3" [innerHtml]="insertionSortMetaData.explainImage"></div>
+<div class="mt-md-4 mt-3" [innerHtml]="insertionSortMetaData.properties"></div>
+<div class="mt-md-4 mt-3" [innerHtml]="insertionSortMetaData.flowChart"></div>
+<div class="mt-md-4 mt-3" [innerHtml]="insertionSortMetaData.workingProcedure"></div>
+<div class="mt-md-4 mt-3" [innerHtml]="insertionSortMetaData.applications"></div>
+<div class="mt-md-4 mt-3" [innerHtml]="insertionSortMetaData.other"></div>
+<div class="mt-md-4 mt-3" [innerHtml]="insertionSortMetaData.advantage"></div>
+<div class="mt-md-4 mt-3" [innerHtml]="insertionSortMetaData.disadvantage"></div>

src/app/components/Algorithms/sorting/insertion-sort/insertion-sort.component.ts

@@ -1,12 +1,13 @@
 import { Component, OnInit } from '@angular/core';
+import { insertionSortMetaData } from 'src/app/core/algorithms/sorting-meta-data';
 
 @Component({
   selector: 'app-insertion-sort',
   templateUrl: './insertion-sort.component.html',
   styleUrls: ['./insertion-sort.component.css']
 })
 export class InsertionSortComponent implements OnInit {
-
+  insertionSortMetaData = insertionSortMetaData;
   constructor() { }
 
   ngOnInit(): void {

src/app/components/Algorithms/sorting/selection-sort/selection-sort.component.html

@@ -1,4 +1,4 @@
-<h1 class="text-center">Selection Sort Algorithm</h1>
+<h1 class="text-center">Selection Sort</h1>
 <div class="mt-md-4 mt-3" [innerHtml]="selectionSortMetaData.defination"></div>
 <div class="mt-md-4 mt-3" [innerHtml]="selectionSortMetaData.explainImage"></div>
 <div class="mt-md-4 mt-3" [innerHtml]="selectionSortMetaData.properties"></div>

src/app/core/algorithms/sorting-meta-data.ts

@@ -50,7 +50,7 @@ export const sortingMetaData = {
     example: Helper.setExampleImage("Complexity and Stability of Sorting Algorithms", sortData.example),
 }
 
-// ------------------------------------------ Selection Sort Meta Data ------------------------------------------//
+// ------------------------------- Selection Sort Meta Data ----------------------------------------------//
 
 const selectionSortData = {
     defination: `Selection sort is a simple sorting algorithm. This sorting algorithm is an in-place comparison-based 
@@ -97,4 +97,67 @@ export const selectionSortMetaData: Algorithms = {
     disadvantage: Helper.setListwithTitleHtml('Selection Sort Disadvantages',selectionSortData.disadvantages),
     applications: Helper.setListwithTitleHtml('Selection Sort Applications',selectionSortData.applications),
     workingProcedure: Helper.setListwithTitleHtml('Follow the below steps to solve the problem',selectionSortData.workingProcedure),
-}
+}
+
+// ------------------------------------- End ----------------------------------------------------------------//
+
+// --------------------------------- Insertion Sort ---------------------------------------------------------//
+
+const insertionSortData = {
+  defination: `Insertion sort is a simple sorting algorithm that works similar to the way you sort playing cards 
+    in your hands. The array is virtually split into a sorted and an unsorted part. Values from the unsorted part 
+    are picked and placed at the correct position in the sorted part`,
+  flowChart:"assets/ds-image/DSA1.jpg",
+  explainImage:"assets/ds-image/DSA1.jpg",
+  workingProcedure:[
+    'Iterate from arr[1] to arr[N] over the array',
+    'Compare the current element (key) to its predecessor',
+    `If the key element is smaller than its predecessor, compare it to the elements before. 
+    Move the greater elements one position up to make space for the swapped element`
+  ],
+  properties:[
+    'This algorithm is one of the simplest algorithm with simple implementation',
+    'Basically, Insertion sort is efficient for small data values',
+    'Insertion sort is adaptive in nature, i.e. it is appropriate for data sets which are already partially sorted',
+    'Insertion sort is an in-place algorithm, meaning it requires no extra space',
+    'Maintains relative order of the input data in case of two equal values (stable)',
+    `the bubble sort performs poorly compared to the insertion sort. Due to the high number of swaps, 
+      it's expected to generate twice as many write operations and twice as many cache misses`,
+    `Insertion sort's advantage is that it only scans as many elements as it needs in order to place the k+1st element,
+      while selection sort must scan all remaining elements to find the k+1st element. Experiments show that insertion 
+      sort usually performs about half as many comparisons as selection sort`
+  ],
+  applications:[
+    `One more real-world example of insertion sort is how tailors arrange shirts in a cupboard, they always keep them in sorted 
+     order of size and thus insert new shirts at the right position very quickly by moving other shirts forward to keep the right 
+     place for a new shirt`
+  ],
+  advantages: [
+    `The main advantage of the insertion sort is its simplicity. It also exhibits a good performance when dealing with a small list. 
+      The insertion sort is an in-place sorting algorithm so the space requirement is minimal`
+  ],
+  disadvantages: [
+    `The disadvantage of the insertion sort is that it does not perform as well as other, better sorting algorithms. 
+     With n-squared steps required for every n element to be sorted, the insertion sort does not deal well with a huge list. 
+     Therefore, the insertion sort is particularly useful only when sorting a list of few items`
+  ],
+  performance:[
+    'Worst-case performance of insertion sort is O(n²) comparisons and swaps',
+    'Best-case performance is O(n) comparisons and O(1) swaps',
+    'Average-case performance is O(n²) comparisons and swaps'
+  ]
+}
+
+export const insertionSortMetaData: Algorithms = {
+  defination: Helper.setHeader(insertionSortData.defination),
+  properties: Helper.setListwithTitleHtml('Insertion Sort Properties', insertionSortData.properties),
+  explainImage: Helper.setExampleImage('Insertion Sort Explain Image', insertionSortData.explainImage),
+  flowChart: Helper.setExampleImage('Insertion Sort Flowchart',insertionSortData.flowChart),
+  advantage: Helper.setListwithTitleHtml('Insertion Sort Advantages',insertionSortData.advantages),
+  disadvantage: Helper.setListwithTitleHtml('Insertion Sort Disadvantages',insertionSortData.disadvantages),
+  applications: Helper.setListwithTitleHtml('Insertion Sort Applications',insertionSortData.applications),
+  other: Helper.setListwithTitleHtml('Insertion Sort Performance',insertionSortData.performance),
+  workingProcedure: Helper.setListwithTitleHtml('Follow the below steps to solve the problem',insertionSortData.workingProcedure),
+}
+
+// ------------------------------------- End ----------------------------------------------------------------//