สแตกและคิว (Stack & queue)
Download as PPT, PDF10 likes22,671 views
วิชาโครงสร้างข้อมูล
![ตัวอย่างการนำาข้อมูลเข้า
0
1
2
3
4
Top
90
1. Top = 0
2. Top = Top + 1
3. Stack[Top] = 10154060
Stack
Stack
Full](https://image.slidesharecdn.com/stackqueue-150127060308-conversion-gate02/85/Stack-queue-7-320.jpg)
![ตัวอย่างการนำาข้อมูลออก
Top
2. Top = Top - 1
1. Temp = Stack[Top]
0
1
2
3
4
Stack
Stack
Empty
Temp
10
15
40
60](https://image.slidesharecdn.com/stackqueue-150127060308-conversion-gate02/85/Stack-queue-9-320.jpg)
![การสร้างกองซ้อนด้วยแถวลำาดับ
เป็นการเตรียมเนื้อที่ในหน่วยความจำาไว้สำาหรับเก็บ
ข้อมูล
ตัวอย่างในภาษาซี คือ
int Stack[4];
การนำาข้อมูลเข้าและออกจากหน่วยความจำาด้วยแถว
ลำาดับ ก็เหมือนกับที่ยกตัวอย่างไปแล้ว
Stack](https://image.slidesharecdn.com/stackqueue-150127060308-conversion-gate02/85/Stack-queue-12-320.jpg)
![การตรวจสอบอักขระ
สมดุล(Balancing Symbol)
ในการตรวจสอบอักขระสมดุลนั้น คอมไพเลอร์
ได้นำาแนวคิดโครงสร้างข้อมูลแบบ Stack มา
ประยุกต์ โดยมีวิธีการดังนี้
1. ให้อ่านอักขระทีละตัว
- ถ้าอักขระเป็นอักขระเปิด เช่น {,(,[ เป็นต้น
ให้ PUSH ลง stack
- ถ้าอักขระเป็นอักขระปิด เช่น },),] เป็นต้น
ให้ตรวจสอบว่าอักขระบน TOP ของ stack เป็น
อักขระเปิดที่คู่กันหรือไม่
- ถ้าใช่ ให้ POP อักขระนั้นออกจาก stack
- ถ้าไม่ใช่ ให้แสดงผล error
2.เมื่ออ่านอักขระหมดแล้ว แต่ stack ไม่เป็น](https://image.slidesharecdn.com/stackqueue-150127060308-conversion-gate02/85/Stack-queue-33-320.jpg)
สแตกและคิว (Stack & queue)
- 1. Week 7 สแตกและคิว (Stack & Queue)
- 2. FIFO และ LIFO First In Fisrt Out : FIFO หมายถึงข้อมูลที่เข้ามาในลิสต์ ก่อน จะถูกนำาออกจากลิสต์เป็นลำาดับแรก เช่น การ ยืนรอคิวเพื่อซื้อตั๋ว Last In First Out : LIFO หมายถึงข้อมูลที่เข้ามาในลิสต์ เป็นลำาดับสุดท้าย จะถูกนำาออกจากลิสต์เป็นอันดับ แรก เช่น การนำาชั้นของปิ่นโตเข้าและออกจากเถา ปิ่นโต
- 3. สแตก(stack) เป็นโครงสร้างข้อมูลแบบเชิงเส้น ที่มี การใส่ข้อมูลเข้า และนำาข้อมูลออก เพียงด้านเดียว ดังนั้น ข้อมูลที่เข้าไป อยู่ใน stack ก่อนจะออกจาก stack หลังข้อมูลที่เข้าไปใน stack ทีหลัง นั่น คือ การ "เข้าทีหลังแต่ออกก่อน" (Last In First Out : LIFO)
- 4. การกระทำา(Operation) ที่เกี่ยวข้อง กับโครงสร้างข้อมูลแบบ Stack ปฏิบัติการพื้นฐานของสแตกได้แก่ push คือการนำา ข้อมูลเก็บในสแตก และ pop คือการนำาข้อมูลออก จากสแตก ซึ่งทั้งสองกระบวนการ จะกระทำาที่ส่วนบน สุดของสแตกเสมอ โดยปกติแล้วมักกำาหนดให้มีตัวชี้ ส่วนบนสุดของสแตก เรียกว่า top ส่วนปฏิบัติการ อื่น ๆ เป็นปฏิบัติการที่เกี่ยวเนื่องกับการ push และ pop มีดังนี้ การสร้างสแตก (CREATE) การทดสอบว่า stack ว่างหรือไม่(EMPTY) การทดสอบว่า stack เต็มหรือไม่(FULL) การทำาให้ stack เป็น stack ว่าง(CLEAR)
- 5. การนำาข้อมูลเข้าสู่สแตก (Push) กระทำาที่ส่วนบนของส แตก (Top) ซึ่งต้องมีการตรวจสอบก่อนว่าสแตกเต็ม หรือไม่ และการนำาข้อมูลออกจากสแตก (Pop) กระทำาที่ส่วนบน ของสแตกเช่นกัน โดยตรวจสอบว่ามีสมาชิกอยู่ในสแตกหรือ ไม่ (ตรวจสอบว่าสแตกว่างเปล่าหรือไม่)
- 6. การนำาข้อมูลเข้าไปในกองซ้อน (Push) เป็นการดำาเนินการที่นำาข้อมูลเข้าไปเก็บ ไว้ด้านบนสุดของกองซ้อน (Top of the Stack) เรื่อย ๆ จนกว่ากองซ้อนไม่ สามารถนำาข้อมูลเข้าไปเก็บได้ จะเรียกว่า กองซ้อนเต็ม (Stack Full)
- 7. ตัวอย่างการนำาข้อมูลเข้า 0 1 2 3 4 Top 90 1. Top = 0 2. Top = Top + 1 3. Stack[Top] = 10154060 Stack Stack Full
- 8. การนำาข้อมูลออกจากกองซ้อน (Pop) การทำางานจะตรงข้ามกับ Push จะดึงเอาข้อมูลที่อยู่บนสุดออกมาก่อน แต่ก่อนที่จะดึงจะ มีการตรวจสอบว่ากองซ้อนว่างหรือไม่ ถ้าว่างจะไม่สามารถนำาข้อมูลออกได้ แสดงว่ากองซ้อนว่าง (Stack Empty) ถ้าไม่ว่างจะนำาเอาข้อมูลออกแล้วเลื่อนตัว ชี้ไปยังตำาแหน่งถัดลงไป
- 9. ตัวอย่างการนำาข้อมูลออก Top 2. Top = Top - 1 1. Temp = Stack[Top] 0 1 2 3 4 Stack Stack Empty Temp 10 15 40 60
- 10. การสร้าง stack ด้วย Array หมายถึง การแทนที่ข้อมูลของ stack ด้วย array ซึ่ง เป็นการจัดสรร เนื้อที่หน่วยความจำาแบบ static นั่น คือ มีการกำาหนดขนาดของ stack ล่วง หน้าว่ามีขนาดเท่าใด และจะมีการ จัดสรรเนื้อที่หน่วยความจำาให้เลย
- 11. การแทนที่โครงสร้างข้อมูลแบบกองซ้อน ด้วยแถวลำาดับ แบบลำาดับจะต้องมีการจองพื้นที่หน่วยความจำาไว้ล่วงหน้า ว่าจะมี ขนาดเท่าใด โดยแถวลำาดับนี้จะปิดปลายด้านหนึ่งไว้ เพื่อให้ข้อมูลเข้า- ออกทางเดียว ปฏิบัติการมี 4 ขั้นตอนคือ การสร้าง การ Push การ Pop การ แสดง
- 12. การสร้างกองซ้อนด้วยแถวลำาดับ เป็นการเตรียมเนื้อที่ในหน่วยความจำาไว้สำาหรับเก็บ ข้อมูล ตัวอย่างในภาษาซี คือ int Stack[4]; การนำาข้อมูลเข้าและออกจากหน่วยความจำาด้วยแถว ลำาดับ ก็เหมือนกับที่ยกตัวอย่างไปแล้ว Stack
- 13. การแสดงข้อมูลที่อยู่ในกองซ้อนด้วย แถวลำาดับ จะเป็นการดึงข้อมูลตั้งแต่ตำาแหน่งแรกจนถึงตำาแหน่งที่ Top ชี้อยู่ออกมาแสดง หรือจะกลับกันคือ นำาข้อมูลจากตำาแหน่ง Top ชี้อยู่จนถึง ตำาแหน่งที่ 0 ออกมาแสดง
- 15. การสร้าง stack ด้วย Link List หมายถึง การแทนที่ข้อมูลของ stack ด้วย Link list ซึ่งเป็นการจัดสรรเนื้อที่ หน่วยความจำาแบบ Dynamic นั่นคือ หน่วยความจำาจะถูกจัดสรรเมื่อมีการของ ใช้จริงๆ ระหว่างการประมวลผล โปรแกรมผ่านตัวแปรชนิด Pointer
- 16. การแทนที่โครงสร้างข้อมูลกองซ้อน ด้วยรายการโยง เป็นการแทนที่ที่มีความยืดหยุ่นมาก เนื่องจากไม่ต้องกำาหนดหรือจองหน่วยความจำา ล่วงหน้า ข้อมูลที่เก็บในกองซ้อนมีจำานวนเท่าใดก็ได้ การปฏิบัติ การมี 4 ขั้นตอนคือ การสร้าง, การ Push, การ Pop และ การแสดง
- 17. การสร้างกองซ้อนด้วยรายการโยง ตัวอย่างกรณีที่เป็น รายการโยงแบบเดี่ยว การ สร้างจะเป็นดังนี้ typedef struct node { int data; struct node *Next; } node; node *Top; int info; data node Next
- 18. การนำาข้อมูลเข้าไปในกองซ้อนแบบ รายการโยง 80 ^ P Top 1. Top = Null 2. New(P) 3. Data(p) = 80 4. Next(p) = Null 5. Top = p
- 19. การนำาข้อมูลเข้าไปในกองซ้อนแบบ รายการโยง เพิ่มข้อมูล 90 เข้าไปในรายการโยง 80 ^ Top 1. New(P) 2. Data(P) = 90 3. Next(P) = Top 4. Top = p P 90Top
- 20. การนำาข้อมูลเข้าไปในกองซ้อนแบบ รายการโยง 80 ^ Top 1. New(P) 2. Data(P) = 120 3. Next(P) = Top 4. Top = p P 120Top 90
- 21. การนำาข้อมูลออกจากกองซ้อนด้วย รายการโยง 80 ^ TopTemp 120Top 90 1. Temp=Top 2. Top = Next(Top)
- 22. การนำาข้อมูลออกจากกองซ้อนด้วย รายการโยง TopTemp 90Top 80 1. Temp=Top 2. Top = Next(Top) ^
- 23. การนำาข้อมูลออกจากกองซ้อนด้วย รายการโยง Top = NULLTemp 80Top 1. Temp=Top 2. Top = Next(Top)
- 24. การนำาข้อมูลออกจากกองซ้อนด้วย รายการโยง Top = NULL 1. Temp=Top Stack Empty
- 25. การแสดงข้อมูลที่อยู่ในกองซ้อนด้วย รายการโยง 80 ^ P 120Top 90 P P 120 90 80
- 26. การประยุกต์ใช้ stack โครงสร้างข้อมูลแบบ stack มีการประยุกต์ใช้มากใน การเขียนโปรแกรมของสาขาวิทยาการคอมพิวเตอร์ เช่น การจัดสรรหน่วยความจำาในการประมวลผล โปรแกรม การตรวจสอบอักขระสมดุล(Balancing Symbol) และการคำานวณนิพจน์คณิตศาสตร์
- 27. การเรียกใช้โปรแกรมย่อย การเรียกโปรแกรมย่อยมีความแตกต่างกับการกระ โดดทั่วไป เนื่องจากภายหลังที่โปรแกรมย่อยทำางาน เสร็จ หน่วยประมวลผลจะต้องสามารถกระโดดกลับมา ทำางานในโปรแกรมหลักต่อไปได้ ดังนั้นการเรียกใช้ โปรแกรมย่อยนั้นจะต้องมีการเก็บตำาแหน่งของ คำาสั่งที่ทำางานอยู่เดิมด้วย และเมื่อจบโปรแกรม ย่อยโปรแกรมจะต้องกระโดดกลับมาทำางานที่เดิม โดยใช้ข้อมูลที่เก็บไว้ ภาพและอัลกอริทึมแสดงตัวอย่าง การเรียกใช้โปรแกรมย่อย
- 28. PROGRAM MAIN ...... CALL Sub1 PRINT Q .... END MAIN PROCEDURE Sub1 .... CALL Sub2 A:=A+B ... END Sub1 PROCEDURE
- 30. การเรียกใช้ โปรแกรมอื่น Stack ----- Call B ----- Call C สิ้นสุดโปรแกรม ----- Call B1 ----- Return ----- ----- Return ----- ----- Return 1000 1500 B B1 C 1000 1500
- 31. Factorial สัญลักษณ์แฟกตอเรียลเขียนเป็น n! 0! = 1 1! = 1 2! = 2 x 1 3! = 3 x 2 x 1 n! = n x (n-1) x (n-2) x …x 2 x 1
- 32. 3! 0 1 2 3 4 Top 3 2 1 Stack 3! = 3 * 2! 2! = 2 * 1! 1! = 1 * 0! 0! = 1 Push Pop 1! = 1 * 1 2! = 2 * 1 3! = 3 * 2
- 33. การตรวจสอบอักขระ สมดุล(Balancing Symbol) ในการตรวจสอบอักขระสมดุลนั้น คอมไพเลอร์ ได้นำาแนวคิดโครงสร้างข้อมูลแบบ Stack มา ประยุกต์ โดยมีวิธีการดังนี้ 1. ให้อ่านอักขระทีละตัว - ถ้าอักขระเป็นอักขระเปิด เช่น {,(,[ เป็นต้น ให้ PUSH ลง stack - ถ้าอักขระเป็นอักขระปิด เช่น },),] เป็นต้น ให้ตรวจสอบว่าอักขระบน TOP ของ stack เป็น อักขระเปิดที่คู่กันหรือไม่ - ถ้าใช่ ให้ POP อักขระนั้นออกจาก stack - ถ้าไม่ใช่ ให้แสดงผล error 2.เมื่ออ่านอักขระหมดแล้ว แต่ stack ไม่เป็น
- 34. โพลิช โนเตชัน(Polish Notation) เป็นวิธีการจัดรูปแบบของสมการใหม่ โดยการย้าย ตำาแหน่งของเครื่องหมายและตัวดำาเนินการ เช่น 2*3 เขียนเป็น *23 เป็นต้น โดยมีรูปแบบการเขียนสมการ ดังนี้ Prefix : การเขียนสมการโดยให้เครื่องหมายอยู่หน้าตัว ดำาเนินการ เช่น * + 5 3 2 Infix : การเขียนสมการโดยให้เครื่องหมายอยู่ระหว่างตัว ดำาเนินการ เช่น (5+3)*2 Postfix : การเขียนสมการโดยให้เครื่องหมายอยู่หลังตัว ดำาเนินการ เช่น 5 3 + 2 *
- 35. Algorithm การคำานวณแบบ Postfix ให้อ่านข้อมูลจากซ้ายไปขวาทีละตัว ถ้าพบตัวถูกดำาเนินการ(ตัวเลข) ให้ push stack ถ้าพบตัวดำาเนินการ(เครื่องหมาย) ให้ pop item บนสุดของ stack 2 ตัว แล้วทำาการคำานวณตาม เครื่องหมายที่พบ แล้วนำาผลลัพธ์ที่ได้ push stack ทำาซำ้าจนกระทั่งหมดข้อมูล
- 37. วิธีการเปลี่ยน Infix เป็น Postfix Algorithm การเปลี่ยน Infix เป็น Postfix ให้ EXP เป็นสมการคณิตศาสตร์ที่เป็น Infix และ Stack เป็น stack ใด ๆ NEXP เป็นสมการที่เป็น Postfix 1. ใส่ “(“ เข้าไปใน Stack 2. อ่าน EXP จากซ้ายไปขวา 2.1 ถ้าพบตัวถูกดำาเนินการ(ตัวเลข) ให้ใส่เข้าไป ใน NEXP 2.2 ถ้าพบ “(“ ให้ push ใส่ stack
- 38. วิธีการเปลี่ยน Infix เป็น Postfix 2.3 ถ้าพบตัวดำาเนินการ(เครื่องหมาย) ให้ทำาดังนี้ - ให้ pop ตัวดำาเนินการ ทุกตัวที่มีลำาดับความสำาคัญ กว่าตัวดำาเนินการที่พบใน 2.3 ออกมาใส่ใน NEXP ให้หมด - นำาตัวดำาเนินการที่พบใน 2.3 push เข้าใน stack แทนที่ 2.4 ถ้าพบ “)” ให้ทำาดังนี้ - ให้ push ตัวดำาเนินการ ทุกตัวมาใส่ไว้ใน NEXP ให้ หมดจนพบ “(“ - push “(“ ทิ้ง 3. จบการทำางาน
- 39. ความสำาคัญของตัวดำาเนินการ เครื่องหมาย ความสำาคัญ เมื่ออยู่ ในStack ความสำาคัญ เมื่ออยู่ที่ อินพุต ** (ยกกำาลัง) 3 4 * , / 2 2 + , - 1 1 ( 0 3
- 40. A + B เครื่องห มาย Stack นิพจน์ Postfix A + B ว่าง + + A A AB AB+
- 41. A + B * C เครื่องหมาย Stack นิพจน์ Postfix A + B * C ว่าง + + + , * + , * A A AB AB ABC ABC*+
- 42. (A + B) * C เครื่องหมาย Stack นิพจน์ Postfix ( A + B ) * C ( ( (+ (+ ว่าง * * ว่าง A A AB AB+ AB+ AB+C AB+C*
- 43. ((10/2-2)*2+2)
- 44. 8*(4+3)-9/6 เครื่องหมาย Stack นิพจน์ Postfix 8 * ( 4 + 3 ) - 9 / 6 ว่าง ว่าง * *( *( *(+ *(+ * - - - / - / 8 8 8 8 4 8 4 8 4 3 8 4 3 + 8 4 3 + * 8 4 3 + * 9 8 4 3 + * 9 8 4 3 + * 9 6 8 4 3 + * 9 6 / -
- 45. ลองทำาดู จงเปลี่ยนนิพจน์อินฟิกซ์ ต่อไปนี้ให้เป็นโพสฟิกซ์ 1. ((A+B)*C)-D 2. A*C/D 3. 10+15*20/6 4. 5*4+(8/2) 5. 10/(2+3)+(5+6)*9 6. A*(B-C/D)+E