Prezentacja multimedialna
Zapoznaj się z prezentacją przedstawiającą użycie stosu zaimplementowanego za pomocą listy jednokierunkowej niecyklicznej w realizacji algorytmu konwersji zapisu infiksowego na odwrotną notację polskąD8zD8PhYJodwrotną notację polską. Algorytm zapisany w pseudokodzie znajdziesz w e‑materiale Dynamiczne struktury danychDINsybcX5Dynamiczne struktury danych.
Specyfikacja problemu:
Dane:
wyrazenie– łańcuch znaków; zapis infiksowy wyrażenia arytmetycznego, w którym znak spacji występuje przed i po każdym operatorze
Wynik:
wyrażenie infiksowe wypisane w odwrotnej notacji polskiej
Na podstawie informacji z sekcji „Przeczytaj” oraz powyższej prezentacji napisz i uruchom program konwertujący podane wyrażenie infiksowe na postfiksowe. W programie użyj stosu zaimplementowanego za pomocą omówionego w sekcji „Przeczytaj” interfejsu Deque i klasy ArrayDeque.
Specyfikacja problemu:
Dane:
wyrazenie– łańcuch znaków; zapis infiksowy wyrażenia arytmetycznego, w którym znak spacji występuje przed i po każdym operatorze
Wynik:
wyrażenie infiksowe wypisane w odwrotnej notacji polskiej.
Działanie programu przetestuj dla następującego wyrażenia: (31 + 4) * 7.
Przykładowy wynik działania programu:
Wyrażenie infiksowe: (31 + 4) * 7
Wyrażenie postfiksowe: 31 4 + 7 *Wykorzystaj kod metody konwertujdoONP() omówiony w prezentacji, ale obiekt stosu utwórz za pomocą instrukcji Deque<String> stos = new ArrayDeque<>();. Następnie użyj we właściwym miejscach metod push(), pop(), getFirst().
import java.util.Deque;
import java.util.ArrayDeque;
public class StosListaOnpJF {
public static boolean czyOperator(String znak) {
if (znak.equals("(") || znak.equals(")") || znak.equals("+") ||
znak.equals("-") || znak.equals("*") || znak.equals("/") ||
znak.equals("%") || znak.equals("^"))
return true;
return false;
}
public static int priorytet(String znak) {
if (znak.equals("(")) return 0;
else if (znak.equals("+") || znak.equals("-")) return 1;
else if (znak.equals("*") || znak.equals("/") || znak.equals("%")) return 2;
else if (znak.equals("^")) return 3;
return -1;
}
public static String konwertujDoOnp(String wyrazenie) {
Deque<String> stos = new ArrayDeque<>();
String wynik = "";
String znak = "";
for (int i=0; i < wyrazenie.length(); i++) {
znak = String.valueOf(wyrazenie.charAt(i));
if (znak.equals(" ") || !czyOperator(znak)) {
wynik += znak;
} else if (znak.equals("(")) {
stos.push(znak);
} else if (znak.equals(")")) {
while (!stos.getFirst().equals("("))
wynik += " " + stos.pop();
stos.pop();
} else {
while (!stos.isEmpty() && (priorytet(stos.getFirst()) >= priorytet(znak)))
wynik += stos.pop();
stos.push(znak);
}
}
while (!stos.isEmpty()) {
wynik += " " + stos.pop();
}
return wynik;
}
public static void main(String[] args) {
String wyrazenie = "(31 + 4) * 7";
System.out.println("Wyrażenie infiksowe: " + wyrazenie);
String wynik = konwertujDoOnp(wyrazenie);
System.out.println("Wyrażenie postfiksowe: " + wynik);
}
}Zapoznaj się z prezentacją przedstawiającą użycie jednokierunkowej listy cyklicznej w symulacji problemu Flawiusza. Algorytm zapisany w pseudokodzie znajdziesz w e‑materiale Dynamiczne struktury danychDINsybcX5Dynamiczne struktury danych.
Specyfikacja problemu:
Dane:
n– liczba naturalna; liczba elementów kręguk– liczba naturalna; liczba oznaczająca pierwszy eliminowany element oraz liczbę przejść do następnego eliminowanego elementu
Wynik:
wypisany numer elementu, który pozostał w kręgu
Przyjmijmy, że do symulacji problemu Flawiusza używamy dwukierunkowej listy cyklicznej o znanym rozmiarze n. Zaimplementuj metody dodaj(), usun() oraz wypisz() uwzględniające dwukierunkowość listy. Po uruchomieniu program powinien wypisywać zawartość listy przed każdym usunięciem węzła, a na końcu pozycję węzła, który pozostał na liście.
Specyfikacja problemu:
Dane:
n– liczba naturalna; rozmiar listy cyklicznejk– liczba naturalna; liczba oznaczająca pierwszy eliminowany element oraz liczbę przejść do następnego eliminowanego elementu
Wynik:
zawartość listy przed każdym usunięciem węzła oraz pozycja węzła, który pozostał na liście
Działanie programu przetestuj dla n = 8 i k = 3.
Przykładowy wynik działania programu:
1 2 3 4 5 6 7 8
1 2 4 5 6 7 8
1 2 4 5 7 8
2 4 5 7 8
2 4 7 8
4 7 8
4 7
7class Wezel {
int pozycja;
Wezel nastepny;
Wezel poprzedni;
Wezel(int pozycja) {
this.pozycja = pozycja;
this.nastepny = null;
this.poprzedni = null;
}
}
class Lista {
Wezel glowa;
public Lista() {
glowa = null;
}
public Wezel przejdz(int o_ile, Wezel wezel) {
Wezel pomocniczy = wezel;
if (wezel == null) {
pomocniczy = glowa;
}
for (int i = 0; i < o_ile; i++) {
pomocniczy = pomocniczy.nastepny;
}
return pomocniczy;
}
public void dodaj(int pozycja) {
Wezel nowy = new Wezel(pozycja);
if (glowa == null) {
glowa = nowy;
glowa.nastepny = glowa.poprzedni = glowa;
return;
}
Wezel ostatni = glowa.poprzedni;
nowy.nastepny = glowa;
nowy.poprzedni = ostatni;
glowa.poprzedni = nowy;
ostatni.nastepny = nowy;
}
public void usun(Wezel wezel) {
wezel.nastepny.poprzedni = wezel.poprzedni;
wezel.poprzedni.nastepny = wezel.nastepny;
if (wezel == glowa) {
if (glowa.nastepny != glowa) {
glowa = glowa.nastepny;
} else {
glowa = null;
}
}
}
public void wypisz(int n) {
Wezel pomocniczy = glowa;
while (n > 0) {
System.out.print(pomocniczy.pozycja + " ");
pomocniczy = pomocniczy.nastepny;
n--;
}
System.out.println();
}
}
public class Lista2Flawiusz {
public static void main(String[] args) {
Lista lista = new Lista();
int n = 8;
int k = 3;
for (int i = 1; i < n + 1; i++)
lista.dodaj(i);
Wezel wezel = lista.przejdz(k - 1, null);
while (wezel.nastepny != wezel) {
lista.wypisz(n--);
lista.usun(wezel);
wezel = lista.przejdz(k, wezel);
}
System.out.println(wezel.pozycja);
}
}Zapoznaj się z prezentacją przedstawiającą użycie niecyklicznej listy dwukierunkowej w algorytmie leksykograficznego sortowania wyrazów. Algorytm zapisany w pseudokodzie znajdziesz w e‑materiale Dynamiczne struktury danychDINsybcX5Dynamiczne struktury danych.
Specyfikacja problemu:
Dane:
wyrazy– tablica lub lista zawierająca ciągi znaków – wyrazy do uporządkowania
Wynik:
wypisane w porządku leksykograficznym wyrazy
Metoda wstaw() zaimplementowana w prezentacji dotyczącej sortowania leksykograficznego wykonuje w pętli while jedno porównanie, które wcześniej wykonywane jest w metodzie sortuj().
Zaimplementuj taką wersję tej metody, która nie wykona zbędnego porównania.
Specyfikacja problemu:
Dane:
wyrazy– tablica lub lista zawierająca ciągi znaków – wyrazy do uporządkowania
Wynik:
wyrazy wypisane przed posortowaniem i po sortowaniu w porządku leksykograficznym
Działanie programu przetestuj dla wyrazów: "dynamiczne", "Struktury", "danych", "Java".
Przykładowy wynik działania programu:
dynamiczne Struktury danych Java
danych dynamiczne Java StrukturyZastanów się nad kolejnością sprawdzania warunków w pętli while, a następnie nad kolejnością sprawdzania warunku zakończenia pętli.
class Wezel {
String wyraz;
Wezel nastepny;
Wezel poprzedni;
Wezel(String wyraz) {
this.wyraz = wyraz;
this.nastepny = null;
this.poprzedni = null;
}
}
class Lista {
Wezel glowa;
Wezel ogon;
public Lista() {
glowa = ogon = null;
}
public void dodaj(String wyraz) {
Wezel nowy = new Wezel(wyraz);
if (glowa == null) {
glowa = ogon = nowy;
} else {
ogon.nastepny = nowy;
nowy.poprzedni = ogon;
ogon = nowy;
}
}
public void usun(Wezel wezel) {
if (wezel == glowa && glowa.nastepny != null) {
glowa = glowa.nastepny;
glowa.poprzedni = null;
return;
}
if (wezel == ogon) {
wezel.poprzedni.nastepny = null;
ogon = wezel.poprzedni;
} else {
wezel.poprzedni.nastepny = wezel.nastepny;
wezel.nastepny.poprzedni = wezel.poprzedni;
}
}
public int porownaj(Wezel wezel_1, Wezel wezel_2) {
String wyraz_1 = wezel_1.wyraz.toLowerCase();
String wyraz_2 = wezel_2.wyraz.toLowerCase();
return wyraz_1.compareTo(wyraz_2);
}
public void sortuj() {
Wezel pomocniczy = glowa;
int i = 0;
while (true) {
if (pomocniczy.nastepny == null)
break;
if (porownaj(pomocniczy, pomocniczy.nastepny) > 0) {
usun(pomocniczy);
wstaw(pomocniczy);
pomocniczy = glowa;
} else {
pomocniczy = pomocniczy.nastepny;
}
}
}
public void wstaw(Wezel wezel) {
Wezel pomocniczy = wezel.nastepny;
while (pomocniczy != ogon && porownaj(wezel, pomocniczy.nastepny) >= 0) {
pomocniczy = pomocniczy.nastepny;
}
if (pomocniczy == ogon) {
wezel.nastepny = null;
wezel.poprzedni = ogon;
ogon.nastepny = wezel;
ogon = wezel;
} else {
wezel.poprzedni = pomocniczy;
wezel.nastepny = pomocniczy.nastepny;
pomocniczy.nastepny.poprzedni = wezel;
pomocniczy.nastepny = wezel;
}
}
public void wypisz() {
Wezel pomocniczy = glowa;
while (pomocniczy != null) {
System.out.print(pomocniczy.wyraz + " ");
pomocniczy = pomocniczy.nastepny;
}
System.out.println();
}
}
public class TesterkaSort {
public static void main(String[] args) {
String dane[] = {"dynamiczne", "Struktury", "danych", "Java"};
Lista lista = new Lista();
for (int i = 0; i < dane.length; i++)
lista.dodaj(dane[i]);
lista.wypisz();
lista.sortuj();
lista.wypisz();
}
}