[UPDATE ALGORITHM] adding more sorting algorithms

[Shaanif600]

Description:

Please describe the changes you want to make to the existing algorithm and why they are necessary.

Checklist:

• [x] Contributor in GSSoC-ext
• [x] Want to work on it

Affected Algorithm:

Mention which algorithm you want to update and the specific directory where you want to change.

Additional Information:

Any extra details or suggestions related to the update. Research Existing Algorithms: Familiarize yourself with well-known sorting algorithms (e.g., Quick Sort, Merge Sort, Bubble Sort) to understand their properties and limitations.

Choose the Algorithm Type: Decide on the type of sorting algorithm based on the use case:

Comparison-based: (e.g., Bubble Sort, Quick Sort) Non-comparison-based: (e.g., Counting Sort, Radix Sort) Design the Algorithm: Outline the specific steps and logic for the new sorting method. Consider algorithm complexity (e.g., average and worst-case time complexity).

Implementation: Code the sorting algorithm in your chosen programming language. Ensure it adheres to coding standards for maintainability.

Test the Algorithm: Validate the algorithm with various datasets, including:

Random data Sorted data Reversely sorted data Edge cases (e.g., empty arrays, arrays with identical elements) Optimize: Analyze performance through benchmarking. Optimize for speed and memory usage.

Document: Provide clear documentation outlining how the algorithm works, its time complexity, best use cases, and limitations.

Integrate: Combine the new sorting method into existing systems, ensuring it integrates well with other functionalities.

Monitor Performance: After integration, monitor the algorithm’s performance to identify any issues or areas for improvement.

Popular Sorting Algorithms to Consider: Quick Sort:

Divide-and-conquer algorithm. Average time complexity of O(n log n). In-place sorting. Merge Sort:

Also a divide-and-conquer algorithm. Stable and excels in worst-case scenarios at O(n log n). Requires additional space. Insertion Sort:

Efficient for small datasets and nearly sorted arrays. Time complexity of O(n²) in the average and worst case but O(n) in the best case. Heap Sort:

Based on a comparison-based binary heap data structure. Time complexity of O(n log n). In-place but not stable. Counting Sort:

Non-comparison-based sorting algorithm. Efficient for sorting integers or objects within a known range. Time complexity of O(n + k), where k is the range of the input. Radix Sort:

A non-comparison-based algorithm that processes individual digits. Time complexity of O(nk), where k is the number of digits. Bucket Sort:

Distributes elements into several "buckets" and sort each bucket individually. Time complexity of O(n + k) but works best with uniform distribution. By following these steps and methodologies, you can effectively design, implement, and integrate new sorting algorithms into your projects.

[github-actions[bot]]

👋 Thank you for raising an issue! We appreciate your effort in helping us improve. Our team will review it shortly. Stay tuned!

[AnujSaha0111]

Can you please assign it to me? I want to work on it.