- Docs
- Algorithms
- Sorting Algorithms
Sorting Algorithms
- Quick Sort
REPORT z_quick_sort_example.
TYPES: ty_value TYPE i,
       ty_data  TYPE TABLE OF ty_value WITH EMPTY KEY.
DATA: lt_data TYPE ty_data,
      lv_start TYPE i,
      lv_end   TYPE i.
* Sample data
lt_data = VALUE ty_data( ( 34 ) ( 7 ) ( 23 ) ( 32 ) ( 5 ) ( 62 ) ( 8 ) ( 13 ) ).
* Display original data
PERFORM display_data USING lt_data 'Original Data'.
* Quick Sort
lv_start = 1.
lv_end = LINES( lt_data ).
PERFORM quick_sort USING lt_data lv_start lv_end.
* Display sorted data
PERFORM display_data USING lt_data 'Sorted Data'.
*&---------------------------------------------------------------------*
*&      Form  QUICK_SORT
*&---------------------------------------------------------------------*
FORM quick_sort USING it_data TYPE ty_data
                        iv_start TYPE i
                        iv_end   TYPE i.
  DATA: lv_left  TYPE i,
        lv_right TYPE i,
        lv_temp  TYPE i,
        lv_pivot TYPE i.
  IF iv_start >= iv_end.
    RETURN.
  ENDIF.
  lv_left  = iv_start.
  lv_right = iv_end.
  lv_pivot = it_data[ iv_start ].
  WHILE lv_left <= lv_right.
    WHILE it_data[ lv_left ] < lv_pivot.
      lv_left = lv_left + 1.
    ENDWHILE.
    WHILE it_data[ lv_right ] > lv_pivot.
      lv_right = lv_right - 1.
    ENDWHILE.
    IF lv_left <= lv_right.
      lv_temp = it_data[ lv_left ].
      it_data[ lv_left ] = it_data[ lv_right ].
      it_data[ lv_right ] = lv_temp.
      lv_left = lv_left + 1.
      lv_right = lv_right - 1.
    ENDIF.
  ENDWHILE.
  PERFORM quick_sort USING it_data iv_start lv_right.
  PERFORM quick_sort USING it_data lv_left  iv_end.
ENDFORM.
*&---------------------------------------------------------------------*
*&      Form  DISPLAY_DATA
*&---------------------------------------------------------------------*
FORM display_data USING it_data TYPE ty_data
                         iv_title TYPE string.
  WRITE: / iv_title.
  LOOP AT it_data INTO DATA(lv_value).
    WRITE: / lv_value.
  ENDLOOP.
  WRITE: / ' '.
  
ENDFORM.
- Merge Sort
- Heap Sort
Searching Algorithms
- Binary Search ✓
- Depth-First Search (DFS) ✓
- Breadth-First Search (BFS) ✓
Graph Algorithms
- Dijkstra's Algorithm
- Bellman-Ford Algorithm
- Floyd-Warshall Algorithm
Dynamic Programming
- Knapsack Problem
- Longest Common Subsequence (LCS)
- Coin Change Problem
Greedy Algorithms
- Activity Selection Problem
- Huffman Coding
- Kruskal's and Prim's algorithms for Minimum Spanning Tree
Hashing
- Implementation of Hash Maps
- Collision Handling (Chaining and Open Addressing)
String Algorithms
- KMP Algorithm for Pattern Matching
- Rabin-Karp Algorithm
- Trie Data Structure
Tree and Binary Tree Algorithms
- Tree Traversals (Inorder, Preorder, Postorder)
- Binary Search Tree operations (Insert, Delete, Search)
- Lowest Common Ancestor (LCA)