Algoritm: Este un algoritm simplu, menit a transforma doua secvente ordonate intr-una singura, tot ordonata, care contine toate elementele celor doua secvente de pornire.
Presupunem că dorim să interclasăm tablourile unidimensionale A şi B, ordonate crescător, şi să obţinem secvenţa rezultat C, ordonată tot crescător.
A:
6
8
9
12
16
28
31
32
35
B:
4
5
7
10
11
14
19
24
36
C:
Presupunem că avem câte un indicator pentru fiecare din vectorii A şi B, care pornesc de pe prima poziţie a fiecăruia. La fiecare pas se compară cele două elemente corespunzătoare indicatorilor. Minimul dintre cele două elemente este adăugat la elementele vectorului C şi indicatorul corespunzător este mutat o poziţie spre dreapta (indicatorul din celălalt vector rămâne neschimbat). Dacă vreunul din indicatori depăşeşte limita dreaptă a vectorului asociat, se copiază elementele rămase în celălat vector la sfârşitul vectorului C, în ordinea în care apar. Algoritmul se încheie în momentul în care ambii indicatri au depăşit limita dreaptă a vectorilor asociaţi (A şi B).
A:
6
8
9
12
16
28
31
32
35
B:
4
5
7
10
11
14
19
24
36
C:
4
A:
6
8
9
12
16
28
31
32
35
B:
4
5
7
10
11
14
19
24
36
C:
4
5
4 < 6, trece 4
5 < 6, trece 5
A:
6
8
9
12
16
28
31
32
35
B:
4
5
7
10
11
14
19
24
36
C:
4
5
6
A:
6
8
9
12
16
28
31
32
35
B:
4
5
7
10
11
14
19
24
36
C:
4
5
6
7
6 < 7, trece 6
7 < 8, trece 7
A:
6
8
9
12
16
28
31
32
35
B:
4
5
7
10
11
14
19
24
36
C:
4
5
6
7
8
A:
6
8
9
12
16
28
31
32
35
B:
4
5
7
10
11
14
19
24
36
C:
4
5
6
7
8
9
8 < 10, trece 8
9 < 10, trece 9
A:
6
8
9
12
16
28
31
32
35
B:
4
5
7
10
11
14
19
24
36
C:
4
5
6
7
8
9
10
A:
6
8
9
12
16
28
31
32
35
B:
4
5
7
10
11
14
19
24
36
C:
4
5
6
7
8
9
10
11
10 < 12, trece 10
11 < 12, trece 11
A:
6
8
9
12
16
28
31
32
35
B:
4
5
7
10
11
14
19
24
36
C:
4
5
6
7
8
9
10
11
12
A:
6
8
9
12
16
28
31
32
35
B:
4
5
7
10
11
14
19
24
36
C:
4
5
6
7
8
9
10
11
12
12 < 14, trece 12
14 < 16, trece 14
14
A:
6
8
9
12
16
28
31
32
35
B:
4
5
7
10
11
14
19
24
36
C:
4
5
6
7
8
9
10
11
12
A:
6
8
9
12
16
28
31
32
35
B:
4
5
7
10
11
14
19
24
36
C:
4
5
6
7
8
9
10
11
12
16 < 19, trece 16
14
16
19 < 28, trece 19
14
16
19
A:
6
8
9
12
16
28
31
32
35
B:
4
5
7
10
11
14
19
24
36
C:
4
5
6
7
8
9
10
11
12
A:
6
8
9
12
16
28
31
32
35
B:
4
5
7
10
11
14
19
24
36
C:
4
5
6
7
8
9
10
11
12
24 < 28, trece 24
14
16
19
24
28 < 36, trece 28
14
16
19
24
28
A:
6
8
9
12
16
28
31
32
35
B:
4
5
7
10
11
14
19
24
36
C:
4
5
6
7
8
9
10
11
12
A:
6
8
9
12
16
28
31
32
35
B:
4
5
7
10
11
14
19
24
36
C:
4
5
6
7
8
9
10
11
12
31 < 36, trece 31
14
16
19
24
28
31
32 < 36, trece 32
14
16
19
24
28
31
32
A:
6
8
9
12
16
28
31
32
35
B:
4
5
7
10
11
14
19
24
36
C:
4
5
6
7
8
9
10
11
12
A:
6
8
9
12
16
28
31
32
35
B:
4
5
7
10
11
14
19
24
36
C:
4
5
6
7
8
9
10
11
12
35 < 36, trece 35
14
16
19
24
28
31
32
35
31
32
35
trece 36
14
16
19
24
28
36
A:
6
8
9
12
16
28
31
32
35
B:
4
5
7
10
11
14
19
24
36
C:
4
5
6
7
8
9
10
11
12
14
16
19
24
28
31
32
35
36
Ambele indicatoare au depăşit limita din dreapta a vectorilor asociaţi, deci algoritmul se opreşte aici.
Problemă:
Se citesc de la tastatura doi vectori A şi B de numere întregi ordonate. Să se creeze un vector C cu elementele din cei doi vectori A şi B, sortat şi să se afişeze vectorul C (INTERCLASARE).
Program: # include <iostream.h> # include <conio.h> int A[50], B[50], C[100], i, j, m, n, k; void main() { clrscr(); cout << “m=” ; cin >> m ; for( i = 0 ; i < m ; i++ ){ cout << “A[“ << i << “]=” ; cin >> A[i] ; } cout << “n=” ; cin >> n ; for( i = 0 ; i < n ; i++ ){ cout << “B[” << i << “]=” ; cin >> B[i] ; } i = 0 ; j = 0 ; k = 0; while ( i < m && j < n ){ if ( A[i] < B[j] ){ C[k] = A[i] ;
} else { }
}
k++ ; i++ ; C[k] = B[j] ; k++ ; j++ ;
} while ( i < m ){ C[k] = A[i] ; k++ ; i++ ; } while ( j < n ){ C[k] = B[j] ; k++ ; j++ ; } for( i = 0 ; i < k ; i++) cout << C[i] <<‘ ‘ ; getch();