paste

#include <stdio.h>
#include <stdlib.h>
#include<time.h>
#include"stdbool.h"
#define size 1000

bool LessEqualSorted(int bubble[], int SIZE);
void bubbleSort(int bubble[], int SIZE);  //Dem Programm angeben dass eine Funktion benutzt wird
void selectionSort(int selection[], int SIZE);

int main(void) {

	int i = 0;

	int bubble[size];
	int selection[size];

	srand(time(NULL));
	for (i = 0; i < size; i++) {
		bubble[i] = (rand() % 1001);
	}

	srand(time(NULL));
	for (int i = 0; i < 1000; i++) {
		selection[i] = (((int)rand() % 1001) - 500);    //doppelter positiver Wertebereich minus den positiven Bereich (von 1000 bis -500)
	}
	//-------------------------------------BUBBLE------------------------------------------------------------//
	puts("Unsortiertes Bubble Array:");

	for (i = 0; i < size; ++i) {             //Ausgabe Unsortierter Bubble
		printf("%4d", bubble[i]);
	}
	LessEqualSorted(bubble, size);           //Ausgabe ob es unsortiert oder sortiert ist

	bubbleSort(bubble, size);                //Anwendung der Bubble Sort Funktion

	puts("Sortiertes Bubble Array:");

	for (int i = 0; i < size; ++i) {         //Ausgabe der sortierten Bubble
		printf("%4d", bubble[i]);
	}

	LessEqualSorted(bubble, size);           //Ausgabe ob sortiert oder nicht

	//--------------------------------------SELECTION---------------------------------------------------//

	puts("\nUnsortiertes Selection Array:");

	for (int i = 0; i < size; ++i) {          //Ausgabe unsortiertes Selection
		printf("%4d", selection[i]);
	}

	LessEqualSorted(selection, size);         //Ausgabe ob sortiert oder nicht

	selectionSort(selection, size);           //Anwendung der selection sort funktion

	puts("Sortiertes Selection Array:");

	for (int i = 0; i < size; ++i) {           //Ausgabe sortiertes selection
		printf("%4d", selection[i]);
	}

	LessEqualSorted(selection, size);           //Ausgabe ob sortiert oder nicht

	//-----------------------------ENDE-------------------------//
	return 0;
}

void bubbleSort(int bubble[], int SIZE) {
	int temp = 0;
	int first = 0;
	int next = 0;

	for (first = 1; first < size; ++first) {
		for (next = 0; next < size - 1; ++next) {    //diese for Schleife läuft immer einmal weniger als die größe des Arrays durch weil dann alle Elemente verglichen wurden
			if (bubble[next] > bubble[next + 1]) {   //das Element wird mit dem darauffolgendem Element verglichen
				temp = bubble[next];                 // das größere Element wird Temporär abgespeichert
				bubble[next] = bubble[next + 1];     // der Stelle an dem sich das größere element befindet wird dem kleineren zugewiesen
				bubble[next + 1] = temp;             // der Stelle an dem sich das kleinere Element befindet wird das temporäre bzw. das größere Element zugewiesen
			}
		}
	}
}

void selectionSort(int selection[], int SIZE) {

	int first = 0;
	int next = 0;
	int min = 0;
	int min_pos = 0;
	int min_found = 0;
	int temp = 0;

	for (int j = 0; j < size; j++) {                               //das Programm muss nach der inneren Schleife erneut durchlaufen um alle Zahlen zu sortieren
		for (first = 0; first < size; first++) {
			for (next = first + 1; next < size; next++) {
				if (selection[first] > selection[next]) {          //Das erste Element wird mit zweiten elements diesen durchlaufs verglichen
					min = selection[next];                         //Die kleinere Zahl (min) wird an die Position des größeren Elements gerückt
					min_pos = next;                                //An der Position der an der sich das kleinere Element befindet wird die min_pos gesetzt
					min_found = 1;                                 //Ein Element gefunden
				}
			}
			if (min_found == 1) {
				temp = selection[first];                           //Wenn ein Element gefunden wurde wird die größere Zahl temp abgespeichert
				selection[first] = min;                            //An der Stelle der größeren Zahl wird die kleinere gesetzt
				selection[min_pos] = temp;                         //An der Position der kleineren Zahl wird die größere Zahl eingesetzt
				min_found = 0;                                     //min_found zurück auf 0 gesetzt
			}
		}
	}
}


bool LessEqualSorted(int arr[], int SIZE) {

	int first = 0;
	int next = 0;

	bool sorted = 0;                      //gibt nur 0 und 1 zurück für true und false

	for (first = 1; first < size; ++first) {
		for (next = 0; next < size - 1; ++next) {
			if (arr[next] > arr[next + 1]) {      //Es wird geprüft ob immer das daruffolgende Element sortiert ist
				sorted = 0;
				break;
			}
			else if (arr[next] < arr[next + 1]) {
				sorted = 1;
			}
		}
		if (sorted == 0) {
			puts("False");
			puts("Das Array ist NICHT sortiert!\n");
			return false;
			break;
		}
	}

	if (sorted == 1) {
		puts("True");
		puts("Das Array ist aufsteigend sortiert!");
		return true;
	}
}