MainframeMaster

COBOL Sorting Algorithms Concepts

Sorting algorithms in COBOL are methods for arranging data in a specific order, including ascending, descending, or custom ordering based on specified criteria. Understanding sorting algorithms is essential for COBOL programming as most business applications require data organization and ordering. Proper sorting techniques ensure efficient data processing, optimal performance, and reliable data organization.

Understanding Sorting Algorithms

Sorting algorithms in COBOL encompass all methods of arranging data in a specific order including programmatic sorting algorithms and the SORT statement for file operations. Different sorting algorithms are appropriate for different data sizes, characteristics, and performance requirements. Understanding these concepts is essential for choosing the right sorting approach for specific business requirements.

Bubble Sort

1. Basic Bubble Sort

Bubble sort is a simple sorting algorithm that repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order. This algorithm is easy to understand but inefficient for large datasets.

cobol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 SORT-TABLE.
           05 TABLE-ENTRY OCCURS 10 TIMES.
               10 ENTRY-VALUE    PIC 9(3).
               10 ENTRY-NAME     PIC X(10).
       
       01 SORT-CONTROLS.
           05 TABLE-SIZE        PIC 9(2) VALUE 10.
           05 OUTER-INDEX       PIC 9(2).
           05 INNER-INDEX       PIC 9(2).
           05 TEMP-VALUE        PIC 9(3).
           05 TEMP-NAME         PIC X(10).
           05 SWAP-FLAG         PIC X(1) VALUE 'N'.
               88 SWAP-OCCURRED VALUE 'Y'.
               88 NO-SWAP       VALUE 'N'.
       
       PROCEDURE DIVISION.
       BUBBLE-SORT-EXAMPLE.
           DISPLAY 'Bubble Sort Example'
           
           *> Initialize table with sample data
           PERFORM INITIALIZE-SORT-TABLE
           
           *> Display unsorted table
           PERFORM DISPLAY-TABLE 'BEFORE SORT'
           
           *> Perform bubble sort
           PERFORM BUBBLE-SORT-ALGORITHM
           
           *> Display sorted table
           PERFORM DISPLAY-TABLE 'AFTER SORT'
           
           STOP RUN.
       
       INITIALIZE-SORT-TABLE.
           MOVE 64 TO ENTRY-VALUE(1)
           MOVE 'ITEM-1' TO ENTRY-NAME(1)
           MOVE 34 TO ENTRY-VALUE(2)
           MOVE 'ITEM-2' TO ENTRY-NAME(2)
           MOVE 25 TO ENTRY-VALUE(3)
           MOVE 'ITEM-3' TO ENTRY-NAME(3)
           MOVE 12 TO ENTRY-VALUE(4)
           MOVE 'ITEM-4' TO ENTRY-NAME(4)
           MOVE 22 TO ENTRY-VALUE(5)
           MOVE 'ITEM-5' TO ENTRY-NAME(5).
       
       BUBBLE-SORT-ALGORITHM.
           DISPLAY 'Performing bubble sort'
           
           PERFORM VARYING OUTER-INDEX FROM 1 BY 1
               UNTIL OUTER-INDEX > TABLE-SIZE - 1
               
               SET NO-SWAP TO TRUE
               
               PERFORM VARYING INNER-INDEX FROM 1 BY 1
                   UNTIL INNER-INDEX > TABLE-SIZE - OUTER-INDEX
                   
                   IF ENTRY-VALUE(INNER-INDEX) > ENTRY-VALUE(INNER-INDEX + 1)
                       PERFORM SWAP-ENTRIES
                       SET SWAP-OCCURRED TO TRUE
                   END-IF
               END-PERFORM
               
               *> If no swaps occurred, array is sorted
               IF NO-SWAP
                   EXIT PERFORM
               END-IF
           END-PERFORM.
       
       SWAP-ENTRIES.
           MOVE ENTRY-VALUE(INNER-INDEX) TO TEMP-VALUE
           MOVE ENTRY-VALUE(INNER-INDEX + 1) TO ENTRY-VALUE(INNER-INDEX)
           MOVE TEMP-VALUE TO ENTRY-VALUE(INNER-INDEX + 1)
           
           MOVE ENTRY-NAME(INNER-INDEX) TO TEMP-NAME
           MOVE ENTRY-NAME(INNER-INDEX + 1) TO ENTRY-NAME(INNER-INDEX)
           MOVE TEMP-NAME TO ENTRY-NAME(INNER-INDEX + 1).
       
       DISPLAY-TABLE.
           DISPLAY 'Table ' PARAMETER-1 ':'
           PERFORM VARYING DISPLAY-INDEX FROM 1 BY 1
               UNTIL DISPLAY-INDEX > TABLE-SIZE
               DISPLAY '  ' ENTRY-VALUE(DISPLAY-INDEX) ' - ' ENTRY-NAME(DISPLAY-INDEX)
           END-PERFORM

Bubble sort repeatedly compares adjacent elements and swaps them if they are in the wrong order. The algorithm continues until no more swaps are needed, indicating the array is sorted.

2. Optimized Bubble Sort

Optimized bubble sort includes early termination when no swaps occur in a pass, reducing unnecessary comparisons and improving performance for partially sorted data.

cobol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
       PROCEDURE DIVISION.
       OPTIMIZED-BUBBLE-SORT.
           DISPLAY 'Optimized Bubble Sort Example'
           
           *> Initialize table
           PERFORM INITIALIZE-SORT-TABLE
           
           *> Perform optimized bubble sort
           PERFORM OPTIMIZED-BUBBLE-SORT-ALGORITHM
           
           *> Display results
           PERFORM DISPLAY-TABLE 'OPTIMIZED SORT'.
       
       OPTIMIZED-BUBBLE-SORT-ALGORITHM.
           DISPLAY 'Performing optimized bubble sort'
           
           MOVE TABLE-SIZE TO LAST-SWAP-POSITION
           
           PERFORM UNTIL LAST-SWAP-POSITION = 0
               MOVE 0 TO CURRENT-SWAP-POSITION
               
               PERFORM VARYING INNER-INDEX FROM 1 BY 1
                   UNTIL INNER-INDEX > LAST-SWAP-POSITION - 1
                   
                   IF ENTRY-VALUE(INNER-INDEX) > ENTRY-VALUE(INNER-INDEX + 1)
                       PERFORM SWAP-ENTRIES
                       MOVE INNER-INDEX TO CURRENT-SWAP-POSITION
                   END-IF
               END-PERFORM
               
               MOVE CURRENT-SWAP-POSITION TO LAST-SWAP-POSITION
           END-PERFORM

Optimized bubble sort tracks the last swap position to avoid unnecessary comparisons in already sorted portions of the array, improving performance for partially sorted data.

Selection Sort

1. Basic Selection Sort

Selection sort finds the minimum element in the unsorted portion of the array and swaps it with the first element of the unsorted portion. This algorithm is more efficient than bubble sort for small datasets.

cobol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
       PROCEDURE DIVISION.
       SELECTION-SORT-EXAMPLE.
           DISPLAY 'Selection Sort Example'
           
           *> Initialize table
           PERFORM INITIALIZE-SORT-TABLE
           
           *> Display unsorted table
           PERFORM DISPLAY-TABLE 'BEFORE SORT'
           
           *> Perform selection sort
           PERFORM SELECTION-SORT-ALGORITHM
           
           *> Display sorted table
           PERFORM DISPLAY-TABLE 'AFTER SORT'
           
           STOP RUN.
       
       SELECTION-SORT-ALGORITHM.
           DISPLAY 'Performing selection sort'
           
           PERFORM VARYING OUTER-INDEX FROM 1 BY 1
               UNTIL OUTER-INDEX > TABLE-SIZE - 1
               
               MOVE OUTER-INDEX TO MIN-INDEX
               
               PERFORM VARYING INNER-INDEX FROM OUTER-INDEX + 1 BY 1
                   UNTIL INNER-INDEX > TABLE-SIZE
                   
                   IF ENTRY-VALUE(INNER-INDEX) < ENTRY-VALUE(MIN-INDEX)
                       MOVE INNER-INDEX TO MIN-INDEX
                   END-IF
               END-PERFORM
               
               *> Swap if minimum is not at current position
               IF MIN-INDEX NOT = OUTER-INDEX
                   PERFORM SWAP-SELECTION-ENTRIES
               END-IF
           END-PERFORM.
       
       SWAP-SELECTION-ENTRIES.
           MOVE ENTRY-VALUE(OUTER-INDEX) TO TEMP-VALUE
           MOVE ENTRY-VALUE(MIN-INDEX) TO ENTRY-VALUE(OUTER-INDEX)
           MOVE TEMP-VALUE TO ENTRY-VALUE(MIN-INDEX)
           
           MOVE ENTRY-NAME(OUTER-INDEX) TO TEMP-NAME
           MOVE ENTRY-NAME(MIN-INDEX) TO ENTRY-NAME(OUTER-INDEX)
           MOVE TEMP-NAME TO ENTRY-NAME(MIN-INDEX)

Selection sort repeatedly finds the minimum element in the unsorted portion and swaps it with the first element of the unsorted portion, building the sorted array incrementally.

2. Selection Sort with Multiple Keys

Selection sort can be extended to handle multiple sort keys, providing more sophisticated sorting capabilities for complex data structures.

cobol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 MULTI-KEY-TABLE.
           05 TABLE-ENTRY OCCURS 10 TIMES.
               10 PRIMARY-KEY    PIC 9(3).
               10 SECONDARY-KEY  PIC X(10).
               10 TERTIARY-KEY   PIC 9(2).
       
       PROCEDURE DIVISION.
       MULTI-KEY-SELECTION-SORT.
           DISPLAY 'Multi-Key Selection Sort Example'
           
           *> Initialize multi-key table
           PERFORM INITIALIZE-MULTI-KEY-TABLE
           
           *> Perform multi-key selection sort
           PERFORM MULTI-KEY-SELECTION-SORT-ALGORITHM
           
           *> Display results
           PERFORM DISPLAY-MULTI-KEY-TABLE.
       
       MULTI-KEY-SELECTION-SORT-ALGORITHM.
           DISPLAY 'Performing multi-key selection sort'
           
           PERFORM VARYING OUTER-INDEX FROM 1 BY 1
               UNTIL OUTER-INDEX > TABLE-SIZE - 1
               
               MOVE OUTER-INDEX TO MIN-INDEX
               
               PERFORM VARYING INNER-INDEX FROM OUTER-INDEX + 1 BY 1
                   UNTIL INNER-INDEX > TABLE-SIZE
                   
                   IF MULTI-KEY-LESS-THAN(INNER-INDEX, MIN-INDEX)
                       MOVE INNER-INDEX TO MIN-INDEX
                   END-IF
               END-PERFORM
               
               IF MIN-INDEX NOT = OUTER-INDEX
                   PERFORM SWAP-MULTI-KEY-ENTRIES
               END-IF
           END-PERFORM.
       
       MULTI-KEY-LESS-THAN.
           *> Compare primary key first
           IF PRIMARY-KEY(INNER-INDEX) < PRIMARY-KEY(MIN-INDEX)
               MOVE 'Y' TO LESS-THAN-FLAG
           ELSE
               IF PRIMARY-KEY(INNER-INDEX) = PRIMARY-KEY(MIN-INDEX)
                   *> Compare secondary key
                   IF SECONDARY-KEY(INNER-INDEX) < SECONDARY-KEY(MIN-INDEX)
                       MOVE 'Y' TO LESS-THAN-FLAG
                   ELSE
                       IF SECONDARY-KEY(INNER-INDEX) = SECONDARY-KEY(MIN-INDEX)
                           *> Compare tertiary key
                           IF TERTIARY-KEY(INNER-INDEX) < TERTIARY-KEY(MIN-INDEX)
                               MOVE 'Y' TO LESS-THAN-FLAG
                           ELSE
                               MOVE 'N' TO LESS-THAN-FLAG
                           END-IF
                       ELSE
                           MOVE 'N' TO LESS-THAN-FLAG
                       END-IF
                   END-IF
               ELSE
                   MOVE 'N' TO LESS-THAN-FLAG
               END-IF
           END-IF

Multi-key selection sort handles multiple sort criteria by comparing keys in priority order. This provides sophisticated sorting capabilities for complex data structures.

Insertion Sort

1. Basic Insertion Sort

Insertion sort builds the sorted array one element at a time by taking each element and inserting it into its correct position in the sorted portion. This algorithm is efficient for small datasets and nearly sorted data.

cobol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
       PROCEDURE DIVISION.
       INSERTION-SORT-EXAMPLE.
           DISPLAY 'Insertion Sort Example'
           
           *> Initialize table
           PERFORM INITIALIZE-SORT-TABLE
           
           *> Display unsorted table
           PERFORM DISPLAY-TABLE 'BEFORE SORT'
           
           *> Perform insertion sort
           PERFORM INSERTION-SORT-ALGORITHM
           
           *> Display sorted table
           PERFORM DISPLAY-TABLE 'AFTER SORT'
           
           STOP RUN.
       
       INSERTION-SORT-ALGORITHM.
           DISPLAY 'Performing insertion sort'
           
           PERFORM VARYING OUTER-INDEX FROM 2 BY 1
               UNTIL OUTER-INDEX > TABLE-SIZE
               
               MOVE ENTRY-VALUE(OUTER-INDEX) TO CURRENT-VALUE
               MOVE ENTRY-NAME(OUTER-INDEX) TO CURRENT-NAME
               MOVE OUTER-INDEX TO INNER-INDEX
               
               *> Move elements greater than current value
               PERFORM UNTIL INNER-INDEX = 1 OR 
                          ENTRY-VALUE(INNER-INDEX - 1) <= CURRENT-VALUE
                   MOVE ENTRY-VALUE(INNER-INDEX - 1) TO ENTRY-VALUE(INNER-INDEX)
                   MOVE ENTRY-NAME(INNER-INDEX - 1) TO ENTRY-NAME(INNER-INDEX)
                   SUBTRACT 1 FROM INNER-INDEX
               END-PERFORM
               
               *> Insert current value at correct position
               MOVE CURRENT-VALUE TO ENTRY-VALUE(INNER-INDEX)
               MOVE CURRENT-NAME TO ENTRY-NAME(INNER-INDEX)
           END-PERFORM

Insertion sort builds the sorted array incrementally by inserting each element into its correct position in the already sorted portion of the array.

2. Binary Insertion Sort

Binary insertion sort uses binary search to find the correct insertion position, reducing the number of comparisons needed for insertion.

cobol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
       PROCEDURE DIVISION.
       BINARY-INSERTION-SORT-EXAMPLE.
           DISPLAY 'Binary Insertion Sort Example'
           
           *> Initialize table
           PERFORM INITIALIZE-SORT-TABLE
           
           *> Perform binary insertion sort
           PERFORM BINARY-INSERTION-SORT-ALGORITHM
           
           *> Display results
           PERFORM DISPLAY-TABLE 'BINARY INSERTION SORT'.
       
       BINARY-INSERTION-SORT-ALGORITHM.
           DISPLAY 'Performing binary insertion sort'
           
           PERFORM VARYING OUTER-INDEX FROM 2 BY 1
               UNTIL OUTER-INDEX > TABLE-SIZE
               
               MOVE ENTRY-VALUE(OUTER-INDEX) TO CURRENT-VALUE
               MOVE ENTRY-NAME(OUTER-INDEX) TO CURRENT-NAME
               
               *> Find insertion position using binary search
               PERFORM BINARY-SEARCH-INSERTION-POSITION
               
               *> Shift elements to make room
               PERFORM SHIFT-ELEMENTS-FOR-INSERTION
               
               *> Insert current value at correct position
               MOVE CURRENT-VALUE TO ENTRY-VALUE(INSERTION-POSITION)
               MOVE CURRENT-NAME TO ENTRY-NAME(INSERTION-POSITION)
           END-PERFORM.
       
       BINARY-SEARCH-INSERTION-POSITION.
           MOVE 1 TO LEFT-BOUND
           MOVE OUTER-INDEX - 1 TO RIGHT-BOUND
           
           PERFORM UNTIL LEFT-BOUND > RIGHT-BOUND
               COMPUTE MIDDLE-POINT = (LEFT-BOUND + RIGHT-BOUND) / 2
               
               IF ENTRY-VALUE(MIDDLE-POINT) <= CURRENT-VALUE
                   COMPUTE LEFT-BOUND = MIDDLE-POINT + 1
               ELSE
                   COMPUTE RIGHT-BOUND = MIDDLE-POINT - 1
               END-IF
           END-PERFORM
           
           MOVE LEFT-BOUND TO INSERTION-POSITION.
       
       SHIFT-ELEMENTS-FOR-INSERTION.
           PERFORM VARYING SHIFT-INDEX FROM OUTER-INDEX BY -1
               UNTIL SHIFT-INDEX <= INSERTION-POSITION
               MOVE ENTRY-VALUE(SHIFT-INDEX - 1) TO ENTRY-VALUE(SHIFT-INDEX)
               MOVE ENTRY-NAME(SHIFT-INDEX - 1) TO ENTRY-NAME(SHIFT-INDEX)
           END-PERFORM

Binary insertion sort uses binary search to find the correct insertion position, reducing comparisons and improving performance for larger datasets.

SORT Statement

1. Basic SORT Statement

The SORT statement provides efficient file sorting capabilities, allowing programs to sort input files and produce sorted output files with specified sort keys.

cobol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
       DATA DIVISION.
       FILE SECTION.
       FD INPUT-FILE.
       01 INPUT-RECORD.
           05 CUSTOMER-ID       PIC 9(5).
           05 CUSTOMER-NAME     PIC X(20).
           05 CUSTOMER-BALANCE  PIC 9(8)V99.
       
       FD OUTPUT-FILE.
       01 OUTPUT-RECORD.
           05 CUSTOMER-ID       PIC 9(5).
           05 CUSTOMER-NAME     PIC X(20).
           05 CUSTOMER-BALANCE  PIC 9(8)V99.
       
       SD SORT-FILE.
       01 SORT-RECORD.
           05 CUSTOMER-ID       PIC 9(5).
           05 CUSTOMER-NAME     PIC X(20).
           05 CUSTOMER-BALANCE  PIC 9(8)V99.
       
       PROCEDURE DIVISION.
       SORT-STATEMENT-EXAMPLE.
           DISPLAY 'SORT Statement Example'
           
           *> Sort by customer ID (ascending)
           SORT SORT-FILE
               ON ASCENDING KEY CUSTOMER-ID
               INPUT PROCEDURE IS INPUT-PROCEDURE
               OUTPUT PROCEDURE IS OUTPUT-PROCEDURE
           
           DISPLAY 'Sort completed successfully'
           STOP RUN.
       
       INPUT-PROCEDURE SECTION.
       INPUT-PROCEDURE.
           DISPLAY 'Input procedure - reading input file'
           
           OPEN INPUT INPUT-FILE
           
           PERFORM UNTIL FILE-EOF
               READ INPUT-FILE
               IF FILE-OK
                   RELEASE SORT-RECORD FROM INPUT-RECORD
               END-IF
           END-PERFORM
           
           CLOSE INPUT-FILE.
       
       OUTPUT-PROCEDURE SECTION.
       OUTPUT-PROCEDURE.
           DISPLAY 'Output procedure - writing sorted output'
           
           OPEN OUTPUT OUTPUT-FILE
           
           PERFORM UNTIL NO-MORE-RECORDS
               RETURN SORT-FILE
               AT END
                   SET NO-MORE-RECORDS TO TRUE
               NOT AT END
                   WRITE OUTPUT-RECORD FROM SORT-RECORD
           END-PERFORM
           
           CLOSE OUTPUT-FILE

The SORT statement provides efficient file sorting with input and output procedures. This method is preferred for large files and provides excellent performance.

2. Multi-Key SORT Statement

Multi-key SORT statement allows sorting by multiple keys in priority order, providing sophisticated sorting capabilities for complex data structures.

cobol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
       PROCEDURE DIVISION.
       MULTI-KEY-SORT-EXAMPLE.
           DISPLAY 'Multi-Key SORT Statement Example'
           
           *> Sort by department (ascending), then by salary (descending)
           SORT SORT-FILE
               ON ASCENDING KEY DEPARTMENT
               ON DESCENDING KEY SALARY
               INPUT PROCEDURE IS MULTI-KEY-INPUT-PROCEDURE
               OUTPUT PROCEDURE IS MULTI-KEY-OUTPUT-PROCEDURE
           
           DISPLAY 'Multi-key sort completed successfully'
           STOP RUN.
       
       MULTI-KEY-INPUT-PROCEDURE SECTION.
       MULTI-KEY-INPUT-PROCEDURE.
           DISPLAY 'Multi-key input procedure'
           
           OPEN INPUT EMPLOYEE-FILE
           
           PERFORM UNTIL FILE-EOF
               READ EMPLOYEE-FILE
               IF FILE-OK
                   RELEASE SORT-RECORD FROM EMPLOYEE-RECORD
               END-IF
           END-PERFORM
           
           CLOSE EMPLOYEE-FILE.
       
       MULTI-KEY-OUTPUT-PROCEDURE SECTION.
       MULTI-KEY-OUTPUT-PROCEDURE.
           DISPLAY 'Multi-key output procedure'
           
           OPEN OUTPUT SORTED-EMPLOYEE-FILE
           
           PERFORM UNTIL NO-MORE-RECORDS
               RETURN SORT-FILE
               AT END
                   SET NO-MORE-RECORDS TO TRUE
               NOT AT END
                   WRITE SORTED-EMPLOYEE-RECORD FROM SORT-RECORD
           END-PERFORM
           
           CLOSE SORTED-EMPLOYEE-FILE

Multi-key SORT statement sorts by multiple keys in priority order, providing sophisticated sorting capabilities for complex business requirements.

Algorithm Selection

1. Choosing the Right Algorithm

Choosing the right sorting algorithm depends on data size, data characteristics, performance requirements, and available resources. Different algorithms are optimal for different situations.

cobol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
       PROCEDURE DIVISION.
       ALGORITHM-SELECTION-EXAMPLE.
           DISPLAY 'Algorithm Selection Example'
           
           *> Analyze data characteristics
           PERFORM ANALYZE-DATA-CHARACTERISTICS
           
           *> Select appropriate sorting algorithm
           PERFORM SELECT-SORTING-ALGORITHM
           
           *> Execute selected algorithm
           PERFORM EXECUTE-SELECTED-ALGORITHM.
       
       ANALYZE-DATA-CHARACTERISTICS.
           DISPLAY 'Analyzing data characteristics'
           
           *> Check data size
           IF DATA-SIZE < 50
               DISPLAY 'Small dataset - insertion sort recommended'
               MOVE 'INSERTION' TO RECOMMENDED-ALGORITHM
           ELSE
               IF DATA-SIZE < 1000
                   DISPLAY 'Medium dataset - selection sort recommended'
                   MOVE 'SELECTION' TO RECOMMENDED-ALGORITHM
               ELSE
                   DISPLAY 'Large dataset - SORT statement recommended'
                   MOVE 'SORT' TO RECOMMENDED-ALGORITHM
               END-IF
           END-IF
           
           *> Check if data is nearly sorted
           IF DATA-NEARLY-SORTED = 'Y'
               DISPLAY 'Nearly sorted data - insertion sort optimal'
               MOVE 'INSERTION' TO RECOMMENDED-ALGORITHM
           END-IF
           
           *> Check memory constraints
           IF MEMORY-CONSTRAINED = 'Y'
               DISPLAY 'Memory constrained - external sort required'
               MOVE 'EXTERNAL-SORT' TO RECOMMENDED-ALGORITHM
           END-IF.
       
       SELECT-SORTING-ALGORITHM.
           DISPLAY 'Selected algorithm: ' RECOMMENDED-ALGORITHM
           
           EVALUATE RECOMMENDED-ALGORITHM
               WHEN 'INSERTION'
                   PERFORM PREPARE-INSERTION-SORT
               WHEN 'SELECTION'
                   PERFORM PREPARE-SELECTION-SORT
               WHEN 'SORT'
                   PERFORM PREPARE-SORT-STATEMENT
               WHEN 'EXTERNAL-SORT'
                   PERFORM PREPARE-EXTERNAL-SORT
           END-EVALUATE.
       
       EXECUTE-SELECTED-ALGORITHM.
           DISPLAY 'Executing selected algorithm'
           
           EVALUATE RECOMMENDED-ALGORITHM
               WHEN 'INSERTION'
                   PERFORM INSERTION-SORT-ALGORITHM
               WHEN 'SELECTION'
                   PERFORM SELECTION-SORT-ALGORITHM
               WHEN 'SORT'
                   PERFORM SORT-STATEMENT-EXAMPLE
               WHEN 'EXTERNAL-SORT'
                   PERFORM EXTERNAL-SORT-EXAMPLE
           END-EVALUATE

Algorithm selection analyzes data characteristics, size, and constraints to choose the most appropriate sorting algorithm for optimal performance.

Best Practices for Sorting Algorithms

Common Sorting Patterns

Data Ordering

Learn data ordering

Sort Operations

Master sort operations

Table Processing

Learn table processing

Data Organization

Master data organization

Performance Tuning

Learn performance tuning

Algorithm Design

Master algorithm design