Zuviel Werbung? - > Hier kostenlos beim SPS-Forum registrieren

Ergebnis 1 bis 4 von 4

Thema: Quick Sort Verfahren

  1. #1
    Registriert seit
    21.01.2012
    Beiträge
    2
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Hallo,

    habe folgendes Problem. Ich soll folgende FB anstatt Bubble Sort Verfahren mit Quick Sort Verfahren sortieren lassen. Kennt sich damit jemand aus?! Danke!



    FUNCTION_BLOCK AUSWERTEN
    CONST
    GRENZE := 7;
    END_CONST

    VAR_IN_OUT
    sortierpuffer : ARRAY[0..GRENZE] OF INT;
    END_VAR

    VAR_OUTPUT
    rechenpuffer : ARRAY[0..GRENZE] OF
    STRUCT
    wurzel : INT;
    quadrat : INT;
    END_STRUCT;
    END_VAR

    VAR_TEMP
    tauschen : BOOL;
    index, hilf : INT;
    wertr, ergebnr: REAL;
    END_VAR

    BEGIN
    (********************************************************
    Teil 1 Sortierung : nach dem "Bubble Sort" Verfahren: Werte
    solange paarweise tauschen, bis Messwertpuffer sortiert ist.
    **********************************************************)
    REPEAT
    tauschen := FALSE;
    FOR index := GRENZE TO 1 BY -1 DO
    IF sortierpuffer[index-1] > sortierpuffer[index]
    THEN hilf := sortierpuffer[index];
    sortierpuffer[index] := sortierpuffer[index-1];
    sortierpuffer[index-1] := hilf;
    tauschen := TRUE;
    END_IF;
    END_FOR;
    UNTIL NOT tauschen
    END_REPEAT;
    (**********************************************************
    Teil 2 Berechnung : Wurzelberechnung mit Standardfunktion
    SQRT und Quadrierung mit Funktion QUADRAT durchführen.
    ************************************************************)
    FOR index := 0 TO GRENZE BY 1 DO
    rechenpuffer[index].wurzel := WURZEL(sortierpuffer[index]);
    rechenpuffer[index].quadrat := QUADRAT(sortierpuffer[index]);
    QUADRAT(sortierpuffer[index]);
    END_FOR;
    END_FUNCTION_BLOCK
    Zitieren Zitieren Quick Sort Verfahren  

  2. #2
    Registriert seit
    29.01.2007
    Ort
    Sandkrug
    Beiträge
    147
    Danke
    7
    Erhielt 36 Danke für 25 Beiträge

    Standard

    Vorgehensweise bei Quicksort:
    - von einer gegebenen Elementefolge wird das erste als Trennelement genommen. Alle anderen Elemente werden davor (wenn sie kleiner oder gleich sind) oder dahinter (wenn sie größer sind) angeordnet. Das Trennelement steht danach an der richtigen Stelle.
    - mit den beiden so entstandenen Teilfolgen, welche durch das Trennelement getrennt sind, wird ebenso verfahren.
    - eine Teilfolge aus nur einem Element ist natürlich sofort fertig sortiert.
    - eine Teilfolge aus nur zwei Elementen benötigt zum Sortieren nur noch einen Vergleich.
    Es handelt sich um ein rekursives Sortierverfahren, braucht also Speicherplatz.
    Weitere Informationen findest du auch bei Wikipedia.
    (oder wolltest du hier deine Aufgabe fertig gelöst bekommen )
    MfG
    eNDe

  3. #3
    Registriert seit
    21.01.2012
    Beiträge
    2
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard

    kann mir darunter immer noch nichts vorstellen... wie in etwa würde dann der syntax aussehen?

  4. #4
    Registriert seit
    19.06.2005
    Ort
    in Bayern ganz oben
    Beiträge
    1.360
    Danke
    188
    Erhielt 372 Danke für 290 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Hi,

    z.B.
    Code:
    FUNCTION_BLOCK _ARRAY_SORT
    TITLE = '_ARRAY_SORT'
    //
    //this function will sort a given array.
    //the function needs to be called:  _array_sort(adr("array"),sizeof("array"));
    //this function will manipulate a given array.
    //the function will not return anything except true, it will instead manipulate the original array.
    //because this function works with pointers its very time efficient and it needs no extra memory.
    //
    VERSION : '2.0'
    AUTHOR  : Alex
    NAME    : AR_SORT
    FAMILY  : ARFUNCT
    
    VAR_INPUT
      PT : POINTER;       (* POINTER TO REAL *)
        _PT AT PT: STRUCT
          DBNr: WORD;
          Adr: DWORD;
        END_STRUCT;    
      SIZE : INT;
    END_VAR
    VAR_OUTPUT
      SORT: BOOL;
    END_VAR
    VAR
      stack: ARRAY[1..32] OF INT;  (* Stackgröße~ 1,6*Log(n)/log(2) *)
                        (* Stackgröße 32 => ~1 Mio Elemente *)
    END_VAR  
    VAR_TEMP
      stack_count: INT;        (* Laufvariable Stack*)
      links: INT;            (* Anfangselement des Arrays *)
      rechts: INT;           (* Endelement des Arrays *)
      pivot: REAL;            (* temporärer Schwellwert für Tauschbedingung *)
      i: INT;              (* Laufvariable1 *)
      j: INT;              (* Laufvariable2 *)
      ende_innen: BOOL;       (* Ende innere Schleife *)
      ende_aussen: BOOL;        (* Ende äußere Schleife *)
      tmp: REAL;            (* Hilfsvariable zum Tauschen von Werten *)
      Adr: INT;
      DB_LENGTH: WORD;
      WRITE_PROT: BOOL;
      rTEST_DB: INT;
    END_VAR
    
    BEGIN
    
    SORT := FALSE;
     
    (* Datenbaustein Testen *)
    rTEST_DB := TEST_DB(DB_NUMBER := _pt.DBNr // IN: WORD
                       ,DB_LENGTH := DB_LENGTH // OUT: WORD
                       ,WRITE_PROT := WRITE_PROT // OUT: BOOL
                       ); // INT
    (* Ende wenn Test-DB <> 0 = Fehler *)
    IF rTEST_DB <> 0 THEN RETURN; END_IF;
    (* Ende wenn DB zu klein *) 
    IF WORD_TO_INT(DB_LENGTH)/4 < size THEN RETURN; END_IF;
    
    Adr := DWORD_TO_INT(SHR(IN:=SHL(IN:=_pt.Adr,N:=8),N:=11))-4;
    
    (* Startwerte zur Arraygröße *)
    links := 1;         (* Anfangselement des Arrays *)
    rechts := WORD_TO_INT(SHR(IN:=INT_TO_WORD(size),N:=2));    (* Endelement des Arrays *)
    stack_count := 1;     (* Laufvariable Stack *)
    
    WHILE NOT ende_aussen DO            (* äußere Schleife *)
      IF links < rechts THEN
        pivot := DWORD_TO_REAL(WORD_TO_BLOCK_DB(_pt.DBNr).DD[(Adr+WORD_TO_INT(SHR(IN:=INT_TO_WORD(rechts+links),N:=1)))*4]);      (* Wert des mittleren Elements als Pivot-Wert *)
        i := links -1;
        j := rechts +1;
    
        (* innere Schleife, teile Feld *)
        ende_innen := FALSE;
        REPEAT
    
          (* steigende Reihenfolge *)
          REPEAT  i := i+1; UNTIL (DWORD_TO_REAL(WORD_TO_BLOCK_DB(_pt.DBNr).DD[(Adr+i)*4]) >= pivot) OR NOT (i < rechts) END_REPEAT;
          REPEAT  j := j-1; UNTIL (DWORD_TO_REAL(WORD_TO_BLOCK_DB(_pt.DBNr).DD[(Adr+j)*4]) <= pivot) OR NOT (j > links)  END_REPEAT;
    
    
          (*sinkende Reihenfolge *)
    (*      REPEAT  i := i+1; UNTIL (PT^[i] <= pivot) OR NOT (i < rechts) END_REPEAT  *)
    (*      REPEAT  j := j-1; UNTIL (PT^[j] >= pivot) OR NOT (j > links)  END_REPEAT  *)
    
          IF i >= j THEN
            ende_innen := TRUE;
          ELSE
               tmp := DWORD_TO_REAL(WORD_TO_BLOCK_DB(_pt.DBNr).DD[(Adr+j)*4]);
            WORD_TO_BLOCK_DB(_pt.DBNr).DD[(Adr+j)*4] := WORD_TO_BLOCK_DB(_pt.DBNr).DD[(Adr+i)*4];
            WORD_TO_BLOCK_DB(_pt.DBNr).DD[(Adr+i)*4] := REAL_TO_DWORD(tmp);
          END_IF;
    
        UNTIL ende_innen END_REPEAT;
    
        (* Push stack *)
        stack[stack_count] := rechts;   (* rechten Teil später sortieren *)
        IF Stack_count < 32 THEN
          stack_count := stack_count +1;
        ELSE
          ende_aussen := TRUE;
          SORT := FALSE;         (* Fehler: Stack zu klein *)
        END_IF;
    
        (* linken Teil sortiern *)
        rechts := MAX(IN1:=links,IN2:=i-1);
    
      ELSE
    
        IF stack_count = 1 THEN
          ende_aussen := TRUE;
        ELSE
    
          links := rechts+1;
    
          (* pop stack *)
          stack_count := stack_count -1;    (* jetzt rechten Teil sortierne *)
          rechts:= stack[stack_count];
        END_IF;
    
      END_IF;
    
    END_WHILE;
    
    SORT := TRUE;        (* Sortierung beendet *)
    
    END_FUNCTION_BLOCK
    Beispiel _ARRAY_SORT aus der OSCAT_S7_basic_332 Lib. Download unter http://www.oscat.de/

    Gruss Daniel
    Erfahrung ist eine nützliche Sache. Leider macht man sie immer erst kurz nachdem man sie brauchte...

    OSCAT.lib Step 7

    Open Source Community for Automation Technolgy

    SPS-Forum Chat (Mibbit) | SPS-Forum Chat (MIRC)

Ähnliche Themen

  1. Quick Stop
    Von diego im Forum CODESYS und IEC61131
    Antworten: 20
    Letzter Beitrag: 27.11.2010, 10:01
  2. Antworten: 4
    Letzter Beitrag: 15.12.2009, 16:19
  3. Zylinder verfahren lassen
    Von Vauxhall1983 im Forum Simatic
    Antworten: 16
    Letzter Beitrag: 02.09.2009, 15:44
  4. DB Bubble Sort
    Von TheBigMemph im Forum Simatic
    Antworten: 1
    Letzter Beitrag: 20.03.2007, 09:54
  5. Achse im Handbetrieb verfahren
    Von Drain im Forum Programmierstrategien
    Antworten: 6
    Letzter Beitrag: 29.08.2006, 12:28

Lesezeichen

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •