Merge pull request #97 from raj-rathod/rajesh

Rajesh

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/backtracking-meta-data.ts

@@ -17,7 +17,7 @@ const backtracking = {
     at 'A' and we divided our problem into three smaller sub-probelms 'B', 'D' and 'F'. And using this sub-problem, we have three 
     possible path to get to our solution -- 'C', 'E', & 'G'.`,
 
-    example:'assets/ds-image/backtracking.jpg',
+    example:'assets/ds-image/DSA1.jpg',
 
     properties:[
         `A backtracking algorithm uses the depth-first search method. When it starts exploring the solutions, a bounding function is 

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

@@ -8,7 +8,7 @@ const greedyData = {
    This algorithm may not produce the best result for all the problems. It's because it always goes for the local best 
    choice to produce the global best result.
    `,
-   example: 'assets/ds-image/greedy.jpg',
+   example: 'assets/ds-image/DSA1.jpg',
    properties:[
     `<b>Greedy Choice Property:</b> If an optimal solution to the problem can be found by choosing the best choice at 
     each step without reconsidering the previous steps once chosen, the problem can be solved using a greedy approach. 

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

@@ -50,16 +50,16 @@ 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 
     algorithm in which the list is divided into two parts, the sorted part at the left end and the unsorted part at the right end.
     Initially, the sorted part is empty and the unsorted part is the entire list. <br>
     The smallest element is selected from the unsorted array and swapped with the leftmost element, and that element becomes 
     a part of the sorted array. This process continues moving unsorted array boundary by one element to the right.`,
-    flowChart:"assets/ds-image/selection-sort.jpg",
-    explainImage:"assets/ds-image/explainImage.jpg",
+    flowChart:"assets/ds-image/DSA1.jpg",
+    explainImage:"assets/ds-image/DSA1.jpg",
     workingProcedure:[
         'Initialize minimum value(minValue) to location 0.',
         'Traverse the array to find the minimum element in the array.',
@@ -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 ----------------------------------------------------------------//