Interclasare

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();