Laborator2 „Utilizarea tehnicilor de sortare a datelor.

Algoritmi de sortare
internă”.

Sarcina: (Obligatoriu)
1. Se consideră un vector de maxim 20 elemente de tip întreg. Numărul de elemente N și valorile lor se citesc de la terminal. Elaborați un program pentru
sortarea ascendentă a acestui masiv liniar utilizând metodele:
a) sortare prin simplă înserare (Straight insertion);
b) sortare prin simplă selectare (Straight selection);
c) sortare prin simplu schimb (Buble sort);
d) sortare de tipul Shaker. (Shakersort)
în limbajele C++, Java.

2. Analiza performanţelor algoritmilor de sortare.

Program A: Straight insertion

#include "stdafx.h"
#include <bits/stdc++.h>
using namespace std;
  
/* Function to sort an array using insertion sort*/
void insertionSort(int arr[], int n) 
{ 
    int i, key, j; 
    for (i = 1; i < n; i++)
    { 
        key = arr[i]; 
        j = i - 1; 
        /* Move elements of arr[0..i-1], that are 
        greater than key, to one position ahead 
        of their current position */
        while (j >= 0 && arr[j] > key)
        { 
            arr[j + 1] = arr[j]; 
            j = j - 1; 
        } 
        arr[j + 1] = key; 
    } 
}    
// A utility function to print an array of size n 
void printArray(int arr[], int n) 
{ 
    int i; 
    for (i = 0; i < n; i++) 
    cout << arr[i] << " "; 
    cout << endl;
}   
/* Driver code */
int main() 
{ 
    int arr[] = { 12, 11, 13, 5, 6 }; 
    int n = sizeof(arr) / sizeof(arr[0]); 
    insertionSort(arr, n); 
    printArray(arr, n); 
    return 0; 
} 

Program B: Straight selection

#include <iostream>
#include <string>
#include <bits/stdc++.h>
using namespace std;

void swap(int *xp, int *yp)

{
int temp = *xp;
*xp = *yp;
*yp = temp;
}
void selectionSort(int arr[], int n)
{
int i, j, min_idx;
for (i = 0; i < n-1; i++)
{
min_idx = i;
for (j = i+1; j < n; j++)
if (arr[j] < arr[min_idx])
min_idx = j;
swap(&arr[min_idx], &arr[i]);
}
}
void printArray(int arr[], int size)
{
int i;
for (i=0; i < size; i++)
cout << arr[i] << " ";
cout << endl;
}
int main()
{
int arr[] = {64, 25, 12, 22, 11};
int n = sizeof(arr)/sizeof(arr[0]);
selectionSort(arr, n);
cout << "Sorted array: \n";
printArray(arr, n);
return 0;
}
 Program C: Buble sort
#include <iostream>
#include <string>
#include <bits/stdc++.h>
using namespace std;

void swap(int *xp, int *yp)

{
int temp = *xp;
*xp = *yp;
*yp = temp;
}
void bubbleSort(int arr[], int n)
{
int i, j;
for (i = 0; i < n-1; i++)

// Last i elements are already in place

for (j = 0; j < n-i-1; j++)
if (arr[j] > arr[j+1])
swap(&arr[j], &arr[j+1]);
}
void printArray(int arr[], int size)
{
int i;
for (i = 0; i < size; i++)
cout << arr[i] << " ";
cout << endl;
}
int main()
{
int arr[] = {64, 34, 25, 12, 22, 11, 90};
int n = sizeof(arr)/sizeof(arr[0]);
bubbleSort(arr, n);
cout<<"Sorted array: \n";
printArray(arr, n);
return 0;
}
 Program D: Shakersort
#include <iostream>
#include <string>
#include<iostream>

using namespace std;

void swap(int *a, int *b)

{
int temp;
temp = *a;
*a = *b;
*b = temp;
}
void ShakerSort(int a[], int n)
{
int i, j, k;
for(i = 0; i < n;)
{
for(j = i+1; j < n; j++)
{
if(a[j] < a[j-1])
swap(&a[j], &a[j-1]);
}
n--;
for(k = n-1; k > i; k--)
{
if(a[k] < a[k-1])
swap(&a[k], &a[k-1]);
}
i++;
}
}
int main()
{
int n, i;
cout<<"\nEnter the number of data element to be sorted: ";
cin>>n;

int arr[n];
for(i = 0; i < n; i++)
{
cout<<"Enter element "<<i+1<<": ";
cin>>arr[i];
}
ShakerSort(arr, n);
cout<<"\nSorted Data ";
for (i = 0; i < n; i++)
cout<<"->"<<arr[i];
return 0;
}

Algoritm de sortare:
Algoritmi de sortare Operaţia de ordonare a unor articole în funcţie de diverse criterii este
foarte des întâlnită în practică. Se cunosc o mulţime de algoritmi de sortare, majoritatea fiind
foarte simpli. În continuare vom încerca să prezintem unele dintre cele mai cunoscute metode de
sortare.
Metodele de sortare cele mai des folosite pot fi clasificate în două categorii: metode
directe şi metode avansate.
Metodele directe se bazează pe algoritmi de dificultate redusă, uşor de găsit şi de înţeles.
Metodele directe pe care le vom lua în considerare sunt sortarea prin selecţie (SelectSort),
sortarea prin inserţie (InsertSort) şi sortarea cu bule (BubbleSort). Metodele avansate se bazează
pe algoritmi puţin mai complicaţi, dar care nu necesită cunoştinţe avansate de algoritmică.
Câteva din cele mai cunoscute sunt sortarea rapidă (QuickSort), sortarea prin interclasare
(MergeSort) şi sortarea cu ansamble (HeapSort).
Orice programator trebuie să cunoască metodele de sortare şi să aleagă folosirea unei
metode, în funcţie de criteriul de eficienţă urmărit. Eficienţa metodelor de sortare, după cum am
precizat mai sus pentru algoritmi în general, se măsoară după tipul de execuţie şi memoria
folosită.