From ac275bb9142dbcfd40e8b5e4542a59e14a334d5e Mon Sep 17 00:00:00 2001 From: ajay-dhangar <99037494+ajay-dhangar@users.noreply.github.com> Date: Fri, 8 Nov 2024 07:22:43 +0000 Subject: [PATCH 1/5] update contributors list in README --- README.md | 332 +++++++++++++++++++++++++++--------------------------- 1 file changed, 166 insertions(+), 166 deletions(-) diff --git a/README.md b/README.md index 653dcca76..4bfeca25d 100644 --- a/README.md +++ b/README.md @@ -289,19 +289,19 @@ Thanks to these amazing people who have contributed to the **Algo** project: - - Meetpidev + + shuvojitss
- Meet Shah + Shuvojit Samanta - - shuvojitss + + Meetpidev
- Shuvojit Samanta + Meet Shah @@ -333,19 +333,19 @@ Thanks to these amazing people who have contributed to the **Algo** project: - - PrAyAg9 + + Shariq2003
- Prayag Thakur + Shariq - - AE-Hertz + + MithanshuHedau
- Abhinandan + Mithanshu Hedau @@ -356,17 +356,24 @@ Thanks to these amazing people who have contributed to the **Algo** project: - - MithanshuHedau + + AE-Hertz
- Mithanshu Hedau + Abhinandan - - Shariq2003 + + PrAyAg9
- Shariq + Prayag Thakur + + + + + shriyadindi +
+ Shriya Dindi @@ -376,6 +383,8 @@ Thanks to these amazing people who have contributed to the **Algo** project: Mugundh J B + + pratheekv39 @@ -383,8 +392,6 @@ Thanks to these amazing people who have contributed to the **Algo** project: V Pratheek - - monishkumardvs @@ -392,13 +399,6 @@ Thanks to these amazing people who have contributed to the **Algo** project: Dvs monish kumar - - - shriyadindi -
- Shriya Dindi - - aditiverma-21 @@ -407,47 +407,54 @@ Thanks to these amazing people who have contributed to the **Algo** project: - - Alpha1zln + + Subashree-selvaraj
- SHREYAS YADUVANSHI + subashree - - Rashigera + + Abhishek2634
- Rashigera + Abhishek Farshwal - - Abhishek2634 + + KashishJuneja101003
- Abhishek Farshwal + Kashish Juneja - - Subashree-selvaraj + + jainaryan04
- subashree + Aryan Ramesh Jain - - KashishJuneja101003 + + Alpha1zln
- Kashish Juneja + SHREYAS YADUVANSHI - - T-Fathima + + Rashigera
- Tatheer Fathima + Rashigera + + + + + Riddhi12349 +
+ riddhi @@ -457,6 +464,15 @@ Thanks to these amazing people who have contributed to the **Algo** project: Kundan Rajoria + + + T-Fathima +
+ Tatheer Fathima + + + + Mansi07sharma @@ -465,14 +481,12 @@ Thanks to these amazing people who have contributed to the **Algo** project: - - Riddhi12349 + + mehul-m-prajapati
- riddhi + Mehul Prajapati - - tanishqkolhatkar93 @@ -487,13 +501,6 @@ Thanks to these amazing people who have contributed to the **Algo** project: PavanTeja2005 - - - mehul-m-prajapati -
- Mehul Prajapati - - sarthaxtic @@ -501,13 +508,6 @@ Thanks to these amazing people who have contributed to the **Algo** project: sarthaxtic - - - jainaryan04 -
- Aryan Ramesh Jain - - shimmer12 @@ -532,54 +532,47 @@ Thanks to these amazing people who have contributed to the **Algo** project: - - jvkousthub + + AKSHITHA-CHILUKA
- Kousthub J V + ~Chiluka Akshitha - - govindumeesala + + LitZeus
- Meesala Govindu + Tejas Athalye - - sriraghavi22 + + Siddhart2004
- sriraghavi22 + SIDDHARTH A - - AKSHITHA-CHILUKA + + sriraghavi22
- ~Chiluka Akshitha + sriraghavi22 - - LitZeus -
- Tejas Athalye - - - - - Siddhart2004 + + jvkousthub
- SIDDHARTH A + Kousthub J V - - anshika-1102 + + govindumeesala
- anshika-1102 + Meesala Govindu @@ -596,6 +589,13 @@ Thanks to these amazing people who have contributed to the **Algo** project: Aadesh_Kumar + + + anshika-1102 +
+ anshika-1102 + + Saaarthak0102 @@ -627,17 +627,17 @@ Thanks to these amazing people who have contributed to the **Algo** project: - - Bhumika-00 + + AswaniBolisetti
- Bhumika Sharma + Aswani Bolisetti - - AswaniBolisetti + + AnushkaChouhan25
- Aswani Bolisetti + Anushka Chouhan @@ -649,20 +649,6 @@ Thanks to these amazing people who have contributed to the **Algo** project: - - - Jivanjamadar -
- Jivan - - - - - Lighting-pixel -
- Ayan - - Shantnu-singh @@ -677,13 +663,6 @@ Thanks to these amazing people who have contributed to the **Algo** project: Kunika Makker - - - samar12-rad -
- Samarth Vaidya - - c4dr-me @@ -691,8 +670,6 @@ Thanks to these amazing people who have contributed to the **Algo** project: c4dr-me - - alo7lika @@ -714,18 +691,41 @@ Thanks to these amazing people who have contributed to the **Algo** project: Shudarsan Regmi + + - - shashmitha46 + + samar12-rad
- Shashmitha V + Samarth Vaidya - - Dishaaa-T + + Richajaishwal0
- Disha T + Richa jaishwal + + + + + Bhumika-00 +
+ Bhumika Sharma + + + + + Lighting-pixel +
+ Ayan + + + + + Jivanjamadar +
+ Jivan @@ -745,24 +745,24 @@ Thanks to these amazing people who have contributed to the **Algo** project: - - IRFANSARI + + Dishaaa-T
- Irfan Ansari + Disha T - - AnushkaChouhan25 + + IRFANSARI
- Anushka Chouhan + Irfan Ansari - - 17arindam + + shashmitha46
- Arindam + Shashmitha V @@ -789,54 +789,54 @@ Thanks to these amazing people who have contributed to the **Algo** project: - - Bhum-ika + + souvikpramanikgit
- Bhumika Sharma + Souvik Kumar Pramanik - - Kunj05 + + Soumya03007
- Kunj Chandak + Soumyadeep Paul - - narendra-dhangar + + kaabilcoder
- Narendra Dhangar + Saurabh Kumar Sahu - - kaabilcoder + + narendra-dhangar
- Saurabh Kumar Sahu + Narendra Dhangar - - souvikpramanikgit + + Kunj05
- Souvik Kumar Pramanik + Kunj Chandak - - Soumya03007 + + Bhum-ika
- Soumyadeep Paul + Bhumika Sharma - - KGupta2601 + + 17arindam
- Kashika + Arindam @@ -847,17 +847,17 @@ Thanks to these amazing people who have contributed to the **Algo** project: - - smog-root + + KGupta2601
- smog-root + Kashika - - ADITHYA-NS + + smog-root
- Adithya N S + smog-root @@ -877,17 +877,17 @@ Thanks to these amazing people who have contributed to the **Algo** project: - - meghanakn473 + + ADITHYA-NS
- K N Meghana + Adithya N S - - Richajaishwal0 + + meghanakn473
- Richa jaishwal + K N Meghana From a189be6e6fd7bf269dce555cc12880a57457c4e8 Mon Sep 17 00:00:00 2001 From: Aryan Ramesh Jain <138214350+jainaryan04@users.noreply.github.com> Date: Fri, 8 Nov 2024 12:57:40 +0530 Subject: [PATCH 2/5] blog on comparing sorting algorithms #1940 --- blog/comparing-sortings.md | 98 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 98 insertions(+) create mode 100644 blog/comparing-sortings.md diff --git a/blog/comparing-sortings.md b/blog/comparing-sortings.md new file mode 100644 index 000000000..022272fe4 --- /dev/null +++ b/blog/comparing-sortings.md @@ -0,0 +1,98 @@ +--- +slug: comparing-sorting-algorithms +title: Comparing the different Sorting Algorithms +authors: [ARYAN-JAIN] +tags: [ARYAN-JAIN, algo, dsa, algorithms, sorting, time-complexity] +--- + +# Comparison of Sorting Algorithms + +Sorting algorithms are essential for organizing data, making it easier to analyze, search, and manipulate. Here’s an overview of some commonly used sorting algorithms, comparing their time complexity, efficiency, and applications. + +## 1. Bubble Sort +**Description**: Bubble Sort repeatedly steps through the list, compares adjacent elements, and swaps them if needed until the list is sorted. + +- **Time Complexity**: \(O(n^2)\) average and worst-case; \(O(n)\) best-case (already sorted) +- **Space Complexity**: \(O(1)\) +- **Pros**: Simple and easy to implement +- **Cons**: Inefficient for large datasets +- **Use Case**: Suitable for small or nearly sorted datasets + +## 2. Selection Sort +**Description**: Selection Sort divides the list into sorted and unsorted parts, finding the minimum element in the unsorted part and placing it in order. + +- **Time Complexity**: \(O(n^2)\) for all cases +- **Space Complexity**: \(O(1)\) +- **Pros**: Simple implementation; fewer swaps +- **Cons**: Inefficient for large datasets +- **Use Case**: Useful for small datasets or when memory writes are costly + +## 3. Insertion Sort +**Description**: Insertion Sort builds a sorted list by taking one item from the unsorted portion and inserting it into the correct position. + +- **Time Complexity**: \(O(n^2)\) average and worst-case; \(O(n)\) best-case (already sorted) +- **Space Complexity**: \(O(1)\) +- **Pros**: Efficient for small or nearly sorted lists +- **Cons**: Not suitable for large unsorted datasets +- **Use Case**: Good for small or mostly sorted datasets + +## 4. Merge Sort +**Description**: Merge Sort is a divide-and-conquer algorithm that splits the list into halves, sorts each half, and then merges them. + +- **Time Complexity**: \(O(n \log n)\) for all cases +- **Space Complexity**: \(O(n)\) +- **Pros**: Consistent performance; stable sort +- **Cons**: Requires extra space +- **Use Case**: Effective for large datasets and linked lists + +## 5. Quick Sort +**Description**: Quick Sort is a divide-and-conquer algorithm that selects a "pivot" element, partitions the array around it, and recursively sorts partitions. + +- **Time Complexity**: \(O(n \log n)\) average; \(O(n^2)\) worst-case +- **Space Complexity**: \(O(\log n)\) +- **Pros**: Fast in practice due to in-place sorting +- **Cons**: Worst-case time can be \(O(n^2)\); not stable +- **Use Case**: Suitable for large datasets, especially when optimizing for speed + +## 6. Heap Sort +**Description**: Heap Sort uses a binary heap to sort by repeatedly extracting the largest element (root) and adjusting the heap. + +- **Time Complexity**: \(O(n \log n)\) +- **Space Complexity**: \(O(1)\) +- **Pros**: Efficient, in-place sorting +- **Cons**: Not stable; slower in practice than Quick Sort +- **Use Case**: Used when in-place sorting is preferred and stability isn't essential + +## 7. Radix Sort +**Description**: Radix Sort is a non-comparative algorithm that sorts integers by processing digits, usually using Counting Sort as a subroutine. + +- **Time Complexity**: \(O(d \cdot (n + k))\), where \(d\) is the digit count and \(k\) is the digit range +- **Space Complexity**: \(O(n + k)\) +- **Pros**: Fast for fixed-digit data; stable +- **Cons**: Limited to numbers or strings; extra space needed +- **Use Case**: Ideal for sorting large lists of integers or strings of uniform length + +## 8. Counting Sort +**Description**: Counting Sort counts occurrences of each element and calculates their sorted positions. + +- **Time Complexity**: \(O(n + k)\), where \(k\) is the input range +- **Space Complexity**: \(O(n + k)\) +- **Pros**: Fast and stable for specific data +- **Cons**: Limited to data with a small range; not for general-purpose sorting +- **Use Case**: Effective for lists with a limited value range + +## Comparison Summary + +| Algorithm | Best Time Complexity | Worst Time Complexity | Space Complexity | Stable | Use Cases | +|-----------------|----------------------|------------------------|------------------|--------|-----------------------------------------| +| Bubble Sort | \(O(n)\) | \(O(n^2)\) | \(O(1)\) | Yes | Small or mostly sorted datasets | +| Selection Sort | \(O(n^2)\) | \(O(n^2)\) | \(O(1)\) | No | Small datasets, costly memory writes | +| Insertion Sort | \(O(n)\) | \(O(n^2)\) | \(O(1)\) | Yes | Small or nearly sorted datasets | +| Merge Sort | \(O(n \log n)\) | \(O(n \log n)\) | \(O(n)\) | Yes | Large datasets, stable sorting needed | +| Quick Sort | \(O(n \log n)\) | \(O(n^2)\) | \(O(\log n)\) | No | Large datasets, in-place and fast sort | +| Heap Sort | \(O(n \log n)\) | \(O(n \log n)\) | \(O(1)\) | No | Large datasets, stability not required | +| Radix Sort | \(O(n \cdot d)\) | \(O(n \cdot d)\) | \(O(n + k)\) | Yes | Large lists of numbers, fixed-length | +| Counting Sort | \(O(n + k)\) | \(O(n + k)\) | \(O(n + k)\) | Yes | Small integer range, limited data range | + +## Conclusion +Each sorting algorithm has unique strengths and weaknesses, and the choice depends on the dataset's characteristics. Quick Sort and Merge Sort work well with large datasets, while Bubble Sort, Selection Sort, and Insertion Sort are best for smaller or partially sorted data. Radix and Counting Sort are efficient for data like integers in a limited range. From 842924df7df326cf5f072f8ab1e4ef6b6766c0d2 Mon Sep 17 00:00:00 2001 From: Aryan Ramesh Jain <138214350+jainaryan04@users.noreply.github.com> Date: Sat, 9 Nov 2024 15:30:58 +0530 Subject: [PATCH 3/5] use $ --- blog/comparing-sortings.md | 50 +++++++++++++++++++------------------- 1 file changed, 25 insertions(+), 25 deletions(-) diff --git a/blog/comparing-sortings.md b/blog/comparing-sortings.md index 022272fe4..8bcbb01c7 100644 --- a/blog/comparing-sortings.md +++ b/blog/comparing-sortings.md @@ -12,8 +12,8 @@ Sorting algorithms are essential for organizing data, making it easier to analyz ## 1. Bubble Sort **Description**: Bubble Sort repeatedly steps through the list, compares adjacent elements, and swaps them if needed until the list is sorted. -- **Time Complexity**: \(O(n^2)\) average and worst-case; \(O(n)\) best-case (already sorted) -- **Space Complexity**: \(O(1)\) +- **Time Complexity**: $O(n^2)$ average and worst-case; $O(n)$ best-case (already sorted) +- **Space Complexity**: $O(1)$ - **Pros**: Simple and easy to implement - **Cons**: Inefficient for large datasets - **Use Case**: Suitable for small or nearly sorted datasets @@ -21,8 +21,8 @@ Sorting algorithms are essential for organizing data, making it easier to analyz ## 2. Selection Sort **Description**: Selection Sort divides the list into sorted and unsorted parts, finding the minimum element in the unsorted part and placing it in order. -- **Time Complexity**: \(O(n^2)\) for all cases -- **Space Complexity**: \(O(1)\) +- **Time Complexity**: $O(n^2)$ for all cases +- **Space Complexity**: $O(1)$ - **Pros**: Simple implementation; fewer swaps - **Cons**: Inefficient for large datasets - **Use Case**: Useful for small datasets or when memory writes are costly @@ -30,8 +30,8 @@ Sorting algorithms are essential for organizing data, making it easier to analyz ## 3. Insertion Sort **Description**: Insertion Sort builds a sorted list by taking one item from the unsorted portion and inserting it into the correct position. -- **Time Complexity**: \(O(n^2)\) average and worst-case; \(O(n)\) best-case (already sorted) -- **Space Complexity**: \(O(1)\) +- **Time Complexity**: $O(n^2)$ average and worst-case; $O(n)$ best-case (already sorted) +- **Space Complexity**: $O(1)$ - **Pros**: Efficient for small or nearly sorted lists - **Cons**: Not suitable for large unsorted datasets - **Use Case**: Good for small or mostly sorted datasets @@ -39,8 +39,8 @@ Sorting algorithms are essential for organizing data, making it easier to analyz ## 4. Merge Sort **Description**: Merge Sort is a divide-and-conquer algorithm that splits the list into halves, sorts each half, and then merges them. -- **Time Complexity**: \(O(n \log n)\) for all cases -- **Space Complexity**: \(O(n)\) +- **Time Complexity**: $O(n \log n)$ for all cases +- **Space Complexity**: $O(n)$ - **Pros**: Consistent performance; stable sort - **Cons**: Requires extra space - **Use Case**: Effective for large datasets and linked lists @@ -48,17 +48,17 @@ Sorting algorithms are essential for organizing data, making it easier to analyz ## 5. Quick Sort **Description**: Quick Sort is a divide-and-conquer algorithm that selects a "pivot" element, partitions the array around it, and recursively sorts partitions. -- **Time Complexity**: \(O(n \log n)\) average; \(O(n^2)\) worst-case -- **Space Complexity**: \(O(\log n)\) +- **Time Complexity**: $O(n \log n)$ average; $O(n^2)$ worst-case +- **Space Complexity**: $O(\log n)$ - **Pros**: Fast in practice due to in-place sorting -- **Cons**: Worst-case time can be \(O(n^2)\); not stable +- **Cons**: Worst-case time can be $O(n^2)$; not stable - **Use Case**: Suitable for large datasets, especially when optimizing for speed ## 6. Heap Sort **Description**: Heap Sort uses a binary heap to sort by repeatedly extracting the largest element (root) and adjusting the heap. -- **Time Complexity**: \(O(n \log n)\) -- **Space Complexity**: \(O(1)\) +- **Time Complexity**: $O(n \log n)$ +- **Space Complexity**: $O(1)$ - **Pros**: Efficient, in-place sorting - **Cons**: Not stable; slower in practice than Quick Sort - **Use Case**: Used when in-place sorting is preferred and stability isn't essential @@ -66,8 +66,8 @@ Sorting algorithms are essential for organizing data, making it easier to analyz ## 7. Radix Sort **Description**: Radix Sort is a non-comparative algorithm that sorts integers by processing digits, usually using Counting Sort as a subroutine. -- **Time Complexity**: \(O(d \cdot (n + k))\), where \(d\) is the digit count and \(k\) is the digit range -- **Space Complexity**: \(O(n + k)\) +- **Time Complexity**: $O(d \cdot (n + k))$, where $d$ is the digit count and $k$ is the digit range +- **Space Complexity**: $O(n + k)$ - **Pros**: Fast for fixed-digit data; stable - **Cons**: Limited to numbers or strings; extra space needed - **Use Case**: Ideal for sorting large lists of integers or strings of uniform length @@ -75,8 +75,8 @@ Sorting algorithms are essential for organizing data, making it easier to analyz ## 8. Counting Sort **Description**: Counting Sort counts occurrences of each element and calculates their sorted positions. -- **Time Complexity**: \(O(n + k)\), where \(k\) is the input range -- **Space Complexity**: \(O(n + k)\) +- **Time Complexity**: $O(n + k)$, where $k$ is the input range +- **Space Complexity**: $O(n + k)$ - **Pros**: Fast and stable for specific data - **Cons**: Limited to data with a small range; not for general-purpose sorting - **Use Case**: Effective for lists with a limited value range @@ -85,14 +85,14 @@ Sorting algorithms are essential for organizing data, making it easier to analyz | Algorithm | Best Time Complexity | Worst Time Complexity | Space Complexity | Stable | Use Cases | |-----------------|----------------------|------------------------|------------------|--------|-----------------------------------------| -| Bubble Sort | \(O(n)\) | \(O(n^2)\) | \(O(1)\) | Yes | Small or mostly sorted datasets | -| Selection Sort | \(O(n^2)\) | \(O(n^2)\) | \(O(1)\) | No | Small datasets, costly memory writes | -| Insertion Sort | \(O(n)\) | \(O(n^2)\) | \(O(1)\) | Yes | Small or nearly sorted datasets | -| Merge Sort | \(O(n \log n)\) | \(O(n \log n)\) | \(O(n)\) | Yes | Large datasets, stable sorting needed | -| Quick Sort | \(O(n \log n)\) | \(O(n^2)\) | \(O(\log n)\) | No | Large datasets, in-place and fast sort | -| Heap Sort | \(O(n \log n)\) | \(O(n \log n)\) | \(O(1)\) | No | Large datasets, stability not required | -| Radix Sort | \(O(n \cdot d)\) | \(O(n \cdot d)\) | \(O(n + k)\) | Yes | Large lists of numbers, fixed-length | -| Counting Sort | \(O(n + k)\) | \(O(n + k)\) | \(O(n + k)\) | Yes | Small integer range, limited data range | +| Bubble Sort | $O(n)$ | $O(n^2)$ | $O(1)$ | Yes | Small or mostly sorted datasets | +| Selection Sort | $O(n^2)$ | $O(n^2)$ | $O(1)$ | No | Small datasets, costly memory writes | +| Insertion Sort | $O(n)$ | $O(n^2)$ | $O(1)$ | Yes | Small or nearly sorted datasets | +| Merge Sort | $O(n \log n)$ | $O(n \log n)$ | $O(n)$ | Yes | Large datasets, stable sorting needed | +| Quick Sort | $O(n \log n)$ | $O(n^2)$ | $O(\log n)$ | No | Large datasets, in-place and fast sort | +| Heap Sort | $O(n \log n)$ | $O(n \log n)$ | $O(1)$ | No | Large datasets, stability not required | +| Radix Sort | $O(n \cdot d)$ | $O(n \cdot d)$ | $O(n + k)$ | Yes | Large lists of numbers, fixed-length | +| Counting Sort | $O(n + k)$ | $O(n + k)$ | $O(n + k)$ | Yes | Small integer range, limited data range | ## Conclusion Each sorting algorithm has unique strengths and weaknesses, and the choice depends on the dataset's characteristics. Quick Sort and Merge Sort work well with large datasets, while Bubble Sort, Selection Sort, and Insertion Sort are best for smaller or partially sorted data. Radix and Counting Sort are efficient for data like integers in a limited range. From 0ed6bf7aec47a66042f9bf7ac9bbb2a36e4c8158 Mon Sep 17 00:00:00 2001 From: ajay-dhangar <99037494+ajay-dhangar@users.noreply.github.com> Date: Sat, 9 Nov 2024 10:01:10 +0000 Subject: [PATCH 4/5] update contributors list in README --- README.md | 88 +++++++++++++++++++++++++++---------------------------- 1 file changed, 44 insertions(+), 44 deletions(-) diff --git a/README.md b/README.md index 4bfeca25d..6fcd4d17e 100644 --- a/README.md +++ b/README.md @@ -348,6 +348,13 @@ Thanks to these amazing people who have contributed to the **Algo** project: Mithanshu Hedau + + + PrAyAg9 +
+ Prayag Thakur + + Mahateaa @@ -362,13 +369,6 @@ Thanks to these amazing people who have contributed to the **Algo** project: Abhinandan - - - PrAyAg9 -
- Prayag Thakur - - shriyadindi @@ -377,10 +377,10 @@ Thanks to these amazing people who have contributed to the **Algo** project: - - J-B-Mugundh + + monishkumardvs
- Mugundh J B + Dvs monish kumar @@ -393,68 +393,68 @@ Thanks to these amazing people who have contributed to the **Algo** project: - - monishkumardvs + + J-B-Mugundh
- Dvs monish kumar + Mugundh J B - - aditiverma-21 + + jainaryan04
- Aditi Verma + Aryan Ramesh Jain - - Subashree-selvaraj + + aditiverma-21
- subashree + Aditi Verma - - Abhishek2634 + + Riddhi12349
- Abhishek Farshwal + riddhi - - KashishJuneja101003 + + Alpha1zln
- Kashish Juneja + SHREYAS YADUVANSHI - - jainaryan04 + + Rashigera
- Aryan Ramesh Jain + Rashigera - - Alpha1zln + + Subashree-selvaraj
- SHREYAS YADUVANSHI + subashree - - Rashigera + + KashishJuneja101003
- Rashigera + Kashish Juneja - - Riddhi12349 + + Abhishek2634
- riddhi + Abhishek Farshwal @@ -480,13 +480,6 @@ Thanks to these amazing people who have contributed to the **Algo** project: Mansi07sharma - - - mehul-m-prajapati -
- Mehul Prajapati - - tanishqkolhatkar93 @@ -501,6 +494,13 @@ Thanks to these amazing people who have contributed to the **Algo** project: PavanTeja2005 + + + mehul-m-prajapati +
+ Mehul Prajapati + + sarthaxtic From 8b9b36cf0d8a5b33d9042fe965b759f8bc404f82 Mon Sep 17 00:00:00 2001 From: Ajay Dhangar <99037494+ajay-dhangar@users.noreply.github.com> Date: Sun, 10 Nov 2024 19:28:53 +0530 Subject: [PATCH 5/5] Update comparing-sortings.md --- blog/comparing-sortings.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/blog/comparing-sortings.md b/blog/comparing-sortings.md index 8bcbb01c7..86fd6550c 100644 --- a/blog/comparing-sortings.md +++ b/blog/comparing-sortings.md @@ -1,7 +1,7 @@ --- slug: comparing-sorting-algorithms title: Comparing the different Sorting Algorithms -authors: [ARYAN-JAIN] +authors: [Aryan-Jain] tags: [ARYAN-JAIN, algo, dsa, algorithms, sorting, time-complexity] ---