Programmieren lernen

*&---------------------------------------------------------------------*
*& Report  ZBUBBLESORT
*&
*&---------------------------------------------------------------------*
*& Sortiert eine Liste aus zufälligen Zahlen aufsteigend, mit Hilfe von Bubblesort
*&
*&---------------------------------------------------------------------*

REPORT  zbubblesort.

PARAMETERS: pa_n TYPE i,
            pa_r TYPE i.

DATA: lt_random TYPE TABLE OF i,
      ls_random LIKE LINE OF lt_random,
      ls_sorted LIKE LINE OF lt_random,
      lv_helper TYPE i,
      lv_zeilen TYPE i,
      lv_temp2 TYPE i,
      lv_temp3 TYPE i,
      lv_temp4 TYPE i,
      lv_temp5 TYPE i.


* Zufallszahlen generieren und in lt_random abspeichern.
DO pa_n TIMES.

  CALL FUNCTION 'GENERAL_GET_RANDOM_INT'
    EXPORTING
      range  = pa_r
    IMPORTING
      random = lv_helper.
  APPEND lv_helper TO lt_random.
ENDDO.

* Zeilenanzahl
DESCRIBE TABLE lt_random LINES lv_zeilen.

* Sortierschleife
WHILE sy-index < lv_zeilen.
  lv_temp2 = 0.
  READ TABLE lt_random INTO ls_sorted INDEX 1.
  LOOP AT lt_random INTO ls_random FROM 2 TO lv_zeilen.
    lv_temp3 = lv_temp3 + 1.
    lv_temp2 = lv_temp2 + 1.
    lv_temp4 = sy-tabix.

    " Vergleich der Zahlen.
    IF ls_sorted > ls_random.
      lv_temp5 = lv_temp4 - 1.
      " tauschen der Zahlen.
      MODIFY lt_random FROM ls_sorted INDEX lv_temp4.
      MODIFY lt_random FROM ls_random INDEX lv_temp5.
    ELSE.
      ls_sorted = ls_random.
    ENDIF.

  ENDLOOP.
ENDWHILE.

* Ausgabe zur Überprüfung
LOOP AT lt_random INTO ls_random.
  WRITE: ls_random,
         ' '.
ENDLOOP.
                

Lösung von: Alexander S. (msg systems)

var r = parseInt(prompt("Anzahl der generierten Zufallszahlen")),
    n = parseInt(prompt("Obergrenze der Zufallszahlen")),
    numbers = [];

// array füllen
for (var i = 0; i <= r; i++) numbers[i] = Math.floor(Math.random() * n);

function bubbleSort(arr) {
  var swapped = true,
      tmp;
  do {
    swapped = false;
    for (var i = 0; i <= arr.length; i++)
      if (arr[i] > arr[i + 1]) {
        tmp = arr[i]; arr[i] = arr[i + 1]; arr[i + 1] = tmp;
        swapped = true;
      }
  }
  while (swapped);
}

// ausgabe
console.log(numbers);
bubbleSort(numbers);
console.log(numbers);                                       // lissalanda@gmx.at

                

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

import random
a = []
for i in range(30):     #Anzahl der Zahlen in der Liste
    a.append(random.randint(1,2000))
print (a)                 #Ausgabe der Initialen Liste mit Zufallstzahlen von 1 bis 2000
    
def bubble():
    for k in range( len(a)-1, 0, -1 ):
         for i in range(0,k):
             if a[i] > a[i+1]:
                 a[i], a[i+1] = a[i+1], a[i]
    print (a)           #Sortierte Liste mit Zufallszahlen

bubblesort()
                

Lösung von: Py Thon ()

package ch.programmieraufgaben.algorithmen;

import java.util.*;

/**
 * www.programmieraufgaben.ch: BubbleSort (ID izfh-mhzu)
 * @version 0.1 (Jun 8, 2016)
 * @author Philipp Gressly Freimann 
 *         (philipp.gressly@santis.ch)
 */
public class BubbleSort {

	public static void main(String[] args) {
		new BubbleSort().top();
	}

	final int[] DEFAULT_VALUES = {6, 5, 3, 1, 8, 7, 2, 4};

	Scanner sc = new Scanner(System.in);
	String inputString(String frage) {
		System.out.println(frage + ": ");
		String eingabe = null;
		while(null == eingabe) {
			eingabe = sc.nextLine();
		}
		return eingabe;
	}


	int inputInt(String frage) {
		String eingabe;
		while(true) {
			eingabe = inputString(frage);
			try {
				int zahl = Integer.parseInt(eingabe);
				return zahl;
			} catch (NumberFormatException nfx) {
				System.out.println("Fehler in der Zahleneigabe: " + eingabe);
			}
		}
	}


	boolean inputBoolean(String frage) {
		String eingabe = inputString(frage);
		return !eingabe.toUpperCase().startsWith("N");
	}


	void top() {
		int[] values = werteInitialisieren();
		bubble(values);
		ausgabe(values);
	}


	void bubble(int[] values) {
		if(values.length < 2) {
			return;
		}
		int startPaar = 0;
		int endPaar   = values.length - 2;
		boolean bubbleLeftToRight = true;
		while(endPaar != startPaar) {
			debug("start while()", startPaar, endPaar, bubbleLeftToRight, values);
			bubble(values, startPaar, endPaar, bubbleLeftToRight);
			int tmpStart = startPaar;
			if(bubbleLeftToRight) {
				startPaar = endPaar - 1;
				endPaar   = tmpStart;
			} else {
				startPaar = endPaar  + 1;
				endPaar   = tmpStart    ;
			}
			bubbleLeftToRight = !bubbleLeftToRight;
			debug("end while()", startPaar, endPaar, bubbleLeftToRight, values);
		}
		debug("nach while", startPaar, endPaar, bubbleLeftToRight, values);
		// nur noch ein vergleich nötig? TODO: ev unnötig
		bubble(values, startPaar, endPaar, true);
	}


	void bubble(int[] values, int start, int end, boolean ltr) {
		int aktPaar = start;
		while(aktPaar != end) {
			bubble(values, aktPaar);	
			if(ltr) {
				aktPaar = aktPaar + 1;
			} else {
				aktPaar = aktPaar - 1;
			}
		}
		bubble(values, aktPaar);
	}


	/**
	 * Bubble ein einziges paar aufeinanderfolgender Werte:
	 * @param paar   == Position des linken  Wertes =>
	 *        paar+1 == Position des rechten Wertes
	 */
	void bubble(int [] values, int paar) {
		if(values[paar] > values[paar + 1]) {
			tausche(values, paar);
		}
	}


	void tausche(int[] values, int paar) {
		int tmp          = values[paar    ];
		values[paar    ] = values[paar + 1];
		values[paar + 1] = tmp;
	}
	
	
	int[] werteInitialisieren() {
		int[] values = DEFAULT_VALUES;
		if(inputBoolean("Wollen Sie eigene Werte verwenden? (j/n)")) {
			values = eigeneWerteLesen();
		}
		return values;
	}


	int[] eigeneWerteLesen() {
		List<Integer> zahlen = new ArrayList<Integer>();
		while(true){
			String eingbae = inputString("Zahl (ENDE für Abbruch)");
			if("ENDE".equalsIgnoreCase(eingbae)) {
				int[] arrInt =  alsIntArray(zahlen);
				return arrInt;
			} else {
				zahlen.add(Integer.parseInt(eingbae));
			}
		}
	}


	int[] alsIntArray(List<Integer> lst) {
		int [] intArr = new int[lst.size()];
		int pos = 0;
		for(int value : lst) {
			intArr[pos] = value;
			pos = pos + 1;
		}
		return intArr;
	}


	void ausgabe(int[] values) {
		for(int zahl: values) {
			System.out.print(zahl);
			System.out.print(" ");
		}
		System.out.println();
	}


	final boolean DEBUG = false;
	private void debug(String string, int startPaar, int endPaar, boolean ltr, int[] values) {
		if(!DEBUG) return;
		System.out.println("DEBUG (" + string  + ") ");
		System.out.println("      Werte         "
				+ ": " + Arrays.toString(values));
		System.out.println(ltr ? "      (left to right)" : "      (right to left)");
		System.out.println("      startPaar     : " + startPaar);
		System.out.println("      endPaar       : " + endPaar  );
	}


} // end of class BubbleSort
                

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

/* bubblesort.c */

#include <stdio.h>
#include <stdlib.h>

int sortiere(anz,bereich){                /* Funktion erstellt array mit Zufallszahlen und sortiert diese */
int zufall, temp, i, j;
int *array= malloc(anz* sizeof(int));
j= anz;

printf ("\n\nZufallszahlen:\n");          /* Zufallszahlen werden generiert und in array gespeichert */
for (i= 0;i< anz ;i++){
  zufall= rand()%bereich;
  array[i]= zufall;
  printf ("\t\t%d\n", array[i]);
}

while (j--)                               /* Bubblesort schlaufe */
for (i= 1;i<= j;i++){
  if (array[i-1]> array[i]){
    temp= array[i];
    array[i]= array[i-1];
    array[i-1]= temp;
  }
}
printf("\nSortiert:\n");                    /* Ausgabe nach bubblesort */
for (i= 0;i< anz;i++)
  printf("\t%d\n", array[i]);

free(array);
return EXIT_SUCCESS;
}
                

Lösung von: Name nicht veröffentlicht

package eins;
import Prog1Tools.IOTools;
import java.util.Random;
public class Bubblesort {
    public static void main(String[] args){
        int n = IOTools.readInt("Wieviele Zufallszahlen?: ");
        int r = IOTools.readInt("Maximalwert: ");
        
        Random ra = new Random();
        int[] array = new int[n]; 
        
        for(int i=0; i<n; i++){
            array[i] = ra.nextInt(r);
        }
        
        boolean fertig = false;
        
        System.out.println("Anfang: ");
        for(int i=0; i<n; i++){
            System.out.print(array[i]+" ");
        }
        
        while(!fertig){
            for(int i=0; i<n;){
                for(int j=1; j<n; j++, i++){
                    if(array[i]>array[j]){
                        int hilfe = array[i];
                        array[i] = array[j];
                        array[j] = hilfe;
                    }
                                    
                }
                for(int k=0, ziel=0; k<n; k++){
                    for(int l=1; l<n; l++, k++){
                        if(array[k]<=array[l]){
                            ziel++;
                        }
  
                        
                    }
                if(ziel==(n-1)){
                    fertig=true;
                }
                break;
                }
            break;    
            }
        }
        System.out.println();
        System.out.println("Ende: ");
        for(int i=0; i<n; i++){
            System.out.print(array[i]+" ");
        }
    }  
}
                

Lösung von: Name nicht veröffentlicht

import java.util.Scanner;

public class bubble {
		
	
	public static void main(String[] args) {
		
		int n,r;
		Scanner sc = new Scanner(System.in);
		
		System.out.println("Bitte geben sie eine Anzahl an.");
		n= sc.nextInt(); //Anzahl
		
		System.out.println("Bitte geben sie einen Maximalwert ein");
		r= sc.nextInt(); //Maximalwert
		
		//array mit zahlen wird auf grösse n gesetzt
		int[] unsort;
		unsort = new int[n];
		
		//schleife füllt array mit randomzahlen
		for(int x = 0; x<n;x++){
			unsort[x]=(int) (Math.random()*r);
		}
		
		//ruft methode bubblesort auf, übergibt array und anzahl
		int[] sort=bubblesort(unsort,n);
		
		//ausgabe des endarrays
		for (int i = 0; i<n; i++) {
			System.out.print(sort[i] + "| ");
		}
	
	}
	
		//bubblesort übernimmt unsortierten array und anz elemente
		public static int[] bubblesort(int[] zusort, int n) {
			int auslagern;
			
			//solange bis i alle ememente von links nach rechts sortiert sind
			for(int i=1; i<n; i++) {
				
				//solange bis die vorherige stelle kleiner ist
				for(int l=0; l<n-i; l++) {
					
					//stellen werden verglichen ist links grösser als rechts
					if(zusort[l]>zusort[l+1]) {
						
						//wenn ja
						//temprär var lagert wert von grösserem
						auslagern=zusort[l];
						
						//kleinere zahl wird in andere stelle geschrieben
						zusort[l]=zusort[l+1];
						
						//temporär var tauscht wert mit voherig grösserem aus
						zusort[l+1]=auslagern;
					}
					
				}
			}//rückgabewert
			return zusort;
			
		}
}
                

Lösung von: Yannick .. (It-Handbook.net)

public class Main {
	
	private static Scanner sc;

	public static void main(String[] args) {
		int anzahl = getAnzahl();
		int max = getMax();
		int[] rand = new int[anzahl];

		for (int i = 0; i < anzahl; i++) {
			rand[i] = (int) Math.round(Math.random() * max);
		}

		int[] sorted = bubbleSort(rand, anzahl);
		
		String result = "";
		for (int x = 0; x < sorted.length; x++) {
			if(x == sorted.length - 1) {
				result += sorted[x];
			} else {
				result += sorted[x] + ", ";
			}
		}
		
		System.out.println("");
		System.out.println("");
		System.out.println("Ergebnis: " + result);
		
	}

	public static int getAnzahl() {
		System.out.print("Anzahl der generierten Zufallszahlen: ");
		sc = new Scanner(System.in);
		int num = sc.nextInt();
		return num;
	}

	public static int getMax() {
		System.out.print("Maximalwert der generierten Zufallszahlen: ");
		sc = new Scanner(System.in);
		int num = sc.nextInt();
		sc.close();
		return num;
	}
	
	public static int[] bubbleSort(int[] array, int length) {
		while (true) {
			int[] temp = array;
			int count = 0;

			for (int i = 0; i < length - 1; i++) {
				if (temp[i] > temp[i + 1]) {
					int save = temp[i];

					temp[i] = temp[i + 1];
					temp[i + 1] = save;
				} else {
					count++;
				}
			}

			if (count >= length - 1) {
				return temp;
			}
		}
	}
}
                

Lösung von: Name nicht veröffentlicht

// Programmiersprache Go
package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {
	n := 10  // Anzahl der generierten Zufallszahlen
	r := 100 // Obergrenze der zu erzeugenden Zufallszahlen
	zufallsliste := randomnumber(n, r)
	fmt.Println("Zufallsliste:", zufallsliste)
	fmt.Println("Sortierte Liste:", bubblesort(zufallsliste))
}

// erstellt eine Liste mit Zufallszahlen (int)
func randomnumber(n, r int) []int {
	zliste := []int{}                                // initialisieren der Zufallszahlenliste
	rsource := rand.NewSource(time.Now().UnixNano()) // neue Zufallsquelle
	random := rand.New(rsource)                      // initialisieren des Zufallgenerators
	for i := 1; i <= n; i++ {                        // Erstellen der Zufallszahlenliste
		zliste = append(zliste, random.Intn(r))
	}
	return zliste
}

// sortiert eine Liste mit Zahlen (int) nach dem Bubblesortprinzip
func bubblesort(zliste []int) []int {
	for n := len(zliste); n > 1; n-- {
		for i := 0; i < n-1; i++ {
			if zliste[i] > zliste[i+1] {
				zliste[i], zliste[i+1] = zliste[i+1], zliste[i]
				fmt.Println(zliste) // optionale Ausgabe der einzelnen Sortierschritte
			}
		}
	}
	return zliste
}

                

Lösung von: Name nicht veröffentlicht

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace BubbleSort
{
    class BubbleSort
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Gib die Anzahl der Zaheln ein!");
            int num = Convert.ToInt32(Console.ReadLine());
            Console.WriteLine("Gib die Maximalgrösse der Zahlen ein!");
            int maxHeight = Convert.ToInt32(Console.ReadLine());
            int[] zahlen = new int[num];

            Random rnd = new Random();
            for(int i = 0; i < zahlen.Length; i++)
            {
                zahlen[i] = rnd.Next(1, maxHeight + 1);
            }

            while(true)
            {
                int count = 0;

                for (int i = 0; i < zahlen.Length - 1; i++)
                {
                    if (zahlen[i] > zahlen[i + 1])
                    {
                        int temp = zahlen[i];
                        zahlen[i] = zahlen[i + 1];
                        zahlen[i + 1] = temp;
                    } else
                    {
                        count++;
                    }
                }

                if(count >= zahlen.Length - 1)
                {
                    break;
                }
            }

            string newString = "";
            foreach(int el in zahlen) {
                newString += el + " ";
            }

            Console.WriteLine(newString);
            Console.ReadLine();
        }
    }
}
                

Lösung von: Elias Zech (Optics Balzers)

'5.3.2017 - PowerBASIC 10

#COMPILE EXE
#DIM ALL

FUNCTION PBMAIN () AS LONG

    DIM r AS LONG 'Zufallszahl - Maximalwert
    DIM n AS INTEGER 'Anzahl der zu generierenden Zahlen
    DIM i AS INTEGER
    DIM x AS INTEGER
    DIM zwVal AS LONG
    DIM inpArray AS STRING
    DIM outArray AS STRING

    n = VAL(INPUTBOX$("Wieviele Zahlen sollen sortiert werden?" & $CRLF & "Nur ganze Zahlen!","Anzahl","10"))
    r = VAL(INPUTBOX$("Welcher Maximalwert?" & $CRLF & "Nur ganze Zahlen!", "Bereich 0 bis xx", "100"))

    IF r * n = 0 THEN
        MSGBOX "Keine gültige Zahl eingegeben"
        EXIT FUNCTION
    END IF

    DIM MyArray(1 TO n) AS LONG

    RANDOMIZE TIMER
    FOR i = 1 TO n
        MyArray(i) = RND(1,r)
        inpArray += FORMAT$(MyArray(i)) & CHR$(32)
    NEXT i

    ''Sortieren mit Bubblesort
    FOR i = 1 TO UBOUND(MyArray)-1
       FOR x = i TO UBOUND(MyArray)
          IF MyArray(i) > MyArray(x) THEN
              zwVal = MyArray(i)
              MyArray(i) = MyArray(x)
              MyArray(x) = zwVal
          END IF
       NEXT x
    NEXT i

    FOR i = 1 TO n
        outArray += FORMAT$(MyArray(i)) & CHR$(32)
    NEXT i

    MSGBOX inpArray,,EXE.NAME$ & " - Unsortiert"
    MSGBOX outArray,,EXE.NAME$ & " - Sortiert"

END FUNCTION
                

Lösung von: Markus Sägesser (keine)

from random import randint

n = int(input("Geben Sie ein n (Anzahl Zufallszahlen) ein: "))
r = int(input("Geben Sie ein r (Maximalwert) ein: "))
liste = []

for i in range(n):
    liste.append(randint(0, r))

print("Liste:\n", liste)

def bubblesort(liste):
    for j in range(len(liste), 1, -1):
        for i in range(0, j-1):
            if liste[i] > liste[i+1]:
                    temp = liste[i+1]
                    liste[i+1] = liste[i]
                    liste[i] = temp
    return liste

print("Liste sortiert:\n", bubblesort(liste))
                

Lösung von: Peter Pan (Home Office)

// NET 6.x | C# 10.x | VS-2022
List<int> RandomNumbers(int num, int max) => Enumerable.Range(0, num + 1).Select(i => new Random().Next(0, max)).ToList();

List<int> SortedList(List<int> lst) {
    var max = lst.Count;
    while(max-- > 0)
        for (int i = 1; i <= max; i++)
            if (lst[i - 1] > lst[i])
                (lst[i - 1], lst[i]) = (lst[i], lst[i - 1]);
    return lst;
}
var rnd = RandomNumbers(20, 100);
Console.WriteLine(string.Join(", ", rnd));
var lst = SortedList(rnd);
Console.WriteLine(string.Join(", ", lst));
                

Lösung von: Jens Kelm (@JKooP)

// C++ 14 | VS-2022
#include <iostream>
#include <vector>

std::vector<int> get_random_numbers(int num, int max) {
	std::vector<int> v;
	for (size_t i{ 0 }; i < num; i++)
		v.push_back(rand() * i % max + 1);
	return v;
}

void bubblesort_numbers(std::vector<int>& v) {
	auto max{ v.size() };
	const auto swap{ [&v](size_t i) {const auto t{ v[i] }; v[i] = v[i - 1]; v[i - 1] = t; } };
	while(max--)
		for (size_t i{ 1 }; i <= max; i++)
			if (v[i - 1] > v[i]) swap(i);
}

void print_random_numbers(const std::vector<int>& v) {
	for (size_t i{ 0 }; i < v.size() - 1; i++)
		std::cout << v[i] << ", ";
	std::cout << v.back() << "\n";
}

int main() {
	srand((int)time(nullptr));
	auto rnd{ get_random_numbers(20, 100) };
	print_random_numbers(rnd);
	bubblesort_numbers(rnd);
	print_random_numbers(rnd);
}
                

Lösung von: Jens Kelm (@JKooP)