daily pastebin goal
20%
SHARE
TWEET

Untitled

a guest Jan 22nd, 2019 55 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <iostream>
  2. using namespace std;
  3.  
  4. void ausgabe(int sortArr[], int length, int matrix[][4], int zweidimensional = 0){
  5.  
  6.     if (zweidimensional) {
  7.         for (int i = 0; i < length; i++)
  8.         {
  9.             for (int j = 0; j < zweidimensional; j++)
  10.             {
  11.                 cout << matrix[i][j] << ' ';
  12.             }
  13.             cout << endl;
  14.         }
  15.     }
  16.     else {
  17.         for (int i = 0; i < length; i++)
  18.         {
  19.             cout << sortArr[i] << ' ';
  20.         }
  21.         cout << endl;
  22.     }
  23. }
  24.  
  25. int getMinIndex(int sortArr[], int length, int start){
  26.     int temp = start;
  27.  
  28.     for (int i = start; i < length; i++) {
  29.         if (sortArr[temp] >= sortArr[i]) {
  30.             temp = i;
  31.         }
  32.     }
  33.    
  34.     return temp;
  35. }
  36.  
  37. void auswahlSort(int sortArr[], int length){
  38.     for (int i = 0; i < length; i++)
  39.     {
  40.         int temp = sortArr[i];
  41.         sortArr[i] = sortArr[getMinIndex(sortArr, length, i)];
  42.         sortArr[getMinIndex(sortArr, length, i)] = temp;
  43.     //  cout << sortArr[i] << ' ';
  44.     }
  45. }
  46.  
  47. void tauschen(int sortArr[], int index){
  48.     int temp = sortArr[index];
  49.     sortArr[index] = sortArr[index + 1];
  50.     sortArr[index + 1] = temp;
  51. }
  52.  
  53. void bubbleSort(int sortArr[], int length){
  54.     bool status = false;
  55.     for (int i = 0; i < length; i++)
  56.     {
  57.         if (sortArr[i + 1] > sortArr[i])
  58.         {
  59.             tauschen(sortArr, i);
  60.             status = true;
  61.         }
  62.        
  63.         if (status)
  64.         {
  65.             bubbleSort(sortArr, length);
  66.         }
  67.     }
  68. }
  69.  
  70. void matrixSort(int matrix[][4], const int x, const int y, int type) {
  71.     int temp[16];
  72.     int index = 0;
  73.     for (int i = 0; i < x; i++)
  74.     {
  75.         for (int j = 0; j < y; j++)
  76.         {
  77.             temp[index++] = matrix[i][j];
  78.         }
  79.     }
  80.    
  81.     bubbleSort(temp, y * x);
  82.     //ausgabe(temp, y*x, matrix);
  83.    
  84.     if (type != 3) {
  85.         for (int i = 0; i < x; i++)
  86.         {
  87.             for (int j = 0; j < y; j++)
  88.             {
  89.                 if (type == 1){
  90.                     matrix[j][i] = temp[--index];
  91.                 }
  92.                 else if (type == 2) {
  93.                     matrix[i][j] = temp[--index];
  94.                 }
  95.             }
  96.         }
  97.     }
  98.     else
  99.     {
  100.         for (int i = 0; i > x; i++)
  101.         {
  102.             int n = 4;
  103.             for (int j = 0; j < n; j++)
  104.             {
  105.                 matrix[i + n][j] = temp[--index];
  106.                 n--;
  107.    
  108.             }
  109.  
  110.        
  111.         }
  112.     }
  113. }
  114.  
  115. int getNext(int feld[], int length){
  116.    
  117.     for (int i = 0;  i < length;  i++)
  118.     {
  119.         if (feld[i] > feld[length])
  120.         {
  121.             return i;
  122.         }
  123.     }
  124.     return -1;
  125. }
  126.  
  127. int getNext2(int feld[], int start, int length){
  128.  
  129.     for (int i = start; i > length; i--)
  130.     {
  131.         if (feld[i] < feld[length])
  132.         {
  133.             return i;
  134.         }
  135.     }
  136.     return -1;
  137. }
  138. void tauschen(int feld[], int i, int j){
  139.     int temp = feld[i];
  140.     feld[i] = feld[j];
  141.     feld[j] = temp;
  142. }
  143.  
  144. bool test(int feld[], int anfang, int ende){
  145.     for (size_t i = anfang + 1; i < ende; i++)
  146.     {
  147.         int temp = feld[anfang];
  148.         if (feld[i] < temp)
  149.         {
  150.             return false;
  151.         }
  152.         else {
  153.             temp = feld[i];
  154.         }
  155.     }
  156.     return true;
  157. }
  158.  
  159. void quicksort(int feld[], int anfang, int ende) {
  160.  
  161.     int pivotelement = ((ende - anfang) / 2) + anfang;
  162.     int tempI = -1, tempJ = -1;
  163.     int j = ende;
  164.  
  165.     for (int i = anfang; i < pivotelement; i++)
  166.     {
  167.         tempI = getNext(feld, pivotelement);
  168.         tempJ = getNext2(feld, ende, pivotelement);
  169. //      cout << feld[tempI] << ' ' << feld[tempJ] << endl;
  170.        
  171.         if (tempI == -1 && tempJ == -1)
  172.         {
  173.             quicksort(feld, anfang, pivotelement - 1);
  174.             quicksort(feld, pivotelement + 1, ende);
  175.         }
  176.  
  177.         if (tempI != -1 && tempJ != -1)
  178.         {
  179.             tauschen(feld,tempI, tempJ);
  180.            
  181.         }
  182.         else if (tempI != -1 && tempJ == -1)
  183.         {
  184.             tauschen(feld, tempI, pivotelement);
  185.         }
  186.         else if (tempJ != -1 && tempI == -1)
  187.         {
  188.             tauschen(feld, tempJ, pivotelement);
  189.         }
  190.         j--;
  191.  
  192.        
  193.        
  194.  
  195.        
  196.     }
  197. }
  198.  
  199. int main(){
  200.    
  201.     const int COUNT = 13;
  202.     const int X = 4;
  203.     const int Y = 4;
  204.    
  205.     int sortArr[COUNT] = { 3, 68, 7, 34, 35, 13, 16, 36, 99, 7, 6, 6, 4 };
  206.     int feld[COUNT] = { 2, 5, 88, 8, 3, 19, 17, -4, 22, 105, 33, 1, 2001 };
  207.     int matrix[4][4] = { 54, 80, 11, 91, 17, 23, 58, 28, 14, 56, 78, 34, 32, 26, 89, 78 };
  208.    
  209.     //auswahlSort(sortArr, COUNT);
  210.     //bubbleSort(sortArr, COUNT);
  211.     //ausgabe(sortArr, COUNT, matrix);
  212.     //matrixSort(matrix, X, Y, 1);
  213.     //matrixSort(matrix, X, Y, 2);
  214.     //matrixSort(matrix, X, Y, 3);
  215.     //ausgabe(sortArr, X, matrix, Y);
  216.    
  217.     quicksort(feld, 0, 12);
  218.     ausgabe(feld, COUNT, matrix);
  219.    
  220.     return 0;
  221. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top