Scribd
Upload
53 views

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

The document summarizes a laboratory work report on sorting algorithms. It implemented various sorting algorithms like counting sort, heap sort, quick sort, and shell sort on both 1D and 2D arrays. It modified arrays, sorted portions of arrays in increasing and decreasing order, and analyzed the results. Code examples in C were provided to demonstrate procedural programming of sorting algorithms on data arrays.

Uploaded by

gdsdfgsfahsfh
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
53 views

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

The document summarizes a laboratory work report on sorting algorithms. It implemented various sorting algorithms like counting sort, heap sort, quick sort, and shell sort on both 1D and 2D arrays. It modified arrays, sorted portions of arrays in increasing and decreasing order, and analyzed the results. Code examples in C were provided to demonstrate procedural programming of sorting algorithms on data arrays.

Uploaded by

gdsdfgsfahsfh
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 22

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:

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 dupa schimbari: ");
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

Schemele-Bloc:

Functia Swap:
Functia Main:
Functia modificare:

Functia quickSortCrescator:
Functia quickSortDescrescator:

Functia partitieCrescatoare:
Functia partitieDescrescatoare:

Functia swap:
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;
}

Scheme-Bloc:

Functia main:
Functia laPatrat:

Functia prod:

Functia swap:
Functia countingSort:
Functia heapify:

Functia heapSort:
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 și HeapSort, 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