Implémentation de l’algorithme de tri à bulles en COBOL

Un des algorithmes de tri les plus simples à appréhender est celui du tri à bulles. Il consiste à balayer la liste autant de fois qu’il y a d’éléments, et à chaque passage de faire remonter en fin de liste les plus grands éléments détectés. C’est également l’algorithme le plus lent.

Fonctionnement de l’algorithme de tri à bulles

Je vous propose une implémentation qui comporte des exemples d’utilisation des instructions COBOL suivantes :

• Tableaux à taille dynamique : OCCURS … DEPENDING ON…
• Double boucle imbriquée faisant varier deux indices : PERFORM VARYING …

      ******************************************************************
      * Component : BBUBSORT (COBOL batch)
      * Author : Cyril Coquilleau
      * Date : 2018-04-14
      * Purpose : Implements bubble sort algorithm
      ******************************************************************
       IDENTIFICATION DIVISION.
       PROGRAM-ID. BBUBSORT.
       DATA DIVISION.
       WORKING-STORAGE SECTION.
      *Array definition
       01 ARRAY-GROUP.
           03 ARRAY-SIZE      PIC 9(9) VALUE 100.
           03 ELT-ARRAY OCCURS 0 TO 9999999 DEPENDING ON ARRAY-SIZE.
              05 ELT-VALUE     PIC 9(8).

      *Indexes
       01 NUM             PIC 9(9).
       01 I               PIC 9(9).
       01 J               PIC 9(9).

      *Temporary data for swapping
       01 ELT-VALUE-TEMP  PIC 9(8).


       PROCEDURE DIVISION.

       MAIN-PROCEDURE.
           DISPLAY 'DATA BEFORE BUBBLE SORT'
           PERFORM VARYING NUM FROM 1 BY 1 UNTIL NUM > ARRAY-SIZE
             COMPUTE ELT-VALUE(NUM) = 1 + FUNCTION RANDOM * 10000000 
             DISPLAY ELT-VALUE(NUM)          
           END-PERFORM
       
      *    Sorting the array with Bubble Sort algorithm
           PERFORM VARYING I FROM ARRAY-SIZE BY -1 UNTIL I = 1
             PERFORM VARYING J FROM 1 BY 1 UNTIL J = I
           
      *        Swapping if needed 
               IF ELT-VALUE(J + 1) < ELT-VALUE(J)
                  MOVE ELT-VALUE(J + 1) TO ELT-VALUE-TEMP
                  MOVE ELT-VALUE(J)       TO ELT-VALUE(J + 1)
                  MOVE ELT-VALUE-TEMP     TO ELT-VALUE(J)
               END-IF
            END-PERFORM
          END-PERFORM

          DISPLAY 'DATA AFTER BUBBLE SORT'
          PERFORM VARYING NUM FROM 1 BY 1 UNTIL NUM > ARRAY-SIZE
             DISPLAY ELT-VALUE(NUM)          
          END-PERFORM            
            
          GOBACK
          .
       END PROGRAM BBUBSORT.

Nota : l’utilisation du PERFORM VARYING … AFTER … afin d’effectuer une double boucle imbriquée est possible sur certains compilateurs, mais tend à être de moins en moins acceptée sur les versions des compilateurs les plus récentes.