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

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++){
}
quicksortCrescator(arr1, 0, len-1); printf("\nArray-ul original sortat crescator
prin Quick Sort: ");
for(i=0;i<len;i++){
}
quicksortDescrescator(arr1, 0, len-1); printf("\nArray-ul original sortat
descrescator prin Quick Sort: ");
for(i=0;i<len;i++){
}
shellSortCrescator(arr2, len); printf("\nArray-ul modificat sortat crescator prin
Shell Sort: ");
for(i=0;i<len;i++){
}
shellSortDescrescator(arr2, len); printf("\nArray-ul modificat sortat descrescator
prin Shell Sort: ");
for(i=0;i<len;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("\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("\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("\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("\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;
}
{
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]]--;
}
{
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.

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

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

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

Uploaded by

Copyright:

Available Formats

Ministerul Educaţiei

Universitatea Tehnică a Moldovei

Tema: Programarea procedurală a algoritmilor de sortare a

int modificare(int *arr1, int *arr2, int a, int b){

int quicksortCrescator(int *arr, int low, int high){

int partitieCrescatoare(int *arr, int low, int high){

void swap(int* a, int* b)

int quicksortDescrescator(int *arr, int low, int high){

int partitieDescrescatoare(int *arr, int low, int high){

int shellSortCrescator(int *arr, int n)

int temp = arr[i];

int shellSortDescrescator(int *arr, int n)

int temp = arr[i];

Introdu marimea array-ului(numar impar): 7

Introdu elementele array-ului:

int laPatrat(int arr[m], int a, int b){

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

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

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

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

void heapSort(int arr[], int n)

void swap(int* a, int* b)

Introdu dimensiunea MxM ale array-ului: 3

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

You might also like

int modificare(int arr1, int arr2, int a, int b){