Några standardalgoritmer Utökning och minskning av vektor Sortering av vektor Sökning i vektor Sammanslagning av sorterade vektorer

Utökning av en vektor (FD) Indata: vektor, nytt Skapa nyVektor med längden av vektor + 1 i = 0 returnera nyVektor i < vektorns längd nyVektor[i] = vektor[i] true false Lägg nytt på sista platsen i nyVektor i = i + 1

Utökning av en vektor (JSP) Indata: vektor, nytt Skapa nyVektor med längden av vektor + 1 i = 0 nyVektor[i] = vektor[i] Utökning Stomme Yttre loop * (i < vektorns längd) Lägg nytt på sista platsen i nyVektor returnera nyVektor i = i + 1

Minskning av en vektor (FD) SlimArray Indata: vektor, index Skapa nyVektor med längden av vektor - 1 i = 0 i < index nyVektor[i] = vektor[i] true false i = index + 1 returnera nyVektor vektorns längd nyVektor[i-1] i = i + 1 i + 1

Minskning av en vektor (JSP) Indata: vektor, index Skapa nyVektor med längden av vektor - 1 i = 0 nyVektor[j] = vektor[i] SlimArray Stomme Första loop * (i < index) returnera nyVektor i = i + 1 Andra loop (i < vektorns längd) i = index + 1

Sorteringar

Swap JSP Flödesdiagram Indata: vektor index a index b Swap Indata: temp = vektor[a] vektor[a] = vektor[b] temp = vektor[a] vektor[a] = vektor[b] vektor[b] = temp vektor[b] = temp Stopp

BubbleSort (FD) Indata: vektor BubbleSort osorterad = true osorterad? osorterad = false end = längden av vektorn - 1 false j = 0 j = j + 1 false vektor[j] > vektor[j + 1] j < end true false true Swap (vektor, j, j+1) osorterad = true end = end - 1 Stopp

end = längden av vektorn - 1 Indata: vektor BubbleSort BubbleSort (JSP) osorterad = true end = längden av vektorn - 1 Stomme Yttre loop (osorterad) * osorterad = false j = 0 Stomme Inre loop end = end - 1 (j < end) * Selektion j = j + 1 ( vektor[j] > vektor[j + 1] ) o Swap (vektor, j, j+1) osorterad = true

vektor[minst] > vektor[j] Indata: vektor ExchangeSort (FD) Exchange i = 0 i = i + 1 i < vektorns längd - 1? true minst = i false j = i + 1 j = j + 1 false vektor[minst] > vektor[j] j < vektorns längd true true minst = j false i < minst true Swap (vektor, minst, i) Stopp false

ExchangeSort (JSP) Indata: vektor Exchange i = 0 Stomme Yttre loop (i < vektorns längd - 1) * minst = i j = i + 1 Stomme Inre loop Selektion i = i + 1 (i < minst) (j < vektorns längd ) o Swap (vektor, minst, i) * Selektion j = j + 1 ( vektor[minst] > vektor[j] ) o minst = j

Linjär sökning Flödesdiagram Linjär Sökning Indata: vektor, target JSP vektorns längd? false returnera -1 i = 0 Iteration returnera -1 (i < vektorns längd) true * vektor[i] == target true returnera i Selektion i = i + 1 false ( vektor[i] = target ) o minst = j returnera i

Binär sökning (FD) Indata: vektor, target Binär Sökning high – low > 1 true high = vektorns längd false low = -1 eller vektor[low] <> target true probe = (high + low) / 2 low = -1 vektor[probe] > target false returnera low returnera -1 true false low = probe high = probe

Binär sökning (JSP) Indata: vektor, target Binär sökning high = vektorns längd low = -1 Iteration Selektion ( low = -1 eller vektor[low] <> target) (high – low > 1) returnera -1 o returnera low o * probe = (high + low) / 2 Selektion (vektor[probe] > target) o o high = probe low = probe

Förena listor (FD) first är tom second är tom false Skapa ny vektor merged med längd av first + second countFirst = 0 countSecond = 0 i = 0 Merge false Indata vektorer: first , second true true returnera second returnera first i = i + 1 i < längden av merged false returnera merged Förena listor (FD) true first[countFirst] < second[countSecond] countFirst = längden på first countSecond = längden på second false false false true true true Merged[i] = second[countSecond] Merged[i] = first[countFirst] Merged[i] = first[countFirst] Merged[i] = second[countSecond] countSecond = countSecond + 1 countFirst = countFirst + 1 countFirst = countFirst + 1 countSecond = countSecond + 1

Förena listor (JSP) Indata vektorer: first, second Merge Selektion Skapa ny vektor merged med längd av first + second countFirst = 0 countSecond = 0 i = 0 Iteration returnera merged (i < längden av merged) (om first är tom) (om second är tom) * returnera second o returnera first o Selektion i = i + 1 (countFirst = längden på first) (first[countFirst] < second[countSecond] ) (countSecond = längden på second) o o o o merged[i] = first[countFirst] countFirst = countFirst + 1 merged[i] = second[countSecond] countSecond = countSecond + 1 merged[i] = first[countFirst] countFirst = countFirst + 1 merged[i] = second[countSecond] countSecond = countSecond + 1

Sortering och sökning på annat än heltal Om vi ex. vill sortera en vektor av böcker, måste vi jämföra på annat än numeriska värden: if ( vektor[probe].ISBN.CompareTo( target ) > 0 ) Som Du ser kan vi här inte använda de vanliga relationsoperatorerna, eftersom string inte implementerat dem, utan vi är då istället tvungna att använda metoden CompareTo.

Brytning av listor Att tänka på: Vilket eller vilka fält sorterar vi efter? Vilket eller vilka fält bryter vi på? Vilka variabler skall nollställas vid brytningen? Vilka skall inte nollställas?