Scribd
Upload
24 views

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

The document describes a laboratory report on procedural programming of sorting algorithms for 1D and 2D arrays. It includes code to sort arrays using Quicksort, Shellsort, Heapsort, and Countingsort. The code samples show sorting both original and modified 1D arrays in increasing and decreasing order. For 2D arrays, it verifies if an element equals a given value, then sorts the row using either Countingsort or Heapsort accordingly. The conclusion states different sorting techniques were used for 1D and 2D arrays to fulfill the purpose of the laboratory work.

Uploaded by

Belîi Daniela
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
24 views

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

The document describes a laboratory report on procedural programming of sorting algorithms for 1D and 2D arrays. It includes code to sort arrays using Quicksort, Shellsort, Heapsort, and Countingsort. The code samples show sorting both original and modified 1D arrays in increasing and decreasing order. For 2D arrays, it verifies if an element equals a given value, then sorts the row using either Countingsort or Heapsort accordingly. The conclusion states different sorting techniques were used for 1D and 2D arrays to fulfill the purpose of the laboratory work.

Uploaded by

Belîi Daniela
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/ 7

Ministerul Educaţiei

al Republicii Moldova
Universitatea Tehnică a Moldovei

RAPORT Nr. 2
la SDA
Tema: Programarea procedurală a algoritmilor de sortare
a
datelor din array (-uri) 1-D & 2-D
Varianta 3

A îndeplinit: Daniela Belii SI-191

Chişinău – 2020

EX I
Codul:
#include <stdio.h>
int len;
int temp;
int main(){
int i;
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(arr1,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 prin QuickSort: ");
for(i=0;i<len;i++){
printf("%d ", arr1[i]);
}
quicksortDescrescator(arr1, 0, len-1); printf("\nArray-ul original sortat descrescator prin QuickSort:
");
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 i;
for(i=0;i<len-1;i++){
arr2[i+1] *= arr1[i];
}
}

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: 7

Introdu elementele array-ului:


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

Array-ul original: 2 5 1 3 2 4 2
Array-ul dupa schimbari: 2 10 5 3 6 8 8
Array-ul original sortat crescator: 1 2 2 2 3 4 5
Array-ul original sortat descrescator: 5 4 3 2 2 2 1
Array-ul modificat sortat crescator prin Shell Sort: 2 3 5 6 8 8 10
Array-ul modificat sortat descrescator prin Shell Sort: 10 8 8 6 5 3 2

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 egale cu 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 swap(int* a, int* b)


{
int t = *a;
*a = *b;
*b = t;
}

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);
}
}
Output:
Introdu dimensiunea MxM ale array-ului4
Introdu elementele array-ului:
Element[0][0]: 2
Element[0][1]: 2
Element[0][2]: 1
Element[0][3]: 3
Element[1][0]: 4
Element[1][1]: 5
Element[1][2]: 2
Element[1][3]: 1
Element[2][0]: 5
Element[2][1]: 6
Element[2][2]: 5
Element[2][3]: 3
Element[3][0]: 5
Element[3][1]: 1
Element[3][2]: 1
Element[3][3]: 2
Array-ul de input este:
2213
4521
5653
5112
Introdu V: 2
Pe randul 0 sunt 2 egale cu V
Pe randul 1 sunt 1 egale cu V
Pe randul 2 sunt 0 egale cu V
Pe randul 3 sunt 1 egale cu V
Array-ul dupa sortarea randului ales este:
1223
4521
5653
5112

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 ,astfel realizând scopul
acestei lucrari de laborator.

You might also like