Ministerul Educaţiei

al Republicii Moldova

Universitatea Tehnică a Moldovei

RAPORT
despre lucrarea de laborator Nr. 2
la Structuri de Date si Algoritmi

Tema: Programarea procedurală a algoritmilor de sortare a

datelor din array (-uri) 1-D & 2-D
Varianta 13

A îndeplinit: Eșanu Cristina

Chişinău – 2020
Mersul lucrării:
EX I

Codul:
#include <stdio.h>
int len;
int temp;
int main(){
int i,k,l;
printf("Introdu marimea array-ului(numar impar): ");
scanf("%d", &len);
if(len%2 != 1){
len++;
printf("Ai introdus un nr par, lungimea este %d", len); }
int arr1[len], arr2[len];
printf("\nIntrodu elementele array-ului: \n");
for(i=0;i<len;i++){
printf("Element[%d]: ", i);
scanf("%d", &arr1[i]);
arr2[i] = arr1[i]; }
printf("Introdu index k si index l"); scanf("%d %d", &k, &l);
modificare(arr1,arr2,k,l);
printf("\nArray-ul original: ");
for(i=0;i<len;i++){
printf("%d ", arr1[i]);}
printf("\nArray-ul Schimbat: ");
for(i=0;i<len;i++){
printf("%d ", arr2[i]);}
quicksortCrescator(arr1, 0, len-1); printf("\nArray-ul original sortat crescator
prin Quick Sort: ");
for(i=0;i<len;i++){
printf("%d ", arr1[i]);}
quicksortDescrescator(arr1, 0, len-1); printf("\nArray-ul original sortat
descrescator prin Quick Sort: ");
for(i=0;i<len;i++){
printf("%d ", arr1[i]);}
shellSortCrescator(arr2, len); printf("\nArray-ul modificat sortat crescator prin
Shell Sort: ");
for(i=0;i<len;i++){
printf("%d ", arr2[i]);}
shellSortDescrescator(arr2, len); printf("\nArray-ul modificat sortat descrescator
prin Shell Sort: ");
for(i=0;i<len;i++){
 printf("%d ", arr2[i]);}
return 0;}
int modificare(int *arr1, int *arr2, int a, int b){
int i,j;
for(i=a, j=b-1; i<b; i++,j--){
arr2[i] = arr1[j];}
int quicksortCrescator(int *arr, int low, int high){
if (low<high){
int pi = partitieCrescatoare(arr, low, high);
quicksortCrescator(arr, low, pi-1);
quicksortCrescator(arr, pi+1, high);}
return 0;}
int partitieCrescatoare(int *arr, int low, int high){
int pivot = arr[high];
int i = (low - 1);
for(int j = low; j<= high - 1; j++){
if(arr[j] < pivot){
i++;
swap(&arr[i], &arr[j]);}}
swap(&arr[i+1], &arr[high]);
return (i+1);}
void swap(int* a, int* b)
{
int t = *a;
*a = *b;
*b = t;
}
int quicksortDescrescator(int *arr, int low, int high){
if (low<high){
int pi = partitieDescrescatoare(arr, low, high);
quicksortDescrescator(arr, low, pi-1);
quicksortDescrescator(arr, pi+1, high);
}
return 0;
int partitieDescrescatoare(int *arr, int low, int high){
int pivot = arr[high];
 int i = (low - 1);
for(int j = low; j<= high - 1; j++){
if(arr[j] > pivot){
i++
swap(&arr[i], &arr[j]);}}
swap(&arr[i+1], &arr[high]);
return (i+1);}
int shellSortCrescator(int *arr, int n)
{
for (int gap = n/2; gap > 0; gap /= 2)
{
for (int i = gap; i < n; i += 1)
{
int temp = arr[i];
int j;
for (j = i; j >= gap && arr[j - gap] > temp; j -= gap)
arr[j] = arr[j - gap];
arr[j] = temp; } }
return 0;}

int shellSortDescrescator(int *arr, int n)

{
for (int gap = n/2; gap > 0; gap /= 2)
{
for (int i = gap; i < n; i += 1)
{

int temp = arr[i];

int j;
for (j = i; j >= gap && arr[j - gap] < temp; j -= gap)
arr[j] = arr[j - gap];
arr[j] = temp; } }
return 0;
}
 Output

Introdu marimea array-ului(numar impar): 7

Introdu elementele array-ului:

Element[0]: 5
Element[1]: 9
Element[2]: 3
Element[3]: 4
Element[4]: 1
Element[5]: 2
Element[6]: 88
Introdu index k si index l: 1 5

Array-ul original: 5 9 3 4 1 2 88
Array-ul dupa schimbari: 5 1 4 3 9 2 88
Array-ul original sortat crescator: 1 2 3 4 5 9 88
Array-ul original sortat descrescator: 88 9 5 4 3 2 1
Array-ul modificat sortat crescator prin Shell Sort: 1 2 3 4 5 9 88
Array-ul modificat sortat descrescator prin Shell Sort: 88 9 5 4 3 2 1
 Ex 2

Codul:

#include <stdio.h>
int t,i,j,m;
int produs = 1;
int main(){
int idx=0, idx1, idx2;
printf("Introdu dimensiunea MxM ale array-ului: "); scanf("%d", &m);
int arr1[m][m], arr2[m*m], arr3[m][m],ultimRand[m];
printf("Introdu elementele array-ului: \n");
for(i=0;i<m;i++){
for(j=0;j<m;j++){
printf("Element[%d][%d]: ", i,j); scanf("%d", &arr1[i][j]);
arr3[i][j] = arr1[i][j];
arr2[idx] = arr1[i][j];
idx++;}}
printf("Array-ul de input este: \n");
for(i=0;i<m;i++){
for(j=0;j<m;j++){
printf("%d ", arr1[i][j]);
}printf("\n");}
printf("Acesta este array-ul sub forma unui array 1-D");
for(i=0;i<m*m;i++){
printf("%d ", arr2[i]);}
printf("\nIntrodu indecsii de start si final: ");scanf("%d %d", &idx1, &idx2);
laPatrat(arr2, idx1, idx2);
idx = 0;
for(i=0;i<m;i++){
for(j=0;j<m;j++){
arr3[i][j] = arr2[idx];
idx++; }}
printf("Array-ul dupa interschimbare: \n");
for(i=0;i<m;i++){
for(j=0;j<m;j++){
printf("%d ", arr3[i][j]);
}printf("\n");}
for(i=0;i<m;i++){
ultimRand[i] = arr3[m-1][i];}
countingSort(arr1, m);
printf("Array-ul original cu primul rand sortat crescator: \n");
for(i=0;i<m;i++){
for(j=0;j<m;j++){
printf("%d ", arr1[i][j]);
 }printf("\n");}
heapSort(ultimRand,m);
for(i=0;i<m;i++){
arr3[m-1][i] = ultimRand[i];}
printf("Array-ul modificat cu ultimul rand sortat descrescator");
for(i=0;i<m;i++){
for(j=0;j<m;j++){
printf("%d ", arr3[i][j]);
}printf("\n");}
return 0;}
int laPatrat(int arr[m], int a, int b){
for(i=a;i<b;i++){
arr[i] *= arr[i]; }
return 0;}

int prod(int arr[m][m], int r1, int r2){

for(i=0;i<m;i++){
produs *= arr[r1][i];
produs *= arr[r2][i];}
return 0;}

void countingSort(int array[m][m], int size)

{
int output[10];
int max = array[0][0];
for (int i = 1; i < size; i++)
{
if (array[0][i] > max)
max = array[0][i];}
int count[10];
for (int i = 0; i <= max; ++i)
{
count[i] = 0;}
for (int i = 0; i < size; i++)
{
count[array[0][i]]++; }
 for (int i = 1; i <= max; i++)
{
count[i] += count[i - 1]; }
for (int i = 0; i <= size-1; i++)
{
output[count[array[0][i]] - 1] = array[0][i];
count[array[0][i]]--;}
for (int i = 0; i < size; i++)
{
array[0][i] = output[i];}}

void heapify(int arr[], int n, int root)

{
int largest = root;
int l = 2*root + 1;
int r = 2*root + 2;

if (l < n && arr[l] > arr[largest])

largest = l;
if (r < n && arr[r] > arr[largest])
largest = r;
if (largest != root)
{
swap(arr[root], arr[largest]);
heapify(arr, n, largest);}}

void heapSort(int arr[], int n)

{
for (int i = n / 2 - 1; i >= 0; i--)
heapify(arr, n, i);
for (int i=n-1; i>=0; i--)
{

swap(arr[0], arr[i]);
heapify(arr, i, 0);}}
void swap(int* a, int* b)
{
int t = *a;
*a = *b;
*b = t;}
Output:

Introdu dimensiunea MxM ale array-ului: 3

Introdu elementele array-ului:
Element[0][0]: 2
Element[0][1]: 3
Element[0][2]: 1
Element[1][0]: 5
Element[1][1]: 4
Element[1][2]: 6
Element[2][0]: 8
Element[2][1]: 3
Element[2][2]: 4
Array-ul de input este:
231
546
834
Acesta este array-ul sub forma unui array 1-D2 3 1 5 4 6 8 3 4
Introdu indecsii de start si final: 2 5
Array-ul dupa interschimbare:
231
25 16 6
834
Array-ul modificat cu ultimul rând sortat descrescator
231
25 16 6
843

Concluzie:
În aceasta lucrare de laborator am lucrat cu diferite tipuri de sortare cum ar fi
Counting Sort cresctator și descrescator, atât cât și cu Quick Sort și Shell Sort
. Am folosit aceste sortari în array-uri unidimensionale și bidimensionale. Am
folosit și funcții parametrice.