T[idx]<->T[idx+1]

Slides:

Advertisements

Podobne prezentacje

Przemocy w szkole mówię: NIE !

Advertisements

Ładowanie gry 35% Proszę czekać….

Dziel – Rządź - Złącz.

START WYPROWADŹ WYNIK 8 STOP

1 1 Przykład 1/3 main() { int i,j,k,m; /* i-m : $s0-$s3 */... i = mult(j,k);... m = mult(i,i);... } int mult (int mcand, int mlier){ int product; product.

OBOWIĄZKI SAMORZĄDÓW wynikające z nowelizacji ustawy o utrzymaniu porządku i czystości w gminach Rydułtowy,

Sortowanie Zajęcia 13.

Funkcje Modularyzacja : program główny , funkcje Funkcje :

Sortowanie przez scalanie Merge Sort

Lena Modzelewska Manager d/s Programu Stypendialnego DBU , Warszawa.

OBLICZENIE PODATKU ZA ROK 2002

Podstawy inżynierii oprogramowania Zofia Kruczkiewicz

PIO 3_2, Zofia Kruczkiewicz1 Wykład 3 – część druga Iteracyjno-rozwojowy cykl oprogramowania 3.

Powtórzenie PPT 2011.

INFORMACJE O DOROBKU NAUKOWYM KIEROWNIKA,

TEST INTELIGENCJI Sprawdzisz tu poziom swojej wiedzy. Myślisz że jesteś inteligentny? My ci udowodnimy, że się mylisz  START.

Program eTwinning COOKBOOK

Piramida Zdrowego Żywienia

Kurs języka C++ – wykład 13 ( )

Gra Przejdź po linii Start.

Visual Basic Scritpts.

Publiczna Szkoła Podstawowa nr 5 w Brzegu

Instrukcje iteracyjne

Gra na lekcje 3301

ZDROWE JEDZONKO ZAPRASZAMY. Piramida zdrowia Owoce.

28 listopada 2014 w Szkole Podstawowej nr 83 im. Stanisława Jachowicza w Łodzi odbył się XVI Ogólnołódzki Konkurs Recytatorski „I muzyka wokół nas rozkwita,

Jak najpełniej przeżyć życie?

Ułóż planety w kolejności, według ich odległości od słońca

Materiały Włókiennicze

Darmowe porady prawne on-line Specprawnik w liczbach: o Ponad 35 tyś. odwiedzin miesięcznie o 1669 potwierdzonych i aktywnych prawników z całego kraju.

Laureaci konkursu pt,,Wspó ł czesna rodzina a zagro ż enia cywilizacyjne’’ Szko ł a Zdrowia Psychicznego 2015 r. Szkoła Zdrowia Psychicznego –zadanie finansowane.

Temat: Schematy blokowe - ćwiczenia

Wyniki szkolnego konkursu plastycznego dla uczniów klas ii-iii „bezpieczna droga do szko Ł y ”

2015 Marcin Ogórek.  24 osoby w obu ligach (+2 względem względem 2013)  11 rund liga główna (-2, 0)  5 rund liga senior (-2, -2)  7 miesięcy.

Skróty klawiszowe. Ctrl + A Zaznacz wszystko Ctrl + B Pogrubienie.

 Suche dane  Testy wiedzy  Tabelki formułki  Daty  Rankingi i olimpiady naukowe  Oceny Tak było, Tak jest ale czy tak ma być?

TYDZIEŃ DRUGI 7 – 11 marca. W tym tygodniu obchodziliśmy urodziny Oli! Zobaczcie sami…

Pawlicz, A. (2015). Wykorzystanie mediów społecznościowych jako narzędzia marketingu turystycznego przez gminy leżące na terenach Parków Narodowych w Polsce.

„W krainie twórczego zamyślenia” Scenariusz multimedialny nr 9/III.

 W szczególności lubię biegać, pływać i chodzić na siłownię.

MŁODZIEŻOWE MINIPRZEDSIĘBIORSTWO CREATIVE TRAVEL UL. I ARMII WOJSKA POLSKIEGO 89; WYSZKÓW NUMER EWIDENCYJNY CREATIVE TRAVEL WYSZKÓW.

Python. Języki Programistyczne Microcode Machine code Assembly Language (symboliczna reprezentacja machine code) Low-level Programming Language (FORTRAN,

„Z twórczością na TY” Scenariusz multimedialny nr 4/II.

JEZIORA I RZEKI ROSJI Autor: Szymon Młynek.

ZAKŁAD STOSOWANIA I FORMULACJI PESTYCYDÓW Karolina Świech.

Important holidays and festivals in Poland. The first of January New Year’s Day New Year’s Day the day of Mary the Holy Mother of God – for Catholics.

Grzegorz Cygan Wstęp do programowania mikrosterowników w języku C

ZAKUPY W INTERNECIE Autorka: Lena Eisner.

Algorytm Dijkstry Podano graf Zdefiniowano jego listę sąsiedztwa 1 2 3

Wyniki konkursu fotograficznego „Cztery pory roku z rowerem w obiektywie” - etap I „Jesień z rowerem”: I miejsce - Filip Obrębski.

Witaj w quizie Wybierz dziedzinę.

Tor przeszkód GRAJ Tor przeszkód Tor przeszkód GRAJ GRAJ Graj

ALGORYTMY I STRUKTURY DANYCH

RAJD ROWEROWY „ROWEREM PO FORMĘ” NIEDZIELA

Efektywność wykorzystania TI

Iteracyjno-rozwojowy cykl oprogramowania 3

„Oczarowani przyrodą”

LABIRYNT MINOTAURA GRAJ.

Labirynt START. Level 1 Level 2 Level 3 Level 4 Start END.

Labirynt START. Level 1 Level 2 Level 3 Level 4 Level 5.

PROGRAMOWANIE niestraszne zadanie

Etapy tworzenia prezentacji

PRZYWÓDZTWO W ORGANIZACJI

SCHEMAT BUDOWY OPINII PRAWNEJ

Członkowie przedsiębiorstwa:

KSIĄŻ CAI2*,CAN C plan Street Og 1,5,9,12,13,16,20, 3 3 km 5 km 5 4 km

LISTA APARTAMENTÓW START Aktualizacja:

58.W odległości 100m od siebie znajdują się dwa ciała poruszające się naprzeciw siebie: pierwsze ze stałą prędkością 4m/s, a drugie z prędkością początkową.

Zapis prezentacji:

T[idx]<->T[idx+1] Bubble sort START Stan początkowy Len=9 T: 2 3 5 1 8 9 6 7 4 idx=1 T[idx]<->T[idx+1] T[idx]>T[idx+1] T F Idx++ Len-- Idx>=Len Len<=1 F STOP T F T

T[idx]<->T[idx+1] Bubble sort START START Len=9 T: 2 3 5 1 8 9 6 7 4 idx=1 T[idx]<->T[idx+1] T[idx]>T[idx+1] T F Idx++ Len-- Idx>=Len Len<=1 F STOP F T T

T[idx]<->T[idx+1] Bubble sort START Przygotowanie do pracy – zakładamy, że cała tablica jest nieposortowana Len=9 T: 2 3 5 1 8 9 6 7 4 idx=1 T[idx]<->T[idx+1] T[idx]>T[idx+1] T F Len=9 Idx++ Len-- Idx>=Len F T Len<=1 F STOP T

T[idx]<->T[idx+1] Bubble sort START Zaczynając od pierwszego elementu: Len=9 T: 2 3 5 1 8 9 6 7 4 idx=1 idx=1 T[idx]<->T[idx+1] T[idx]>T[idx+1] T F Len=9 Idx++ Len-- Idx>=Len Len<=1 F STOP F T T

T[idx]<->T[idx+1] Bubble sort Porównujemy w parach. Teza warunku: „Wyższy element większy od niższego” START Len=9 T: 2 3 5 1 8 9 6 7 4 idx=1 idx=1 T[idx]<->T[idx+1] T[idx]>T[idx+1] T F Len=9 Idx++ Len-- Idx>=Len Len<=1 F STOP F T T

T[idx]<->T[idx+1] Bubble sort START Fałsz – para jest wstępnie uporządkowana Len=9 T: 2 3 5 1 8 9 6 7 4 idx=1 idx=1 T[idx]<->T[idx+1] T[idx]>T[idx+1] T F Len=9 Idx++ Len-- Idx>=Len Len<=1 F STOP F T T

T[idx]<->T[idx+1] Bubble sort START Fałsz- omija procedurę wymiany Len=9 T: 2 3 5 1 8 9 6 7 4 idx=1 idx=1 T[idx]<->T[idx+1] T[idx]>T[idx+1] T F Len=9 Idx++ Len-- Idx>=Len Len<=1 F STOP F T T

T[idx]<->T[idx+1] Bubble sort START Przejdź do następnych elementów Len=9 T: 2 3 5 1 8 9 6 7 4 idx=2 idx=1 T[idx]<->T[idx+1] T[idx]>T[idx+1] T F Len=9 Idx++ Len-- Idx>=Len Iidx =2 Len<=1 F STOP F T T

T[idx]<->T[idx+1] Bubble sort START Teza:”Osiągnął koniec” Len=9 T: 2 3 5 1 8 9 6 7 4 idx=2 idx=1 T[idx]<->T[idx+1] T[idx]>T[idx+1] T F Len=9 Idx++ Len-- Idx>=Len Len<=1 F STOP F T T idx=2 Len=9

T[idx]<->T[idx+1] Bubble sort Fałsz-to jeszcze nie koniec nieposortowanej części – pętla działa dalej START Len=9 T: 2 3 5 1 8 9 6 7 4 idx=2 idx=1 T[idx]<->T[idx+1] T[idx]>T[idx+1] T F Len=9 Idx++ Len-- Idx>=Len Len<=1 F STOP F T T idx=2 Len=9

T[idx]<->T[idx+1] Bubble sort START Teza:”Wyższy element większy od niższego” Len=9 T: 2 3 5 1 8 9 6 7 4 idx=2 idx=1 T[idx]<->T[idx+1] T[idx]>T[idx+1] T F Len=9 Idx++ Len-- Idx>=Len Len<=1 F STOP F T T idx=2 Len=9

T[idx]<->T[idx+1] Bubble sort START Fałsz – elementy są w dobrym porządku- sterowanie przechodzi dalej Len=9 T: 2 3 5 1 8 9 6 7 4 idx=2 idx=1 T[idx]<->T[idx+1] T[idx]>T[idx+1] T F Len=9 Idx++ Len-- Idx>=Len Len<=1 F STOP F T T

T[idx]<->T[idx+1] Bubble sort START Przejdź do następnych elementów T: 2 3 5 1 8 9 6 7 4 Len=9 idx=1 idx=3 T[idx]<->T[idx+1] T[idx]>T[idx+1] T F Len=9 Idx++ Len-- Idx>=Len iIdx =3 Len<=1 F STOP F T T

T[idx]<->T[idx+1] Bubble sort START Teza:”Osiągnął koniec” Len=9 T: 2 3 5 1 8 9 6 7 4 idx=1 idx=3 T[idx]<->T[idx+1] T[idx]>T[idx+1] T F Len=9 Idx++ Len-- Idx>=Len Len<=1 F STOP F T T idx=3 Len=9

T[idx]<->T[idx+1] Bubble sort START Fałsz – pętla działa dalej Len=9 T: 2 3 5 1 8 9 6 7 4 idx=1 idx=3 T[idx]<->T[idx+1] T[idx]>T[idx+1] T F Len=9 Idx++ Len-- Idx>=Len Len<=1 F STOP F T T idx=3 Len=9

T[idx]<->T[idx+1] Bubble sort START Teza:”Wyższy element większy od niższego” Len=9 T: 2 3 5 1 8 9 6 7 4 idx=1 idx=3 T[idx]<->T[idx+1] T[idx]>T[idx+1] T F Len=9 Idx++ Len-- Idx>=Len Len<=1 F STOP F T T idx=3 Len=9

T[idx]<->T[idx+1] Bubble sort START Prawda – będzie przestawienie Len=9 T: 2 3 5 1 8 9 6 7 4 idx=1 idx=3 T[idx]<->T[idx+1] T[idx]>T[idx+1] T F Len=9 Idx++ Len-- Idx>=Len Len<=1 F STOP F T T idx=3 Len=9

T[idx]<->T[idx+1] Bubble sort START Przestawienie Len=9 T: 2 3 5 1 8 9 6 7 4 idx=1 idx=3 1 5 T[idx]<->T[idx+1] T[idx]>T[idx+1] T F Len=9 Idx++ Len-- Idx>=Len Len<=1 F STOP F T T idx=3 Len=9

T[idx]<->T[idx+1] Bubble sort START Kolejna para do analizy Len=9 T: 2 3 8 9 6 7 4 idx=1 1 5 idx=4 T[idx]<->T[idx+1] T[idx]>T[idx+1] T F Idx++ Len-- Len=9 Idx>=Len Len<=1 F STOP F T T idx=4 Len=9

T[idx]<->T[idx+1] Bubble sort START Jeszcze jest kilka elementów do przeglądnięcia Len=9 T: 2 3 8 9 6 7 4 idx=1 1 5 idx=4 T[idx]<->T[idx+1] T[idx]>T[idx+1] T F Idx++ Len-- Len=9 Idx>=Len Len<=1 F STOP F T T idx=4 Len=9

T[idx]<->T[idx+1] Bubble sort START Warunek jest fałszywy – jeszcze nie doszedł do końca części nieuporządkowanej. Pętla trwa dalej. Len=9 T: 2 3 8 9 6 7 4 idx=1 1 5 idx=4 T[idx]<->T[idx+1] T[idx]>T[idx+1] T F Idx++ Len-- Len=9 Idx>=Len Len<=1 F STOP F T T idx=4 Len=9

T[idx]<->T[idx+1] Bubble sort START Następuje kolejne sprawdzenie porządku w parze dwuelementowej. Para jest wstępnie uporzadkowana. Nie nastąpi przestawienie. Len=9 T: 2 3 8 9 6 7 4 idx=1 1 5 idx=4 T[idx]<->T[idx+1] T[idx]>T[idx+1] T F Idx++ Len-- Len=9 Idx>=Len Len<=1 F STOP F T T idx=4 Len=9

T[idx]<->T[idx+1] Bubble sort START Następna para. Len=9 T: 2 3 8 9 6 7 4 idx=1 1 5 T[idx]<->T[idx+1] idx=5 T[idx]>T[idx+1] T F Idx++ Len-- Len=9 Idx>=Len Len<=1 F STOP F T T idx=5 Len=9

T[idx]<->T[idx+1] Bubble sort START Teza: „Doszedł do końca” - jest fałszywa. Zabawa trwa dalej. Len=9 T: 2 3 8 9 6 7 4 idx=1 1 5 T[idx]<->T[idx+1] idx=5 T[idx]>T[idx+1] T F Idx++ Len-- Len=9 Idx>=Len Len<=1 F STOP F T T idx=5 Len=9

T[idx]<->T[idx+1] Bubble sort START Para jest uporządkowana – nie będzie przestawienia. Len=9 T: 2 3 8 9 6 7 4 idx=1 1 5 T[idx]<->T[idx+1] idx=5 T[idx]>T[idx+1] T F Idx++ Len-- Len=9 Idx>=Len Len<=1 F STOP F T T idx=5 Len=9

T[idx]<->T[idx+1] Bubble sort START Teraz opracowywana będzie para(T[6] i T[7]) Len=9 T: 2 3 8 9 6 7 4 idx=1 1 5 T[idx]<->T[idx+1] T[idx]>T[idx+1] idx=6 T F Idx++ Len-- Len=9 Idx>=Len Len<=1 F STOP F T T idx=6 Len=9

T[idx]<->T[idx+1] Bubble sort START Para znajduje się w części nieopracowanej – będzie analizowana. Len=9 T: 2 3 8 9 6 7 4 idx=1 1 5 T[idx]<->T[idx+1] T[idx]>T[idx+1] idx=6 T F Idx++ Len-- Len=9 Idx>=Len Len<=1 F STOP F T T idx=6 Len=9

T[idx]<->T[idx+1] Bubble sort START Większy element jest przed mniejszym – nastąpi przestawienie. Len=9 T: 2 3 8 9 6 7 4 idx=1 1 5 T[idx]<->T[idx+1] T[idx]>T[idx+1] idx=6 T F Idx++ Len-- Len=9 Idx>=Len Len<=1 F STOP T F T idx=6 Len=9

T[idx]<->T[idx+1] Bubble sort START Przestawienie. „Cięższy” element „spadł niżej”, a ”lżejszy” „poszedł w górę”. Len=9 T: 2 3 8 9 6 7 4 idx=1 1 5 T[idx]<->T[idx+1] T[idx]>T[idx+1] idx=6 6 9 T F Idx++ Len-- Len=9 Idx>=Len Len<=1 F STOP T F T idx=6 Len=9

T[idx]<->T[idx+1] Bubble sort START I kolejne dwa elementy – jeszcze w części nieposortowanej. Pętla wykona kolejny obrót. Len=9 T: 2 3 8 7 4 idx=1 1 5 T[idx]<->T[idx+1] T[idx]>T[idx+1] 6 9 T idx=7 F Idx++ Len-- Len=9 Idx>=Len Len<=1 F STOP T F T idx=7 Len=9

T[idx]<->T[idx+1] Bubble sort START Będzie przestawienie. Len=9 T: 2 3 8 7 4 idx=1 1 5 T[idx]<->T[idx+1] T[idx]>T[idx+1] 6 9 T idx=7 F Idx++ Len-- Len=9 Idx>=Len Len<=1 F STOP T F T idx=7 Len=9

T[idx]<->T[idx+1] Bubble sort START Przestawienie Len=9 T: 2 3 8 7 4 idx=1 1 5 T[idx]<->T[idx+1] T[idx]>T[idx+1] 6 9 T idx=7 7 9 F Idx++ Len-- Len=9 Idx>=Len Len<=1 F STOP T F T idx=7 Len=9

T[idx]<->T[idx+1] Bubble sort START Jeszcze jedna para będzie sprawdzana - nie osiągnięto końca obszaru sortowanego. Wykonany zostanie kolejny obrót petli. Len=9 T: 2 3 8 4 idx=1 1 5 T[idx]<->T[idx+1] T[idx]>T[idx+1] 6 7 9 T idx=8 F Idx++ Len-- Len=9 Idx>=Len Len<=1 F STOP T F T idx=8 Len=9

T[idx]<->T[idx+1] Bubble sort START Znów przestawienie: Bo T[idx] jest większe od T[idx+1] Len=9 T: 2 3 8 4 idx=1 1 5 T[idx]<->T[idx+1] T[idx]>T[idx+1] 6 7 9 T idx=8 F Idx++ Len-- Len=9 Idx>=Len Len<=1 F STOP T F T idx=8 Len=9

T[idx]<->T[idx+1] Bubble sort START Przestawienie. „9” dotarło na “dno”. Len=9 T: 2 3 8 4 idx=1 1 5 T[idx]<->T[idx+1] T[idx]>T[idx+1] 6 7 9 T idx=8 4 9 F Idx++ Len-- Len=8 Idx>=Len Len<=1 F STOP T F T idx=8 Len=9

T[idx]<->T[idx+1] Bubble sort START Obszar przestawiania dotarł do końca części sortowanej – pętla jest przerywana. Len=9 T: 2 3 8 9 idx=1 1 5 T[idx]<->T[idx+1] T[idx]>T[idx+1] 6 7 4 T F idx=9 Idx++ Len-- Len=9 Idx>=Len Len<=1 F STOP F T T idx=9 Len=9

T[idx]<->T[idx+1] Bubble sort START „9” jest już na właściwym miejscu. Część sortowana może być skrócona o jedną liczbę. Len=9 T: 2 3 1 5 8 6 7 4 9 idx=1 T[idx]<->T[idx+1] T[idx]>T[idx+1] T Len=8 F idx=9 Idx++ Len-- Idx>=Len Len<=1 F STOP F T T idx=9 Len=8

T[idx]<->T[idx+1] Bubble sort START To jeszcze nie koniec – jest co sortować. Len=9 T: 2 3 1 5 8 6 7 4 9 idx=1 T[idx]<->T[idx+1] T[idx]>T[idx+1] T Len=9 F idx=9 Idx++ Len-- Idx>=Len Len<=1 F STOP F T T idx=9 Len=8

T[idx]<->T[idx+1] Bubble sort START Dla całej nieposortowanej części cała praca zaczyna się od nowa.. Len=9 T: 2 3 1 5 8 6 7 4 9 idx=1 idx=1 T[idx]<->T[idx+1] T[idx]>T[idx+1] T Len=8 F Idx++ Len-- Idx>=Len Len<=1 F STOP F T T idx=1 Len=8

T[idx]<->T[idx+1] Bubble sort START Znowu, w zależności od ustawienia, kolejne liczby są przestawiane... i tak dla wszystkich par w części nieposortowanej. Len=9 T: 2 3 1 5 8 6 7 4 9 idx=1 idx=1 T[idx]<->T[idx+1] T[idx]>T[idx+1] T Len=8 F Idx++ Len-- Idx>=Len Len<=1 F STOP F T T idx=1 Len=8

T[idx]<->T[idx+1] Bubble sort START Ta część zostanie przedstawiona w skrócie. Zaznaczone zostaną tylko przestawienia. Przed cyklem: Przed cyklem: Len=9 Po cyklu: T: 2 3 1 5 8 6 7 4 9 T: 2 3 1 5 6 7 4 8 9 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=2 idx=2 idx=1 idx=2 idx=1 idx=2 idx=1 idx=1 idx=2 idx=2 idx=1 idx=1 idx=1 idx=3 idx=3 idx=1 idx=1 idx=3 idx=3 idx=1 idx=3 idx=3 idx=1 idx=1 idx=4 idx=1 idx=1 idx=1 idx=1 idx=4 idx=4 idx=4 idx=4 idx=1 idx=4 idx=1 T[idx]<->T[idx+1] idx=5 idx=1 idx=5 idx=1 idx=1 idx=5 idx=5 idx=1 idx=1 idx=1 idx=5 idx=5 T[idx]>T[idx+1] idx=1 idx=6 idx=6 idx=1 idx=1 idx=1 idx=6 idx=6 idx=6 idx=6 idx=1 idx=1 T idx=1 idx=1 idx=7 idx=1 idx=7 idx=1 idx=1 idx=7 idx=1 idx=1 idx=1 idx=7 idx=1 idx=1 idx=7 idx=1 idx=7 idx=1 idx=8 idx=8 idx=8 idx=8 Len=8 Len=8 Len=8 Len=8 idx=8 idx=8 Len=8 Len=8 F Idx++ Len-- Idx>=Len Len<=1 F STOP F T T idx=1 Len=8

T[idx]<->T[idx+1] Bubble sort START Po pełnym cyklu, “8” jest na właściwym miejscu. Część do sortowania jest znowu skracana. Przed cyklem: Przed cyklem: Len=9 T: 2 3 1 5 6 7 4 8 9 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=2 idx=2 idx=1 idx=2 idx=1 idx=1 idx=2 idx=1 idx=3 idx=1 idx=1 idx=3 idx=3 idx=1 idx=1 idx=3 idx=1 idx=4 idx=1 idx=4 idx=1 idx=4 idx=4 idx=1 T[idx]<->T[idx+1] idx=5 idx=1 idx=1 idx=5 idx=5 idx=5 idx=1 idx=1 T[idx]>T[idx+1] idx=1 idx=6 idx=1 idx=1 idx=1 idx=6 idx=6 idx=6 T idx=7 idx=1 idx=1 idx=1 idx=7 idx=1 idx=1 idx=1 idx=1 idx=7 idx=1 idx=7 idx=8 idx=8 idx=8 idx=8 Len=8 Len=8 Len=8 Len=8 F Idx++ Len-- Idx>=Len Len<=1 F STOP F T T idx=1 Len=8

T[idx]<->T[idx+1] Bubble sort START Na razie ma długość większą niż 1. Przed cyklem: Przed cyklem: Len=9 T: 2 3 1 5 6 7 4 8 9 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 T[idx]<->T[idx+1] T[idx]>T[idx+1] T Len=7 Len=8 Len=8 Len=8 F Idx++ Len-- Idx>=Len Len<=1 F STOP F T T idx=1 Len=8

T[idx]<->T[idx+1] Bubble sort START Zewnętrzna pętla jest powtarzana, aż długość części posortowanej zmaleje do 1 elementu. Po cyklu: Przed cyklem: Przed cyklem: Przed cyklem: Przed cyklem: Len=9 T: 2 3 1 5 6 7 4 8 9 T: 2 1 3 5 6 4 7 8 9 T: 1 2 3 5 4 6 7 8 9 T: 1 2 3 5 4 6 7 8 9 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx= idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 idx=1 Od tego momentu algorytm pracuje na darmo. Wykona jeszcze 4 przebiegi, w których nic sie nie zmieni. Len=5 T[idx]<->T[idx+1] T[idx]>T[idx+1] Len=6 T Len=7 Len=8 F Idx++ Len-- Idx>=Len Len<=1 F STOP F T T idx=1 Len=8

T[idx]<->T[idx+1] Bubble sort START Kiedy część do posortowania ma 1 element – cały algorytm kończy się Len=9 T: 1 2 3 5 4 6 7 8 9 Len=1 idx=1 T[idx]<->T[idx+1] T[idx]>T[idx+1] T F Idx++ Len-- Idx>=Len Len<=1 F STOP F T T idx=1 Len=8

T[idx]<->T[idx+1] Bubble sort START I to by było na tyle... Len=9 T: 1 2 3 5 4 6 7 8 9 Len=1 idx=1 Cała tablica jest posortowana T[idx]<->T[idx+1] T[idx]>T[idx+1] T F Idx++ Len-- Idx>=Len Len<=1 F STOP F T T idx=1 Len=8