Scribd
Upload
48 views13 pages

Tema: Programarea Procedurală A Algoritmilor de Sortare A Datelor Din Array (-Uri) 1-D & 2-D

The document describes a laboratory report on sorting algorithms. It implements various sorting algorithms like quicksort, shellsort, heap sort and counting sort to sort both 1D and 2D arrays. It includes code examples that take user input for array sizes and elements, apply the different sorting algorithms, and output the sorted arrays. Testing is done on sample input and output is displayed to show the sorting in action. The conclusion summarizes working with different sorting techniques on uni- and multi-dimensional arrays and using parameterized functions.

Uploaded by

Slavik Polskii
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
48 views13 pages

Tema: Programarea Procedurală A Algoritmilor de Sortare A Datelor Din Array (-Uri) 1-D & 2-D

The document describes a laboratory report on sorting algorithms. It implements various sorting algorithms like quicksort, shellsort, heap sort and counting sort to sort both 1D and 2D arrays. It includes code examples that take user input for array sizes and elements, apply the different sorting algorithms, and output the sorted arrays. Testing is done on sample input and output is displayed to show the sorting in action. The conclusion summarizes working with different sorting techniques on uni- and multi-dimensional arrays and using parameterized functions.

Uploaded by

Slavik Polskii
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 13

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.

You might also like