งานนำเสนอกำลังจะดาวน์โหลด โปรดรอ

งานนำเสนอกำลังจะดาวน์โหลด โปรดรอ

คืออะไร ? คือ queue ที่ access element ตามความสำคัญของตัว element นั้น เช่นคนป่วยขาหักกับหลังหัก ถึง คนหลังหักมาทีหลังก็ควรถูก รักษาก่อน ( ไม่งั้นได้เผาก่อนแน่

งานนำเสนอที่คล้ายกัน


งานนำเสนอเรื่อง: "คืออะไร ? คือ queue ที่ access element ตามความสำคัญของตัว element นั้น เช่นคนป่วยขาหักกับหลังหัก ถึง คนหลังหักมาทีหลังก็ควรถูก รักษาก่อน ( ไม่งั้นได้เผาก่อนแน่"— ใบสำเนางานนำเสนอ:

1

2 คืออะไร ? คือ queue ที่ access element ตามความสำคัญของตัว element นั้น เช่นคนป่วยขาหักกับหลังหัก ถึง คนหลังหักมาทีหลังก็ควรถูก รักษาก่อน ( ไม่งั้นได้เผาก่อนแน่ ) Printer queue จำนวนหน้าน้อย ควรได้ก่อน

3 Priority โดยทั่วไป ค่าน้อยถือว่าสำคัญกว่า ค่ามาก ( มี priority สูงกว่านั่นเอง ) ถ้าสองตัวมีค่าเท่ากัน ก็น่าจะให้ตัวที่ อยู่ในคิวมานานกว่าได้ไป การเปรียบเทียบค่า เราใช้ Comparable interface หรือ Comparator interface

4 Comparator interface เหมือน Comparable เพียงแต่มี int compare(Object o1, Object o2) ต้องเป็น class เดียวกัน หรือ เป็นsubclass กัน ไม่งั้น throw CastCastException

5 ตัว interface // Postcondition: รีเทิร์นจำนวนสมาชิก ใน priority queue นี้ // Postcondition: รีเทิร์น true ถ้า priority queue นี้ไม่มีสมาชิก // ไม่งั้นก็รีเทิร์น false // Postcondition: element จะถูกเติมลง ใน priority queue

6 // Precondition: ต้องไม่เป็นคิวที่ว่าง ไม่งั้นจะ throw // NoSuchElementException // Postcondition: รีเทิร์นออบเจ็คต์ตัวที่สำคัญที่สุดใน PriorityQueue นี้ // Precondition: ต้องไม่เป็นคิวที่ว่าง ไม่งั้นจะ throw // NoSuchElementException // Postcondition: เอาออบเจ็คต์ตัวที่สำคัญที่สุดใน PriorityQueue นี้ // ออกจากคิวและรีเทิร์นออบเจ็คต์นี้เป็นคำตอบของเมธอด ด้วย

7 วิธีการ implement มีหลาย วิธี ใช้คิวธรรมดา จะไม่ได้ prioriry อาร์เรย์ของคิว ก็ไม่ได้เพราะ priority อาจเยอะมาก ใช้ ArrayList เรียงสมาชิก getMin จะเป็น constant time add กับ removeMin จะใช้ linear time - ซึ่งยัง ช้าไป

8 วิธีการ implement ( ต่อ ) ใช้ LinkedList getMin กับ removeMin เป็น constant time add จะเป็น linear time Ok รับได้ ลองทำดู

9 ใช้ Comparable โดย default

10

11

12 ทำไม?

13 ทำไมต้อง previous ? ถ้าเรามี 1,2,4,5 และต้องการ add 3 Loop จะหยุดเมื่อ itr.next() เป็น 4 แต่ตัว iterator ได้เลื่อนไปที่ 5 ซะแล้ว ดังนั้น ต้อง previous() กลับมา ก่อนที่จะใส่ 3

14 protected int compare (Object elem1, Object elem2) { return (comparator==null ? ((Comparable)elem1).compareTo(elem2) : comparator.compare (elem1, elem2)); } // method compare ถ้า comparator = null, return elem1.compareTo (elem2) ; ถ้าไม่งั้น return comparator.compare (elem1, elem2) ;

15 คราวนี้ใช้เซตบ้าง ดูแผ่นถัดไป

16

17 public void add (Object element) { set.add (element); } // method add public Object getMin ( ) { return set.first( ); } // method getMin public Object removeMin ( ) { Object temp = set.first( ); set.remove (set.first( )); return temp; } // method removeMin ทั้ง 3 method นี้มี worstTime(n) เป็น LOGARITHMIC ของ n.

18 อีกวิธีนึง คราวนี้ใช้ Heap ppublic class Heap implements PriorityQueue { ยังไม่อยู่ใน JAVA COLLECTIONS FRAMEWORK

19 Complete Binary tree ยังจำได้ หรือไม่

20 Heap คือ complete binary tree ซึ่งเป็น empty tree หรือ สมาชิกใน root มีค่าน้อยที่สุด ( เรียกว่า minHeap) และ left กับ right subtree ก็เป็น heap ด้วย ( ไม่ใช่ binary search tree นะ )

21

22 Complete binary tree เอาใส่ อาร์เรย์ได้ ง่ายต่อการหา child, parent

23 ก่อนอื่นดูการใช้ Heap (GPA น้อยสุดถือว่า highest priority)

24

25

26 // มี constructor ที่รับ string เป็น input และก็มีเมธอด toString ด้วย เวลาทำอย่าลืม // Postcondition: รีเทิร์นจำนวนเต็มที่ 0 ขึ้นอยู่กับว่า GPA ของ // this Student ออบเจ็คต์นั้นน้อยกว่า เท่ากัน หรือมากกว่า GPA ของ o1

27 คราวนี้ดู Heap เลย

28 index ของลูกได้แบบนี้

29 index ของพ่อได้แบบนี้

30 ดู method ใน Heap

31 ถ้าเต็มอาร์เรย์ ก็ขยาย //เติมลงไปท้ายอาร์เรย์ //แล้วค่อยปรับเลื่อนตำแหน่งขึ้นมา // Postcondition: element ถูกเติมเป็นสมาชิกของ heap // เวลา worst case = O(n) // ส่วนเวลาเฉลี่ยเป็นค่าคงที่ ขึ้นกับเวลา percolateUp

32 สมมติว่าเราจะเติม 30 ลงไป 30

33 Percolate up คือ... สลับที่ 30 กับพ่อของ เขาเรื่อยๆจนกว่าตัว พ่อจะน้อยกว่า พอทำ เสร็จเราก็จะได้ heap

34

35

36 protected void percolateUp() { int parent; int child = size-1; Object temp; while (child>0) { parent = (child-1)/2; if(compare(heap[parent],heap[child]) <=0) break; temp = heap[parent]; heap[parent] = heap[child]; heap[child] = temp; child = parent; } // while } // method percolateUp ความสูงของต้นไม้ เพราะเวลาแย่สุดเกิด ตอนที่ต้องเลื่อนจนถึง ยอด // Postcondition: จัด heap โดยเลื่อนตัวท้ายสุดขึ้นต้นไม้ เวลาที่ แย่ที่สุดจะเป็น //O(log n) ส่วนเวลาเฉลี่ยจะเป็นค่าคงที่

37 Average time -percolateUp ก็ต้องให้ครึ่งหนึ่งของสมาชิก ทั้งหมดมีค่ามากกว่าตัวใหม่ แต่ครึ่งที่มากก็เป็นใบแน่ๆ ฉะนั้นในการสลับที่ขึ้นเพื่อให้ เป็น heap ก็ใช้ไม่กี่ขั้นตอน – constant time

38 public Object getMin() { if (size == 0) throw new NoSuchElementException( “ Empty ” ); return heap[0]; } // method getMin

39 removeMin() ถ้าไม่ระวัง เสียความเป็น complete binary tree งั้นทำไงดี??

40 //เอาท้ายอาร์เรย์ใส่ที่ root //แล้วค่อยปรับเลื่อนตำแหน่ง // Precondition: ต้องไม่เป็นคิวที่ว่าง ไม่งั้นจะ throw // NoSuchElementException // Postcondition: เอาออบเจ็คต์ตัวที่สำคัญที่สุดใน PriorityQueue นี้ // ออกจากคิวและรีเทิร์นออบเจ็คต์นี้เป็นคำตอบของเมธอด ด้วย // เวลาที่แย่ที่สุดจะเป็น O(log n) ขึ้นกับ percolateDown

41 เมื่อ removeMin( ) ถูกเรียก 48 จะถูกสลับกับ 26 ส่วน size ก็จะถูกลดไปหนึ่ง จากนั้นก็จะ percolateDown

42 PercolateDown คือ สลับ 48 กับลูกที่น้อย ที่สุด ทำจนกว่าจะสลับไม่ได้ พอทำเสร็จเราก็จะได้ heap

43

44

45

46 protected void percolateDown(int start) { int parent = start; int child = 2*parent+1; Object temp; while (child

47 ลองทำดู

48

49 มาดูปัญหา จะ compress file โดยไม่ให้เสีย ข้อมูลไปเลยได้อย่างไร ให้ M เป็น ข้อมูลที่เราต้องการ compress สมมติว่ามันมีขนาด character โดยประกอบไป ด้วย a ถึง e เท่านั้น ให้ E คือ version ที่ compress แล้ว

50 มาดูปัญหา ( ต่อ ) โดยปกติ 1 character จะใช้ 16 bit ฉะนั้น character -_- ’’ ก็คูณเข้า ไปดิ ต้องหาทางลดจำนวน bit

51 ลองทำดู จำนวน bit ก็จะเหลือ 3 แสน

52 ลดได้อีกไหม ? จำนวน bit ก็จะน้อยกว่า3แสน แต่ อาจเป็นได้ทั้ง aababa หรือ cbda ก็ได้

53 แล้วจะให้ไม่มั่วได้ไง ใช้ prefix-free encoding โดยสร้าง binary tree กิ่งซ้ายถือเป็น 0 กิ่งขวาถือเป็น 1 ให้ character อยู่ที่ใบ

54 จะไม่มี character ที่อยู่ path เดียวกันจากรากแน่นอน a = 010 b = 11 c = 00 d = 10 e = 011

55 ทำได้อีกแบบนะเนี่ย แล้วแบบไหนดี? ขึ้นกับว่า character นั้นเกิดบ่อยไหม bit เยอะไม่ควรเกิดบ่อย

56 สร้าง Huffman tree ซึ่งก็คือ binary tree ของรหัสนี่ แหละ แต่ว่าสร้างโดยดูจาก ความถี่ในการเกิดของแต่ละ character เพื่อให้ตัวอักษรที่มีความถี่มาก ในข้อความของเรา ใช้จำนวน bit น้อยที่สุด

57 สมมติมีความถี่แบบนี้ a มี 5000 b มี c มี d มี e มี 34000

58 เอาคู่ (character, ความถี่ ) ใส่ Priority Q Priority Q ที่ใช้ ให้ถือว่าความถี่ต่ำอยู่ บนสุด แต่ละ node ของ priority Q ก็มี left, right, parent ของมันเอง ตอนแรก คิวของเราจะเป็น (a:5000) (b: 10000) (c: 20000) (d: 31000) (e: 34000) ต่อไป สร้าง Huffman tree ล่ะ

59 เอาสองตัวที่น้อยสุดออกจากคิว ตัวแรกเอามาเป็นกิ่งซ้าย ตัวที่ สองมาเป็นกิ่งขวา ส่วนผลบวก ของความถี่เราเอามาเป็นราก a b จากนั้นก็เอาผลใส่กลับลงใน priority Q ซึ่งจะกลายเป็น ( :15000) (c: 20000) (d: 31000) (e: 34000) 0 1

60 เอาสองตัวที่น้อยสุดออกจากคิว ทำเหมือนเดิม a b c เมื่อเอาต้นไม้นี้กลับเข้า priority Q ตัวคิวจะกลายเป็น (d: 31000) (e: 34000) ( : 35000)

61 เอาสองตัวที่น้อยสุดออกจากคิว ทำเหมือนเดิม d e นี่กลายเป็นอีก tree หนึ่งเลย เมื่อเอาต้นไม้นี้กลับเข้า priority Q ตัวคิวจะกลายเป็น ( : 35000) ( : 65000)

62 เอาสองตัวสุดท้ายออกจากคิว ทำเหมือนเดิม priority Q จะ กลายเป็น (: ) a b c d e

63 ลองทำดู

64 Huffman เป็น Greedy Algorithm เราเลือกสิ่งที่ดีที่สุดในระบบ ย่อย ในที่นี้คือเอา min ออก จาก tree มีผลต่อระบบใหญ่ ทำให้ได้ optimal solution ไปด้วย ในที่นี้ คือได้ prefix-free code ที่ดีสุด

65 Huffman class จะเปลี่ยน input ที่ได้ให้เป็นรหัส Huffman ก่อนอื่นดู Entry ก่อนละกัน

66

67 ต่อไปก็ทำอาร์เรย์ของใบ เพื่อให้ access ได้เร็ว

68 ตัวอย่างเช่น c มี index 99 นี่คือหนึ่ง Entry

69 // Postcondition: ‘ This ’ Huffman object ถูก initialize // Postcondition: ไฟล์ ที่ถูกกำหนดโดย s ถูกจัดการเรียบร้อย // Postcondition: priority queue ถูกสร้างจากข้อมูลของ input //file โดยเวลา worst case = O(n)

70 // Postcondition: สร้าง huffman tree เวลา worst case นั้นคงที่ // Postcondition: คำนวณ huffman code ของแต่ละตัวอักษร // เวลา worst case นั้นคงที่ // Postcondition: Huffman codes และข้อความที่แปลงแล้วถูกจัดเก็บใส่ไฟล์ // เวลา worst case นั้น = O (n).

71 Fields ใน Huffman class Gui priority queue file reader file writer input file name เก็บเพื่อให้เปิดไฟล์ได้ 2 ที คำนวณความถี่ encode ตัวข้อมูล boolean บอกว่ากำลังอ่านไฟล์ไหนอยู่

72

73 Method processInput สร้าง priority Q สร้าง Huffman tree สร้างตัวรหัส เก็บรหัสและตัวข้อความที่แปลง แล้วลงไฟล์

74 Method createPQ สร้าง leafEntries update freq field ของแต่ละ Entry หลังจากนั้นก็สร้าง priority queue จากการดู freq

75 Method createHuffmanTree Loop จนกว่า size ของ priority queue จะเหลือ 1 ทำเหมือนที่บอกไปแล้วเป๊ะๆ

76 Method calculateHuffmanCodes Loop บน leafEntries แต่ละ Entry นั้น มีตัวแปรซึ่งเป็น empty string ดู parent แล้ว เติมเลขที่กำกับ parent ลงไปข้างหน้าของ string เรื่อยๆ ( ภาษาอังกฤษเรียก prepend) ไล่ดูไปจนถึง root

77 ตัวอย่างการสร้างรหัส ถ้ามีต้นไม้แบบ ซ้ายมือนี้ ดูหน้าถัดไป

78 รหัสของ f f มีค่า int เป็น 102 ดังนั้นเราจึง set ค่า leafEntries[102].code = “ 1010 ” ; ลูปบันทึกย้อนจากใบต้นไม้

79 Method saveToFile Loop บน leafEntries ส่ง character กับ code ของมันไปที่ไฟล์ แล้วก็อ่าน input file อีกที รหัสของ input จะถูกสร้างขึ้น และ save ไว้ใน ไฟล์

80 ดู web เพิ่มได้

81 ถ้ามี output file มา ลองสร้าง Huffman tree ดูและบอกข้อความที่ แท้จริง

82 จบเรื่อง priority queue


ดาวน์โหลด ppt คืออะไร ? คือ queue ที่ access element ตามความสำคัญของตัว element นั้น เช่นคนป่วยขาหักกับหลังหัก ถึง คนหลังหักมาทีหลังก็ควรถูก รักษาก่อน ( ไม่งั้นได้เผาก่อนแน่

งานนำเสนอที่คล้ายกัน


Ads by Google