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 5

A îndeplinit: Iordan Marin

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

Codul:
#include <stdio.h>
int len,i,j;
int temp;
int main(){
printf("Introdu marimea array-ului: "); scanf("%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];
}
modificare(arr2);
printf("\nArray-ul original: ");
for(i=0;i<len;i++){
printf("%d ", arr1[i]);
 }
printf("\nArray-ul dupa schimbari: ");
for(i=0;i<len;i++){
printf("%d ", arr2[i]);
}
quicksortCrescator(arr1, 0, len-1); printf("\nArray-ul original sortat crescator: ");
for(i=0;i<len;i++){
printf("%d ", arr1[i]);
}
quicksortDescrescator(arr1, 0, len-1); printf("\nArray-ul original sortat
descrescator: ");
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 *arr){

int nrImpar, z=0;
for(i=0;i<len;i++){
if(arr[i]%2!= 0){
nrImpar = arr[i];
break;
}
}
 for(i=0;i<len;i++){
if(arr[i]%2 == 0){
arr[i] += nrImpar;
z++;
}
}
if(z==0){
printf("Nu sunt numere pare, toate numerele se inmultesc cu 2");
for(i=0;i<len;i++){
arr[i] *= 2;
}
}

return 0;
}

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;
}t 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: 7

Introdu elementele array-ului:

Element[0]: 5
Element[1]: 1
Element[2]: 2
Element[3]: 3
Element[4]: 1
Element[5]: 4
Element[6]: 5

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

Codul:

#include <stdio.h>
int t,i,j,m;
int main(){
int v;
printf("Introdu dimensiunea MxM ale array-ului"); scanf("%d", &m);
int arr[m][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", &arr[i][j]);
}
}
printf("Array-ul de input este: \n");
for(i=0;i<m;i++){
for(j=0;j<m;j++){
printf("%d ", arr[i][j]);
}printf("\n");
}
printf("Introdu V: "); scanf("%d", &v);

if(verificare(arr, v)%2==0){
countingSort(arr, m);
}else{
heapSort(arr,m);
}
printf("Array-ul dupa sortarea randului ales este: \n");
for(i=0;i<m;i++){
for(j=0;j<m;j++){
printf("%d ", arr[i][j]);
}printf("\n");
}
return 0;
}

int verificare(int array[m][m], int a){

int c = 0;
for(i=0;i<m;i++){
int count = 0;
for(j=0;j<m;j++){
if(array[i][j] > a){
count++; c++;
}
 }printf("Pe randul %d sunt %d elemente mai mari ca v\n", i, count);
}
return c;
}

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 = size - 1; i >= 0; 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[m][m], int n, int i)
{
int smallest = i;
int l = 2 * i + 1;
int r = 2 * i + 2;
if (l < n && arr[l][m-1] < arr[smallest][m-1])
smallest = l;
if (r < n && arr[r][m-1] < arr[smallest][m-1])
smallest = r;
if (smallest != i) {
swap(arr[i][m-1], arr[smallest][m-1]);
heapify(arr, n, smallest);
}
}
void heapSort(int arr[m][m], 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][m-1], arr[i][m-1]);

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]: 1
Element[0][1]: 3
Element[0][2]: 2
Element[1][0]: 4
Element[1][1]: 6
Element[1][2]: 5
Element[2][0]: 7
Element[2][1]: 9
Element[2][2]: 8
Array-ul de input este:
132
465
798
Introdu V: 3
Pe randul 0 sunt 0 elemente mai mari ca v
Pe randul 1 sunt 3 elemente mai mari ca v
Pe randul 2 sunt 3 elemente mai mari ca v
Array-ul dupa sortarea randului este:
123
465
798

Concluzie: În aceasta lucrare de laborator am lucrat cu diferite tipuri de

sortare cum ar fi Heap Sort și Counting Sort, 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.