Presentasi sedang didownload. Silahkan tunggu

Presentasi sedang didownload. Silahkan tunggu

Linear List Teknik Informatika Universitas Muhammadiyah Malang SP - 2013 Algoritma & Struktur Data.

Presentasi serupa


Presentasi berjudul: "Linear List Teknik Informatika Universitas Muhammadiyah Malang SP - 2013 Algoritma & Struktur Data."— Transcript presentasi:

1

2 Linear List Teknik Informatika Universitas Muhammadiyah Malang SP Algoritma & Struktur Data

3 Representasi Linear List dengan Array dan Linked list

4 Tujuan Instruksional Mahasiswa mampu : – Memahami struktur data dari linear list – Mampu merepresentasikan linear list menggunakan array dan linked list – Mengimplementasikan linear list ke dalam program

5 Struktur Data Struktur data terdiri dari obyek data dan operasi-operasi. Obyek data adalah sekumpulan instance (model/sampling) Contoh obyek data : integer = {0, +1, -1, +2, -2, +3, -3, …} daysOfWeek = {S,M,T,W,Th,F,Sa} myDataObject = {apple, chair, 2, 5.2, red, green, Jack}

6 Struktur Data Struktur data dibedakan menjadi 2 jenis : 1.Linear list direpresentasikan dengan : array dan linked list 2.Struktur data hirarki Direpresentasikan dengan : tree dan graph

7 Linear Lists Disebut juga dengan ordered list. Bentuk instance dari linear list : (e 0, e 1, e 2, …, e n-1 ) where e i denotes a list element n >= 0 is finite (list size is n)

8 Linear Lists L = (e 0, e 1, e 2, e 3, …, e n-1 ) relationships e 0 is the zero’th (or front) element e n-1 is the last element e i immediately precedes e i+1

9 Linear List Examples/Instances Students in COP3530 = (Jack, Jill, Abe, Henry, Mary, …, Judy) Exams in COP3530 = (exam1, exam2, exam3) Days of Week = (S, M, T, W, Th, F, Sa) Months = (Jan, Feb, Mar, Apr, …, Nov, Dec)

10 Struktur data Operations Operasi : aksi yang dapat dilakukan pada obyek data. Operasi-operasi yang umum pada obyek data : penambahan elemen, penghapusan elemen, pengaksesan elemen, dll.

11 Linear List Operations—size() determine list size L = (a,b,c,d,e) size = 5

12 Linear List Operations—get(theIndex) get element with given index L = (a,b,c,d,e) get(0) = a get(2) = c get(4) = e get(-1) = error get(9) = error

13 Linear List Operations— indexOf(theElement) determine the index of an element L = (a,b,d,b,a) indexOf(d) = 2 indexOf(a) = 0 indexOf(z) = -1

14 Linear List Operations— remove(theIndex) remove and return element with given index L = (a,b,c,d,e,f,g) remove(2) returns c and L becomes (a,b,d,e,f,g) index of d,e,f, and g decrease by 1

15 Linear List Operations— remove(theIndex) remove and return element with given index L = (a,b,c,d,e,f,g) remove(-1) => error remove(20) => error

16 Linear List Operations— add(theIndex, theElement) add an element so that the new element has a specified index L = (a,b,c,d,e,f,g) add(0,h) => L = (h,a,b,c,d,e,f,g) index of a,b,c,d,e,f, and g increase by 1

17 Linear List Operations— add(theIndex, theElement) L = (a,b,c,d,e,f,g) add(2,h) => L = (a,b,h,c,d,e,f,g) index of c,d,e,f, and g increase by 1 add(10,h) => error add(-6,h) => error

18 Latihan Diketahui L=(a,b,c,d). L adalah sebuah array linier list. Tentukan hasil yang didapatkan ketika dilakukan perintah berikut ini : a)isEmpty() b)size() c)get(0), get(2),get(6),get(-3) d)indexOf(a), indexOf(c), indexOf(q) e)remove(0), remove(2), remove(3) f)add(0,e), add(2,f), add(3,g), add(4,h), add(6,h), add(-3,h)

19 Data Structure Specification  Language independent  Abstract Data Type  Java  Interface  Abstract Class

20 Linear List Abstract Data Type AbstractDataType LinearList { instances ordered finite collections of zero or more elements operations isEmpty(): return true if the list is empty, false otherwise size(): return the list size (i.e., number of elements in the list) get(index): return the indexth element of the list indexO f(x): return the index of the first occurrence of x in the list, return -1 if x is not in the list remove(index): remove and return the indexth element, elements with higher index have their index reduced by 1 add(theIndex, x): insert x as the indexth element, elements with theIndex >= index have their index increased by 1 output(): output the list elements from left to right }

21 Linear List as Java Interface An interface may include constants and abstract methods (i.e., methods for which no implementation is provided).

22 Linear List as Java Interface public interface LinearList { public boolean isEmpty(); public int size(); public Object get(int index); public int indexOf(Object elem); public Object remove(int index); public void add(int index, Object obj); public String toString(); }

23 Implementing An Interface public class ArrayLinearList implements LinearList { // code for all LinearList methods must be provided here }

24 Linear List As An Abstract Class An abstract class may include constants, variables, abstract methods, and nonabstract methods.

25 Linear List As Java Abstract Class public abstract class LinearListAsAbstractClass { public abstract boolean isEmpty(); public abstract int size(); public abstract Object get(int index); public abstract int indexOf(Object theElement); public abstract Object remove(int index); public abstract void add(int index, Object theElement); public abstract String toString(); }

26 Extending A Java Class public class ArrayLinearList extends LinearListAsAbstractClass { // code for all abstract classes must come here }

27 Linear List Array Representation use a one-dimensional array element[] abcde L = (a, b, c, d, e) Store element i of list in element[i].

28 Representation Used In Text put element i of list in element[i] use a variable size to record current number of elements abcde size = 5

29 Add/Remove An Element abcde size = 5 agbcde size = 6 add(1,g)

30 Data Type Of Array element[] Data type of list elements is unknown. Define element[] to be of data type Object. Cannot put elements of primitive data types (int, float, double, char, etc.) into our linear lists.

31 Increasing Array Length Length of array element[] is 6. abcdef newArray = new Object[15]; First create a new and larger array

32 Increasing Array Length Now copy elements from old array to new one. abcdefabcdef

33 Increasing Array Length Finally, rename new array. element = newArray; element.length = 15 abcdef element[0]

34 Class ArrayLinearList Merupakan hasil implements dari interface LinearList.

35 Create An Empty List ArrayLinearList a = new ArrayLinearList(100), b = new ArrayLinearList(), c; LinearList d = new ArrayLinearList(1000), e = new ArrayLinearList(), f;

36 Using A Linear List System.out.println(a.size()); a.add(0, new Integer(2)); b.add(0, new Integer(4)); System.out.println(a); b.remove(0); if (a.isEmpty()) a.add(0, new Integer(5));

37 Array Of Linear Lists LinearList [] x = new LinearList [4]; x[0] = new ArrayLinearList(20); x[1] = new Chain(); x[2] = new Chain(); x[3] = new ArrayLinearList(); for (int i = 0; i < 4; i++) x[i].add(0, new Integer(i));

38 The Class ArrayLinearList /** array implementation of LinearList */ package dataStructures; import java.util.*; // has Iterator interface import utilities.*; // has array resizing class public class ArrayLinearList implements LinearList { // data members protected Object [] element; // array of elements protected int size; // number of elements in array // constructors and other methods come here }

39 A Constructor /** create a list with initial capacity initialCapacity IllegalArgumentException when * initialCapacity < 1 */ public ArrayLinearList(int initialCapacity) { if (initialCapacity < 1) throw new IllegalArgumentException ("initialCapacity must be >= 1"); // size has the default initial value of 0 element = new Object [initialCapacity]; }

40 Another Constructor /** create a list with initial capacity 10 */ public ArrayLinearList() {// use default capacity of 10 this(10); }

41 The Method isEmpty true iff list is empty */ public boolean isEmpty() {return size == 0;}

42 The Method size() current number of elements in list */ public int size() {return size;}

43 The Method checkIndex IndexOutOfBoundsException when * index is not between 0 and size - 1 */ void checkIndex(int index) { if (index = size) throw new IndexOutOfBoundsException ("index = " + index + " size = " + size); }

44 The Method get element with specified index IndexOutOfBoundsException when * index is not between 0 and size - 1 */ public Object get(int index) { checkIndex(index); return element[index]; }

45 The Method indexOf index of first occurrence of theElement, * return -1 if theElement not in list */ public int indexOf(Object theElement) { // search element[] for theElement for (int i = 0; i < size; i++) if (element[i].equals(theElement)) return i; // theElement not found return -1; }

46 The Method remove public Object remove(int index) { checkIndex(index); // valid index, shift elements with higher index Object removedElement = element[index]; for (int i = index + 1; i < size; i++) element[i-1] = element[i]; element[--size] = null; // enable garbage collection return removedElement; }

47 The Method add public void add(int index, Object theElement) { if (index size) // invalid list position throw new IndexOutOfBoundsException ("index = " + index + " size = " + size); // valid index, make sure we have space if (size == element.length) // no space, double capacity element = ChangeArrayLength.changeLength1D(element, 2 * size);

49 Faster Way To Shift Elements 1 Right System.arraycopy(element, index, element, index + 1, size - index);

50 Convert To A String public String toString() { StringBuffer s = new StringBuffer("["); // put elements into the buffer for (int i = 0; i < size; i++) if (element[i] == null) s.append("null, "); else s.append(element[i].toString() + ", "); if (size > 0) s.delete(s.length() - 2, s.length()); // remove last ", " s.append("]"); // create equivalent String return new String(s); }

51 Linear list Linked-Lists Representation

52 Definisi Linked list : linear list yang dibangun dari satu atau lebih node. Node terdiri dari dua bagian : data field dan pointer. Data field: bagian dari list node untuk menyimpan data. Pointer : bagian dari list node untuk menunjuk node berikutnya.

53 Node Link atau pointer data field

54 Single linked list Yaitu Linked list yang memiliki satu pointer. Pointer bantu : firstnode

55 Linked Representation pointer (or link) in e is null caedb use a variable firstNode to get to the first element a firstNode

56 Normal Way To Draw A Linked List link or pointer field of node data field of node abcde null firstNode

57 Linked Lists vs Array Menyimpan koleksi elemen secara non-contiguously. – Elemen dapat terletak pada lokasi memory yang saling berjauhan. Bandingkan dengan array dimana tiap-tiap elemen akan terletak pada lokasi memory yang berurutan. Mengizinkan operasi penambahan atau penghapusan elemen ditengah-tengah koleksi dengan hanya membutuhkan jumlah perpindahan elemen yang konstan. – Bandingkan dengan array. Berapa banyak elemen yang harus dipindahkan bila akan menyisipi elemen ditengah- tengah array? A0A1A2A3

58 Chain A chain is a linked list in which each node represents one element. There is a link or pointer from one element to the next. The last node has a null pointer. abcde null firstNode

59 Latihan Diketahui L=(a,b,c,d). L adalah sebuah linked lists.. Tentukan hasil yang didapatkan ketika dilakukan operasi berikut ini : a)isEmpty() b)size() c)get(0), get(2),get(6),get(-3) d)indexOf(a), indexOf(c), indexOf(q) e)remove(0), remove(2), remove(3) f)add(0,e), add(2,f), add(3,g), add(4,h), add(6,h), add(-3,h) (Gambarkan rangkaian node pembentuk linked list tersebut kondisi awal dan akhir tiap operasi)

60 Node Representation package dataStructures; class ChainNode { // package visible data members Object element; ChainNode next; // constructors come here } next element

61 Constructors Of ChainNode ChainNode() {} null element next element ChainNode(Object element) {this.element = element;} ChainNode(Object element, ChainNode next) {this.element = element; this.next = next;}

62 get(0) checkIndex(0); desiredNode = firstNode; // gets you to first node return desiredNode.element; abcde null firstNode

63 get(1) checkIndex(1); desiredNode = firstNode.next; // gets you to second node return desiredNode.element; abcde null firstNode

64 get(2) checkIndex(2); desiredNode = firstNode.next.next; // gets you to third node return desiredNode.element; abcde null firstNode

65 get(5) checkIndex(5); // throws exception desiredNode = firstNode.next.next.next.next.next; // desiredNode = null return desiredNode.element; // null.element abcde null firstNode

66 NullPointerException desiredNode = firstNode.next.next.next.next.next.next; // gets the computer mad // you get a NullPointerException abcde null firstNode

67 Remove An Element remove(0) abcde null firstNode firstNode = firstNode.next;

68 abde null firstNode c remove(2) first get to node just before node to be removed c c beforeNode = firstNode.next ; b beforeNode

69 remove(2) now change pointer in beforeNode beforeNode.next = beforeNode.next.next; beforeNode abcde null firstNode

70 add(0,’f’) abcde null firstNode f newNod e Step 1: get a node, set its data and link fields ChainNode newNode = new ChainNode(new Character(‘f’), firstNode);

71 add(0,’f’) abcde null firstNode f newNod e Step 2: update firstNode firstNode = newNode;

72 One-Step add(0,’f’) abcde null firstNode f newNod e firstNode = new ChainNode( new Character(‘f’), firstNode);

73 add(3,’f’) first find node whose index is 2 abcde null firstNode f newNode beforeNode c next create a node and set its data and link fields ChainNode newNode = new ChainNode(new Character(‘f’), beforeNode.next); finally link beforeNode to newNode beforeNode.next = newNode;

74 Two-Step add(3,’f’) beforeNode = firstNode.next.next; beforeNode.next = new ChainNode(new Character(‘f’), beforeNode.next); abcde null firstNode f newNode beforeNode c

75 Double Linked List

76 Definisi Linked list dengan dua pointer(next & prev) Pointer next : menghadap ke node yang lebih besar indexnya. Pointer prev : menghadap ke node yang lebih kecil indexnya.

77 Head & Tail Head : menunjuk pada node pertama. Tail : menunjuk pada node terakhir. Pada node pertama, pointer prev mengarah ke null. Pada node terakhir, pointer next mengarah ke null.

78 Gambaran last Data/item prev next

79 Double Representation class Node { Object dData; // data item Node next; // pointer next Node prev; // pointer prev ….. }

80 Operasi Penambahan/penyisipan Penghapusan

81 Penambahan Node

82 Penambahan di awal Penambahan di akhir Penambahan sebelum node tertentu Penambahan setelah node tertentu

83 Asumsi awal

84 Penambahan di Awal Pointer bantu : baru Langkah : – Baru.next = head – head.prev = Baru – head = baru

85 84 Penambahan di Awal(1) last

86 85 Penambahan di Awal(2) last

87 Penambahan di Awal(3) 86 last

88 87 Penambahan di Akhir Asumsi linked list awal : last

89 88 Penambahan di Akhir 1. Baru.prev = last last

90 89 Penambahan di Akhir 2. last.next = Baru last

91 90 Penambahan di Akhir 3. last = Baru last

92 Penambahan Setelah Node x Pointer bantu : after

93 92 Penambahan Setelah Node x Asumsi linked list awal : last

94 93 Penambahan Setelah Node x 1.Node after; after diarahkan ke posisi node 10, bisa dimulai dari head maupun last last

95 94 Penambahan Setelah Node x 2. Baru.prev = after last

96 95 Penambahan Setelah Node x 3. Baru.next = after.next last

97 96 Penambahan Setelah Node x 4. after.next.prev = Baru last

98 97 Penambahan Setelah Node x 5. after.next = Baru last

99 98 Penambahan Setelah Node x Hasil akhir : last

100 99 Penambahan Sebelum Node x Asumsi linked list awal : last

101 100 Penambahan Sebelum Node x 1.Node before; before diarahkan ke posisi node 5, bisa dimulai dari head maupun last last

102 101 Penambahan Sebelum Node x 2. Baru.prev = before.prev last

103 102 Penambahan Sebelum Node x 3. Baru.next = before last

104 103 Penambahan Sebelum Node x 4. before.prev.next = Baru last

105 104 Penambahan Sebelum Node x 5. before.prev = Baru last

106 105 Penambahan Sebelum Node x Hasil akhir : last

107 Penghapusan Node

108 107 Operasi Hapus Node (Delete) Hapus awal (Delete First) Hapus akhir (Delete Last) Hapus Node x

109 108 Asumsi Awal Asumsi linked list awal : last

110 109 Delete First 1. Node hapus; hapus = head; last

111 110 Delete First 2. head.next.prev = null last

112 111 Delete First 3. head = hapus.next last

113 112 Delete First last

114 113 Delete First Hasil akhir : last

115 114 Delete Last Asumsi linked list awal : last

116 115 Delete Last 1. Node hapus; hapus = last; last

117 116 Delete Last 2. last.prev.next = null last

118 117 Delete Last 3. last = hapus.prev last

119 118 Delete Last last

120 119 Delete Last Hasil akhir : last

121 120 Delete Node x Asumsi linked list awal :  Misalkan x = 3 last

122 121 Delete Node x 1.Node hapus; hapus diarahkan pada posisi node 3, bisa mulai dari head maupun last last

123 122 Delete Node x 2. hapus.prev.next = hapus.next; last

124 123 Delete Node x 3. hapus.next.prev = hapus.prev; last

125 124 Delete Node x last

126 Circular List

127 Definisi Circular List : list yang berbentuk cirrcular/melingkar, node depan terhubung dengan node paling belakang.

128 Linked List: Insertion Menyisipkan X pada lokasi setelah current. a b c d current a b x c d x

129 tmp = new ListNode (x, current.next); current.next = tmp; Langkah-langkah menyisipkan yang lebih efisien a b x current a b x

130 Pertanyaan: Selama ini contoh menyisipkan dan menghapus elemen dengan asumsi ada node current yang terletak sebelumnya. – Bagaimana menambahkan node pada urutan pertama pada linked list? – Bagaimana menghapus elemen pertama pada linked list?

131 Latihan Buatlah sebuah method untuk menghitung jumlah elemen dalam sebuah linked list! public static int listSize (LinkedList theList)‏ { }

132 Doubly-linked lists: Tiap list node menyimpan referensi node sebelum dan sesudahnya. Berguna bila perlu melakukan pembacaan linkedlist dari dua arah. Variasi Linked Lists A headtail prev next

133 Variasi Linked Lists Circular-linked lists: Node terakhir menyimpan referensi node pertama. Dapat diterapkan dengan atau tanpa header node. ABC first prev next

134 Doubly-linked lists: InsertNext newNode = new DoublyLinkedListNode(x); 1 newNode.prev = current; 2 newNode.prev.next = newNode; … x b a 1 2 ? current

135 Doubly-linked lists: insertNext 1 newNode = new DoublyLinkedListNode(x); 2 newNode.prev = current; 3 newNode.next = current.next; 4 newNode.prev.next = newNode; 5 newNode.next.prev = newNode; 6 current = newNode; AB current X prev next newNode

136 Doubly-linked lists: DeleteCurrent 1.current.prev.next = current.next; 2.current.next.prev = current.prev; 3.current = current.prev; x b a current 1 2 3

137 Rangkuman ListNode List, LinkedList dan variasinya Iterator class Kelebihan & kekurangan dari linked list – Growable – Overhead a pointer, new operator untuk membuat node. – Hanya bisa diakses secara sequential.

138 Gambaran abcde firstNode

139 Daftar Pustaka L.N. Harnaningrum, Struktur Data menggunakan Java, Graha ilmu, 2010 Siswanto, Algoritma & Struktur Data Linier, Graha Ilmu, 2010 Ruli Manurung, Ade Azurat, Struktur Data dan Algoritma, Fasilkom UI, 2008


Download ppt "Linear List Teknik Informatika Universitas Muhammadiyah Malang SP - 2013 Algoritma & Struktur Data."

Presentasi serupa


Iklan oleh Google