Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00451 005977 19029344 na godz. na dobę w sumie
Zrozum struktury danych. Algorytmy i praca na danych w Javie - książka
Zrozum struktury danych. Algorytmy i praca na danych w Javie - książka
Autor: Liczba stron: 192
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-4092-3 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook (-35%), audiobook).

Niezależnie od tego, jakim językiem programowania się posługujesz, nie staniesz się dobrym programistą ani nawet przeciętnym informatykiem, jeśli nie przyswoisz sobie najważniejszych idei inżynierii oprogramowania: algorytmów i struktur danych. Nie są to zagadnienia proste i z pewnością niejednego studenta informatyki kosztowały wiele zarwanych nocy. Niestety, istniejące na rynku książki dotyczące tych zagadnień nie ułatwiają nauki. Najczęściej są przeładowane matematycznymi wywodami, zbyt teoretyczne, zbyt opasłe i... zbyt oderwane od konkretnych zastosowań!

Jeśli postanowiłeś zyskać praktyczną wiedzę o algorytmach i strukturach danych, a przy tym nieźle posługujesz się Javą, to trzymasz w rękach właściwą poublikację. Podstawy teoretyczne zostały w niej ograniczone do niezbędnych, potrzebnych w praktyce zagadnień. Sporo miejsca poświęcono analizie implementacji algorytmów i mierzeniu ich wydajności. Wyczerpująco wyjaśniono tak ważne aspekty praktyki inżynierii oprogramowania, jak kontrola wersji i testy jednostkowe. Mimo niewielkiej objętości książki znalazły się tu również ambitniejsze zagadnienia, np. trwałe struktury danych tworzone przez bazy danych Redis. W każdym rozdziale zamieszczono praktyczne ćwiczenia wraz z odpowiednim kodem testującym.

W tej książce między innymi:

Myśl jak informatyk i zrozum algorytmy!


Allen B. Downey jest profesorem informatyki na uczelni Olin College of Engineering. Wykładał na Wellesley College, Colby College i Uniwersytecie Kalifornijskim Berkeley. W 2009 roku pracował jako badacz dla firmy Google. Doktorat z dziedziny informatyki obronił na Uniwersytecie Kalifornijskim Berkeley. Jest autorem szeregu książek i artykułów publikowanych w renomowanych periodykach. Zawodowo interesuje się statystyką Bayesa i nauką o prawdopodobieństwie.

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Tytuł oryginału: Think Data Structures: Algorithms and Information Retrieval in Java Tłumaczenie: Łukasz Suma ISBN: 978-83-283-4092-3 © 2018 Helion S.A. Authorized Polish translation of the English edition of Think Data Structures ISBN 9781491954386 © 2017 Allen B. Downey This translation is published and sold by permission of O’Reilly Media, Inc., which owns or controls all rights to publish and sell the same. All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from the Publisher. Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Pliki z przykładami omawianymi w książce można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/zrojav.zip Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/ Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis treści Wstęp ..........................................................................................................7 1. Interfejsy ............................................................................................13 14 15 16 17 Dlaczego są dwa rodzaje list? Interfejsy w języku Java Interfejs List Ćwiczenie 1. 2. Analiza algorytmów ..........................................................................21 23 25 26 Sortowanie przez wybieranie Notacja dużego O Ćwiczenie 2. 3. Klasa ArrayList ...................................................................................31 31 33 36 37 39 42 Klasyfikacja metod klasy MyArrayList Klasyfikacja metody add Wielkość problemu obliczeniowego Powiązane struktury danych Ćwiczenie 3. Uwaga na temat odśmiecania pamięci 4. Klasa LinkedList .................................................................................45 45 48 49 52 53 Klasyfikacja metod klasy MyLinkedList Porównanie klas MyArrayList i MyLinkedList Profilowanie Interpretacja wyników Ćwiczenie 4. 5. Lista dwukierunkowa ........................................................................55 55 57 59 Wyniki profilowania wydajnościowego Profilowanie metod klasy LinkedList Dodawanie na końcu listy będącej obiektem klasy LinkedList Spis treści (cid:95) 3 Poleć książkęKup książkę Lista dwukierunkowa Wybór struktury 61 62 6. Przechodzenie przez drzewo ...........................................................65 65 67 69 71 72 73 75 Mechanizmy wyszukiwania Parsowanie kodu HTML Używanie biblioteki jsoup Iterowanie po drzewie DOM Przeszukiwanie w głąb Stosy w języku Java Iteracyjna implementacja DFS 7. Dochodzenie do filozofii ...................................................................77 77 78 80 82 Pierwsze kroki Interfejsy Iterable i Iterator Klasa WikiFetcher Ćwiczenie 5. 8. Indekser ..............................................................................................85 85 87 90 Wybór struktury danych Klasa TermCounter Ćwiczenie 6. 9. Interfejs Map ......................................................................................95 95 96 98 Implementacja klasy MyLinearMap Ćwiczenie 7. Analiza klasy MyLinearMap 10. Mieszanie .........................................................................................101 101 104 106 107 Mieszanie Jak działa mieszanie? Mieszanie i zmiany Ćwiczenie 8. 11. Klasa HashMap ................................................................................109 109 111 113 114 114 117 Ćwiczenie 9. Analiza klasy MyHashMap Kompromisy Profilowanie klasy MyHashMap Poprawianie klasy MyHashMap Diagramy klas UML 4 (cid:95) Spis treści Poleć książkęKup książkę 12. Klasa TreeMap .................................................................................119 119 120 122 124 Co jest nie tak z mieszaniem? Binarne drzewo poszukiwań Ćwiczenie 10. Implementacja klasy TreeMap 13. Binarne drzewo poszukiwań ..........................................................129 129 130 132 133 135 137 138 Prosta klasa MyTreeMap Wyszukiwanie wartości Implementacja metody put Przechodzenie poprzeczne Metody logarytmiczne Drzewa samorównoważące się Jeszcze jedno ćwiczenie 14. Trwałość ...........................................................................................139 140 141 142 144 146 148 149 Redis Serwery i klienty Redisa Tworzenie indeksu przy użyciu Redisa Typy danych Redisa Ćwiczenie 11. Więcej sugestii, z których możesz skorzystać Kilka wskazówek dotyczących projektu 15. Pełzanie po Wikipedii .....................................................................151 151 154 155 156 157 Indekser wykorzystujący Redisa Analiza operacji przeglądania Analiza operacji indeksowania Przechodzenie grafu Ćwiczenie 12. 16. Wyszukiwanie logiczne ..................................................................161 161 163 164 165 168 170 Implementacja pełzacza Pozyskiwanie informacji Wyszukiwanie logiczne Ćwiczenie 13. Interfejsy Comparable i Comparator Rozszerzenia Spis treści (cid:95) 5 Poleć książkęKup książkę 17. Sortowanie .......................................................................................173 174 176 178 180 182 185 185 Sortowanie przez wstawianie Ćwiczenie 14. Analiza sortowania przez scalanie Sortowanie pozycyjne Sortowanie przez kopcowanie Kopiec ograniczony Złożoność pamięciowa Skorowidz ...............................................................................................189 6 (cid:95) Spis treści Poleć książkęKup książkę ROZDZIAŁ 1. Interfejsy W tej książce prezentowane są trzy główne tematy: Struktury danych Korzystając ze struktur oferowanych przez Java Collections Framework (JCF), nauczysz się używać struktur danych takich jak listy i mapy, a także dowiesz się, jak działają. Analiza algorytmów Przedstawiam tu sposoby umożliwiające analizowanie kodu i przewidywanie tego, jak szybko będzie on działał i ile miejsca (pamięci) będzie mu potrzebne. Pozyskiwanie informacji Aby uzasadnić potrzebę zapoznania się z dwoma pierwszymi tematami i uczynić ćwiczenia nieco bardziej interesującymi, skorzystamy z algorytmów i struktur danych w celu zbudowania prostego mechanizmu wyszukiwarki internetowej. Oto ogólny zarys kolejności poruszonych tematów: (cid:120) Zaczniemy od interfejsu List, a Twoim zadaniem będzie napisanie klas im- plementujących go na dwa różne sposoby. Następnie porównamy Twoje im- plementacje z klasami ArrayList i LinkedList zapewnianymi przez język Java. (cid:120) Następnie przedstawię struktury o charakterze drzewiastym, a Ty opracujesz swoją pierwszą aplikację: program odczytujący strony Wikipedii, analizujący ich treść i poruszający się po utworzonym w ten sposób drzewie w celu wyszukiwania łącz i innych elementów. Skorzystamy z tych narzędzi, aby sprawdzić hipotezę, że większość stron serwisu prowadzi ostatecznie do 13 Poleć książkęKup książkę strony hasła „filozofia” (informacje na temat tego zjawiska znajdziesz w języku angielskim na stronie https://en.wikipedia.org/wiki/Wikipedia: (cid:180)Getting_to_Philosophy1). (cid:120) Kolejna będzie prezentacja interfejsu Map i zapewnianej przez język Java implementacji klasy HashMap. Następnie napiszesz klasy implementujące ten interfejs za pomocą tablicy mieszającej i binarnego drzewa poszukiwań. (cid:120) Na koniec użyjesz tych klas (i kilku innych, które przedstawię po drodze) do zaimplementowania mechanizmu wyszukiwarki internetowej, w tym również pełzacza, który wyszukuje i odczytuje strony, indeksera, który zapi- suje zawartość stron internetowych w takiej formie, aby dało się ją efektywnie przeszukiwać, a także pozyskiwacza, który przyjmuje zapytania od użytkow- nika i zwraca odpowiednie wyniki. Zacznijmy zatem. Dlaczego są dwa rodzaje list? Gdy ludzie zaczynają korzystać z Java Collections Framework, są nieraz zdezo- rientowani faktem istnienia dwóch różnych klas reprezentujących listę, a miano- wicie ArrayList i LinkedList. Dlaczego Java dostarcza dwie implementacje interfejsu List? I na podstawie jakich kryteriów powinno się wybrać tę właściwą do zastosowania w danym przypadku? Odpowiem na te pytania w kilku kolej- nych podrozdziałach. Zacznę od przeglądu interfejsów i klas, które je implementują, a także zapre- zentuję koncepcję tak zwanego programowania do interfejsu. W pierwszych kilku ćwiczeniach zaimplementujesz klasy podobne do ArrayList i LinkedList, aby dowiedzieć się, jak one działają; przekonasz się również, że każda z tych klas ma swoje zalety i wady. Niektóre operacje są wykonywane szybciej lub wymagają mniej pamięci w przypadku zastosowania klasy ArrayList, inne są z kolei szybsze lub mniej wymagające pamięciowo, gdy użyje się klasy LinkedList. To, która z tych klas jest lepsza w konkretnym zastosowaniu, zależy od tego, jakie operacje są wykonywane częściej. 1 Niestety w sieci brak podobnego artykułu w języku polskim — przyp. tłum. 14 (cid:95) Rozdział 1. Interfejsy Poleć książkęKup książkę Interfejsy w języku Java Interfejs języka Java określa zestaw metod, a każda klasa implementująca dany interfejs musi zapewnić te metody. Oto na przykład kod źródłowy interfejsu Comparable, który został zdefiniowany w pakiecie java.lang: public interface Comparable T { public int compareTo(T o); } W tej definicji interfejsu używany jest parametr typu T, który powoduje, że interfejs Comparable jest typem generycznym, zwanym też ogólnym (ang. generic type). Aby implementować ten interfejs, klasa musi: (cid:120) określać typ, do którego odnosi się T; (cid:120) zapewniać metodę o nazwie compareTo, która przyjmuje jako argument obiekt i zwraca wartość int. Tak na przykład wygląda kod klasy java.lang.Integer: public final class Integer extends Number implements Comparable Integer { public int compareTo(Integer anotherInteger) { int thisVal = this.value; int anotherVal = anotherInteger.value; return (thisVal anotherVal ? -1 : (thisVal==anotherVal ? 0 : 1)); } // inne metody pominięte } Klasa ta rozszerza klasę Number, dlatego dziedziczy metody i zmienne instancyjne tej ostatniej i implementuje interfejs Comparable Integer , w związku z czym zapewnia metodę compareTo, która przyjmuje jako argument obiekt klasy Integer i zwraca wartość typu int. Gdy deklaruje się, że klasa implementuje pewien interfejs, kompilator spraw- dza, czy zapewnia ona wszystkie metody zdefiniowane w ramach tego interfejsu. A tak na marginesie: w przedstawionej powyżej implementacji metody compareTo zastosowany został „potrójny operator”, zapisywany czasem jako ?:. Jeśli nie jest Ci on znany, odwiedź anglojęzyczną stronę https://docs.oracle.com/javase/ tutorial/java/nutsandbolts/op2.html 2. 2 Informacje po polsku na temat trójargumentowego operatora porównania możesz znaleźć na przykład pod adresem http://notatkiprogramisty.blox.pl/2011/11/Operator-warunkowy-potrojny- -ternary-operator.html — przyp. tłum. Interfejsy w języku Java (cid:95) 15 Poleć książkęKup książkę Interfejs List W ramach Java Collections Framework (JCF) zdefiniowany został interfejs o nazwie List; zbiór zapewnia też dwie implementujące go klasy: ArrayList i LinkedList. Interfejs ten definiuje to, co oznacza bycie listą; każda implementująca go klasa musi zapewnić określony zestaw metod, w tym metody add, get, remove, a także około 20 innych. Klasy ArrayList i LinkedList oferują te metody, dlatego mogą być używane wymiennie. Metoda napisana w taki sposób, aby operować na obiekcie typu List, poradzi sobie z obiektem klasy ArrayList, LinkedList, a także z każdym innym, którego klasa implementuje interfejs List. Oto wymyślony przykład, który demonstruje sposób działania tego mechanizmu: public class ListClientExample { private List list; public ListClientExample() { list = new LinkedList(); } private List getList() { return list; } public static void main(String[] args) { ListClientExample lce = new ListClientExample(); List list = lce.getList(); System.out.println(list); } } Klasa ListClientExample nie robi nic użytecznego, ale ma wszystkie podstawowe elementy klasy, która hermetyzuje interfejs List. Oznacza to, że zawiera ona zmienną instancyjną typu List. Skorzystam z tej klasy, aby przedstawić ideę, a następnie zajmiesz się pierwszym ćwiczeniem. Konstruktor klasy ListClientExample inicjalizuje składnik list poprzez utwo- rzenie instancji (czyli egzemplarza) klasy LinkedList. Metoda gettera o nazwie getList zwraca referencję do wewnętrznego obiektu typu List, a metoda main zawiera kilka wierszy kodu, których zadaniem jest przetestowanie pozostałych metod. 16 (cid:95) Rozdział 1. Interfejsy Poleć książkęKup książkę Ważne w tym przykładzie jest to, że wykorzystujemy w nim typ List wszędzie tam, gdzie jest to możliwe, i unikamy precyzowania, czy chodzi nam o klasę LinkedList czy o klasę ArrayList, dopóki nie jest to konieczne. Zmienna instan- cyjna jest na przykład zadeklarowana jako List, a metoda getList zwraca obiekt typu List, w żadnym z tych przypadków nie określamy jednak dokładnie, o jaki dokładnie rodzaj listy nam chodzi. Jeśli w pewnym momencie zmienisz zdanie i postanowisz zastosować klasę ArrayList, będziesz jedynie musiał zmienić konstruktor; żadne inne zmiany nie będą konieczne. Ten styl określany jest mianem programowania opartego na interfejsach (ang. interface-based programming) lub — nieco bardziej potocznie — progra- mowania do interfejsu (ang. programming to an interface). Więcej informacji po angielsku na temat tej techniki znajdziesz pod adresem https://en.wikipedia. org/wiki/Interface-based_programming3. Mówimy tutaj o ogólnej idei interfejsu, nie konkretnie o interfejsie języka Java. Gdy korzystasz z biblioteki, Twój kod powinien być uzależniony wyłącznie od jej interfejsu, takiego jak List. Kod nie powinien zależeć od konkretnej imple- mentacji, takiej jak ArrayList. Dzięki temu, jeśli implementacja ulegnie w przy- szłości zmianie, wykorzystujący ją kod nadal będzie działał bez problemu. Z drugiej jednak strony, jeśli zmieni się interfejs, zmodyfikowany będzie musiał zostać również zależny od niego kod. To właśnie z tego powodu programiści tworzący biblioteki unikają zmian interfejsów, gdy nie są absolutnie konieczne. Ćwiczenie 1. Jako że jest to pierwsze ćwiczenie w tej książce, będzie ono bardzo proste. Chodzi w nim o to, aby wziąć kod przedstawiony w poprzednim podrozdziale i zamienić implementację. Należy zatem zastąpić odwołanie do klasy LinkedList odwołaniem do klasy ArrayList. Dzięki temu, że nasz kod powstał zgodnie z za- łożeniem programowania do interfejsu, przełączenie implementacji będzie wymagało zmiany tylko jednego wiersza i dodania instrukcji import. 3 Informacje na ten temat w języku polskim znaleźć można na przykład na stronie https://javastart.pl/static/programowanie-obiektowe/polimorfizm/ — przyp. tłum. Ćwiczenie 1. (cid:95) 17 Poleć książkęKup książkę Zacznij od konfiguracji swojego środowiska programistycznego. W przypadku wszystkich ćwiczeń przedstawionych w tej książce będzie Ci potrzebna możliwość kompilacji i uruchamiania kodu napisanego w języku Java. Opracowałem przy- kłady, korzystając ze środowiska Java SE Development Kit 7. Jeśli korzystasz z nowszej wersji rozwiązania, wszystko w dalszym ciągu powinno działać. Jeśli używasz starszej wersji środowiska, możesz natknąć się na pewne niezgodności. Zalecam Ci zastosowanie interaktywnego środowiska programistycznego (ang. interactive development environment IDE), które zapewnia możliwości spraw- dzania składni, autouzupełniania oraz refaktoringu kodu źródłowego. Funkcje te pomogą Ci unikać błędów i szybko znajdować te, których uniknąć Ci się nie uda. Jeśli jednak przygotowujesz się na techniczną rozmowę kwalifikacyjną, musisz pamiętać, że w jej trakcie nie będziesz mieć do dyspozycji wszystkich tych narzędzi, dlatego może Ci się przydać trochę praktyki w pisaniu kodu bez ich użycia. Jeśli nie pobrałeś jeszcze kodu związanego z tą książką, zapoznaj się ze wskazów- kami przedstawionymi w podrozdziale wstępu zatytułowanym „Praca z kodem”. W katalogu o nazwie code powinieneś znaleźć następujące elementy: (cid:120) build.xml to plik Anta, który ułatwia kompilację i uruchamianie kodu; (cid:120) lib to katalog zawierający biblioteki, których będziesz potrzebować (w przy- padku tego ćwiczenia będzie to jedynie JUnit); (cid:120) src to katalog zawierający kod źródłowy. Gdy przejdziesz do katalogu src/com/allendowney/thinkdast, znajdziesz kod źródłowy dla tego ćwiczenia: (cid:120) Plik ListClientExample.java zawiera kod przedstawiony w poprzednim podrozdziale. (cid:120) Plik ListClientExampleTest.java zawiera opracowany za pomocą biblioteki JUnit test klasy ListClientExample. Przejrzyj kod klasy ListClientExample i upewnij się, że rozumiesz jego działanie. Następnie go skompiluj i uruchom. Jeśli używasz Anta, przejdź do katalogu code i wywołaj polecenie ant ListClientExample. Niewykluczone, że w wyniku tego na ekranie pojawi się ostrzeżenie podobne do następującego: 18 (cid:95) Rozdział 1. Interfejsy Poleć książkęKup książkę List is a raw type. References to generic type List E should be parameterized.4 Aby uprościć przykład, nie zawracałem sobie głowy określaniem typu elementów przechowywanych za pomocą obiektu klasy List. Jeśli ostrzeżenie to Ci przeszka- dza, możesz się go pozbyć, zastępując każde wystąpienie typu List lub LinkedList odpowiednio konstrukcją List Integer lub LinkedList Integer . Przejrzyj kod klasy ListClientExampleTest. Jest w niej wykonywany pojedynczy test, w ramach którego tworzy się obiekt klasy ListClientExample, wywołuje się metodę getList, a następnie sprawdza się, czy uzyskany wynik jest typu ArrayList. Początkowo test ten zakończy się niepowodzeniem, ponieważ wynik jest obiektem klasy LinkedList, a nie ArrayList. Uruchom ten test i przekonaj się, że się nie powiedzie. Uwaga: Test ten ma sens w przypadku tego ćwiczenia, nie jest jednak dobrym przykładem testu jako takiego. Dobre testy powinny sprawdzać, czy testowana klasa spełnia wymagania stawiane przez interfejs; nie powinny być uzależnione od szczegółów implementacji. W klasie ListClientExample zastąp typ LinkedList typem ArrayList. Być może będzie też trzeba dodać instrukcję import. Skompiluj i uruchom kod klasy ListClientExample. Potem ponownie uruchom odpowiedni test. Dzięki dokona- nej przez Ciebie zmianie test tym razem powinien się powieść. Aby do tego doprowadzić, musiałeś jedynie zmienić jeden wiersz konstruktora klasy; nie było potrzeby wprowadzania jakichkolwiek innych zmian w którym- kolwiek miejscu, w jakim występuje typ List. A co stanie się, gdy to zrobisz? Śmiało, spróbuj: zastąp jedno lub wszystkie wystąpienia słowa List słowem ArrayList. Kiedy to zrobisz, program w dalszym ciągu powinien działać popraw- nie, będzie jednak „nadmiernie skonkretyzowany”. Jeśli zmienisz w przyszłości zdanie i postanowisz ponownie przełączyć implementację, będziesz musiał zmie- nić większą ilość kodu. Co się stanie, gdy w konstruktorze klasy ListClientExample zmienisz typ Array (cid:180)List na typ List? Dlaczego nie możesz utworzyć egzemplarza tego typu? 4 List to typ surowy. Odwołania do generycznego typu List E powinny być sparametry- zowane — przyp. tłum. Ćwiczenie 1. (cid:95) 19 Poleć książkęKup książkę 20 (cid:95) Rozdział 1. Interfejsy Poleć książkęKup książkę A algorytm DFS, 75 kwadratowy, 22 liniowy, 22 logarytmiczny, 122 stałoczasowy, 22 analiza algorytmów, 21 operacji indeksowania, 155 operacji przeglądania, 154 z amortyzacją, 35 API, application programming interface, 9 B biblioteka jsoup, 69 binarne drzewo poszukiwań, 120, 129 D diagramy klas UML, 117 drzewo, 120, 129 DOM, 67, 71 samorównoważące się, 137 E egzemplarz klasy, 16 Skorowidz FIFO, 73 funkcja mieszająca, 102 skrótu, 102 graf, 156 F G H haszowanie, Patrz mieszanie, 101, 104 HTML, 67 I identyfikator, 135 iloczyn zbiorów, 86 indeks, 85 indekser, 151 indeksowanie, 65, 155 instancja, 16 interfejs, 15 Comparable, 168 Comparator, 168 Iterable, 78 Iterator, 78 List, 16 Map, 95 programowania aplikacji, API, 9 Skorowidz (cid:95) 189 Poleć książkęKup książkę logarytmiczne, 135 opakowujące, 88 mieszanie, 101, 104 N notacja dużego O, 25 O odśmiecanie pamięci, 42 P parametr typu T, 15 parsowanie kodu HTML, 67 pełzacz, 161 pełzanie, 65 pozyskiwanie informacji, 66, 163 profilowanie, 21, 49 klasy LinkedList, 57 klasy MyHashMap, 114 wydajnościowe, 55 programowanie oparte na interfejsach, 17 przechodzenie poprzeczne, 133 przeglądanie, 154 przeszukiwanie w głąb, 71 R Redis, 140 indekser, 151 klienty, 141 serwery, 141 tworzenie indeksu, 142 typy danych, 144 rząd wzrostu, 26 K klasa ArrayList, 31 HashMap, 109 LinkedList, 45 ListNode, 38 MyArrayList, 48 MyHashMap, 111, 114 MyLinearMap, 95, 98 MyLinkedList, 48 MyTreeMap, 129 TermCounter, 87 TreeMap, 119, 124 WikiFetcher, 80 klasy anonimowe, 50 klucz, 86 kopiec ograniczony, 185 L LIFO, 73 lista, 14 dodawanie elementów, 59 dwukierunkowa, 55, 61 M mapa, 86 metoda add, 33 get, 31 getElementById, 70 indexOf, 32 keySet, 133 put, 132 remove, 47 select, 70 set, 32 metody klasy MyArrayList, 31 klasy MyLinkedList, 45 190 (cid:95) Skorowidz Poleć książkęKup książkę S schemat obiektów listy, 39 skrót, 102 sortowanie, 173 pozycyjne, 180 przez kopcowanie, 182 przez scalanie, 178 przez wstawianie, 174 przez wybieranie, 23 stos, 73 struktura danych, 37, 85 T tworzenie indeksu, 142 instancji, 16 typ generyczny, 15 typy danych Redisa, 144 U UML, 117 W wyrażenia regularne, 89 wyszukiwanie logiczne, 164 wartości, 130 wyszukiwarka internetowa, 65 Z złożoność pamięciowa, 185 znacznik, 67 Skorowidz (cid:95) 191 Poleć książkęKup książkę Poleć książkęKup książkę
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Zrozum struktury danych. Algorytmy i praca na danych w Javie
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: