diff --git a/Python.wiki/Home.md b/Python.wiki/Home.md new file mode 100644 index 000000000000..765420b7b2ae --- /dev/null +++ b/Python.wiki/Home.md @@ -0,0 +1,6 @@ +## Python Algorithms +- All the algorithms are implemented in **Python** for **education purpose** only.
+- These are just for **demonstration** purpose.
+- There are many implementations of different algorithms in the Python standard library that are much better for performance reasons.
+ +List of Algorithms diff --git a/Python.wiki/Sorting-Algorithms.md b/Python.wiki/Sorting-Algorithms.md new file mode 100644 index 000000000000..709cea5d4204 --- /dev/null +++ b/Python.wiki/Sorting-Algorithms.md @@ -0,0 +1,93 @@ +

index

+ +
+ +
    +
  1. Selection Sort
    2. +
  2. Bubble Sort
    3. +
  3. Recursive Bubble Sort
    4. +
  4. Insertion Sort
    5. +
  5. Recursive Insertion Sort
    6. +
  6. Merge Sort
    7. +
  7. Iterative Merge Sort
    8. +
  8. Quick Sort
    9. +
  9. Iterative Quick Sort
    10. +
  10. Heap Sort
    11. +
  11. Counting Sort
    12. +
  12. Radix Sort
    13. +
  13. Bucket Sort
    14. +
  14. ShellSort
    15. +
  15. TimSort
    16. +
  16. Comb Sort
    17. +
  17. Pigeonhole Sort
    18. +
  18. Cycle Sort
    19. +
  19. Cocktail Sort
    20. +
  20. Strand Sort
    21. +
  21. Bitonic Sort
    22. +
  22. Pancake sorting
    23. +
  23. Binary Insertion Sort
    24. +
  24. BogoSort or Permutation Sort
    25. +
  25. Gnome Sort
    26. +
  26. Sleep Sort – The King of Laziness / Sorting while Sleeping
    27. +
  27. Structure Sorting (By Multiple Rules)
    28. +
  28. Stooge Sort
    29. +
  29. Tag Sort (To get both sorted and original)
    30. +
  30. Tree Sort
    31. +
  31. Cartesian Tree Sorting
    32. +
  32. Odd-Even Sort / Brick Sort
    33. +
  33. QuickSort on Singly Linked List
    34. +
  34. QuickSort on Doubly Linked List
    35. +
  35. 3-Way QuickSort (Dutch National Flag)
    36. +
  36. Merge Sort for Linked Lists
    37. +
  37. Merge Sort for Doubly Linked List
    38. +
  38. 3-way Merge Sort
    39. +
+ +*** + +

Selection sort

+ +**Selection sort**, algorithm sorts an array by repeatedly finding the minimum element (considering ascending order) from the unsorted part and putting it at the beginning. The algorithm maintains two subarrays in a given array. +
    +
  1. The subarray which is already sorted.
    2. +
  2. Remaining subarray which is unsorted.
    3. + +In every iteration of selection sort, the minimum element (considering ascending order) from the unsorted subarray is picked and moved to the sorted subarray. + +#### Properties: +- Worst-case performance O(n^2) +- Best-case performance O(n) +- Average case performance O(n^2) + +**read more at: [Wikipedia](https://en.wikipedia.org/wiki/Selection_sort)**
    +**code: [Selection sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/selection_sort.py)** + +*** + + +

    Bubble sort

    + +**Bubble sort**, sometimes referred to as sinking sort, is a simple sorting algorithm that repeatedly steps through the list to be sorted, compares each pair of adjacent items and swaps them if they are in the wrong order. The pass through the list is repeated until no swaps are needed, which indicates that the list is sorted. The algorithm, which is a comparison sort, is named for the way smaller elements "bubble" to the top of the list. Although the algorithm is simple, it is too slow and impractical for most problems even when compared to insertion sort. It can be practical if the input is usually in sorted order but may occasionally have some out-of-order elements nearly in position. + +#### Properties: +- Worst-case performance O(n^2) +- Best-case performance O(n) +- Average case performance O(n^2) + +**read more at: [Wikipedia](https://en.wikipedia.org/wiki/Bubble_sort)**
    +**code: [Bubble sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bubble_sort.py)** + +*** + + +

    Insertion sort

    + +**Insertion sort** is a simple sorting algorithm that builds the final sorted array (or list) one item at a time. It is much less efficient on large lists than more advanced algorithms such as quicksort, heapsort, or merge sort. + +#### Properties: +- Worst-case performance O(n^2) +- Best-case performance O(n) +- Average case performance O(n^2) + +**read more at: [Wikipedia](https://en.wikipedia.org/wiki/Insertion_sort)**
    +**code: [Insertion sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/insertion_sort.py)** diff --git a/Python.wiki/_Footer.md b/Python.wiki/_Footer.md new file mode 100644 index 000000000000..b304535c2357 --- /dev/null +++ b/Python.wiki/_Footer.md @@ -0,0 +1 @@ +

    Contribution | join at Gitter!

    \ No newline at end of file