1 / 56

บทที่ 5 สแต๊ก ( Stacks ) (ส่วนที่ 2)

บทที่ 5 สแต๊ก ( Stacks ) (ส่วนที่ 2). By Juthawut Chantharamalee. Abstract Data Type ของสแต็ก ( Stack ADT ).

christmas
Télécharger la présentation

บทที่ 5 สแต๊ก ( Stacks ) (ส่วนที่ 2)

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. บทที่ 5 สแต๊ก (Stacks)(ส่วนที่ 2) By Juthawut Chantharamalee วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  2. Abstract Data Type ของสแต็ก (Stack ADT) ก่อนจะเข้าถึงเนื้อหาของเนื่องสแต็ก ADT จะขอทบทวนเพื่อสรุปโครงสร้างข้อมูลแบบสแต็กนั้นจะเป็นลิสต์ที่มีข้อจำกัดหลายประการดังเงื่อนไขต่อไปนี้ 1. การเพิ่มสมาชิกหรือข้อมูลจะสามารถจัดเก็บเรียงตามลำดับจากปลายด้านใดด้านหนึ่งเท่านั้น เช่น จากส่วนบนสุด หรือจากส่วนล่าสุด2. รายการเพิ่มข้อมูลเข้าไปจะอยู่บนสุด 3. เราสามารถเข้าถึงรายการข้อมูลในสแต็กได้ ณ ส่วนบนสุดเท่านั้น ไม่ว่าจะเป็นการอ่านข้อมูลด้วย Stack Top หรือนำข้อมูลออกด้วย Pop วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  3. 4. การดำเนินงานใดๆ บนสแต็กจะเป็นไปตามประสิทธิภาพของฟังก์ชันO(1) อัลกอริทึมแต่ละชนิดจากเนื้อหาข้างต้นที่ผ่านมา สามารถนำมาใช้เขียนโปรแกรมเพื่อดำเนินงานกับสแต็กได้อย่างหลากหลาย แต่สำหรับ เนื้อหาต่อไปนี้ ต้องการนำเสนอสแต็กในรูปแบบของ ADT เป็นสำคัญ เพื่อสามารถนำไปเก็บไว้ในไลบรารีเพื่อเรียกใช้งานได้ต้องการ โดยในที่จะพัฒนาสแต็ก ADT ด้วยการใช้โครงสร้างข้อมูลแบบลิงก์ลิสต์ วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  4. main Dynamic memory data stack N link count top dataPtr data link dataPtr . . data dataPtr link รูปที่ 5.13 แนวคิกโครงสร้างของสแต็ก ADT (Stack ADT Structural Concepts) วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  5. ทั้งโหนดส่วนหัวและโหนดข้อมูลจะถูกเก็บซ่อนรายละเอียดไว้ใน ADT การเรียกใช้ฟังก์ชันของสแต็ก ก็คือพอยน์เตอร์ที่ชี้ไปยังโครงสร้างสแต็กใน ADT นั้นเอง ส่วนการสร้างสแต็ก โปรแกรมเมอร์จะนิยามพอยน์เตอร์เพื่อชี้ไปยังสแต็ก ซึ่งแสดงได้จากตัวอย่างชุดคำสั่งด้านล่างต่อไปนี้ โดยโครงสร้างสแต็ก ADT ที่แสดงดังรูปที่ 5.13 จะทำให้เห็นภาพแนวคิดดังกล่าวได้ชัดเจนยิ่งขึ้น STACK* stack .. .. Stack = createStack (); วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  6. อย่างไรก็ตาม ยังมีสิ่งที่ต้องคำนึงนอกเหนือจากโครงสร้างข้อมูลที่นำมาสร้าง ADT จะต้องมีตัวดำเนินงานที่ใช้สนับสนุนการทำงานในแต่ละฟังก์ชันของสแต็กอย่างเพียงพอ เช่น การพัฒนาฟังก์ชันด้วยภาษา C ซึ่งประกอบด้วย Stack Definitions, Create Stack, Push Stack, Pop Stack, Stack Top, Empty Stack, Stack Count และ Destroy Stack ซึ่งแสดงได้ดังตัวอย่างต่อไปนี้ วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  7. 1 2 3 4 5 6 7 8 9 10 11 12 // Stack ADT Type Definitions typedef struct node { void* dataPtr; struct node* link; } STACK_NODE; typedef struc { int count ; STACK_NODE* top; } STACK; โปรแกรมที่ 5.1 Stack ADT Definitions วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  8. โปรแกรมที่ 5.2 Create Stack วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  9. โปรแกรมที่ 5.3 Push Stack วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  10. โปรแกรมที่ 5.4 Pop Stack วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  11. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 /*=================== stackTop =============== Retrieves data from the top of stack without changing the stack. Pre stack is a pointer to the stack Post Returns data pointer if successful null pointer if stack empty */ void* stackTop (STACK* stack) { // Statements if (stack->count == 0) return NULL; else return stack->top->dataPtr; } //stackTop โปรแกรมที่ 5.5 Retrieve Stack Top วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  12. 1 2 3 4 5 6 7 8 9 10 /*================= emptyStack ================== This function determines if a stack is empty. Pre stack is pointer to a stack Post Returns 1 if empty; 0 if data in stack */ bool emptyStack (STACK* stack) { // Statements return (stack->count == 0); } //emptyStack โปรแกรมที่ 5.6 Empty Stack วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  13. โปรแกรมที่ 5.7 Full Stack วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  14. 1 2 3 4 5 6 7 8 9 10 /*============= stackCount ============ Returns number of elements in stack. Pre stack is a pointer to the stack Post count returned */ int stackCount (STACK* stack) { // Statements return stack->count; } //stackCount โปรแกรมที่ 5.8 Stack Count วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  15. โปรแกรมที่ 5.9 Destroy Stack วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  16. การนำสแต็กไปประยุกต์ใช้กับโปรแกรมการนำสแต็กไปประยุกต์ใช้กับโปรแกรม โดยปกติการเขียนโปรแกรมมักเขียนในลักษณะโมดูลหรือโปรแกรมย่อย โดยโปรแกรมหลักจะทำการเรียกใช้โปรแกรมย่อยต่างๆ เพื่อใช้งาน ดังนั้นโครงสร้างข้อมูลแบบสแต็กจะสามารถนำมาประยุกต์ใช้เพื่อทำงานกับกรณีดังกล่าวได้เป็นอย่างดี โดยส่วนโปรแกรมที่มีการเรียกใช้งานโปรแกรมย่อย จะมีการ Push ลำดับคำสั่งที่ต้องการประมวลผลในลำดับถัดไว้ในสแต็ก วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  17. เพื่อจะได้สามารถรีเทิร์นกลับมาทำกลับมาทำงานต่อจากตัวที่เรียกได้ และเมื่อมีการประมวลผลชุดคำสั่งในโปรแกรมย่อยที่เรียกใช้งานจนเสร็จ ก็จะทำการ Pop ลำดับคำสั่งออกจากสแต็ก เพื่อจะได้กลับไปทำงานยังลำดับคำสั่งที่เรียกใช้โปรแกรมย่อยนั้นได้ต่อไป วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  18. Call Task A …….. …….. Task B …….. …….. Call Return Task C …….. …….. Call Return Task D …….. …….. Return รูปที่ 5.14 ตัวอย่างโปรแกรมแสดงลำดับการเรียกโปรแกรมย่อยเพื่อใช้งาน วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  19. จากรูปที่ 5.14 เป็นตัวอย่างโปรแกรมแสดงลำดับการเรียกโปรแกรมย่อยเพื่อใช้งาน โดยที่ Task A ได้เรียกใช้งาน Task B และ Task B ได้มีการเรียกใช้งาน Task C ในขณะที่ Task C ก็ได้เรียกใช้งาน Task D จนกระทั้งจบที่ Task D ก็มีการรีเทิร์นกลับไปยัง Task ก่อนหน้าที่เรียกใช้งาน จนกระทั้งจบโปรแกรม วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  20. C B B A A A (b) (a) (c) (d) B A A (e) (f) (g) รูปที่ 5.15 แสดงถึงโปรแกรมย่อยต่าง ที่ Push ลงในสแต็กและ Pop ออกจากสแต็กในแต่ละสถานการณ์ วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  21. การประยุกต์ใช้งานสแต็ก (Stack Applications) การเรียงลำดับข้อมูลแบบย้อนกลับ (Reversing Data) คือการจัดเรียงลำดับข้อมูลใหม่ ตัวอย่างเช่น ข้อมูลในสแต็กที่มีข้อมูลตัวเลขลำดับจาก Top ลงไปคือ {4 3 2 1} เมื่อมีการจัดเรียงใหม่ลงในสแต็กหนึ่งก็จะลำดับใหม่มาเป็น {1 2 3 4} เป็นต้น วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  22. Pop 4 1 3 2 2 3 4 1 Stack 2 Stack 1 รูปที่ 5.16 การเรียงลำดับข้อมูลย้อนกลับด้วยสแต็ก วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  23. การแตกข้อมูลออกเป็นส่วนๆ (Parsing) เป็นการแตกข้อมูลออกเป็นส่วนๆ ให้เป็นอิสระต่อกัน เพื่อส่งไปประมวลผล ตัวอย่างเช่น การแปลซอร์สโค้ดให้เป็นภาษาเครื่อง ซึ่งคอมไพเลอร์จะดำเนินการแตกโปรแกรมออกเป็นส่วนๆ ให้เป็นอิสระกัน เช่น คำสงวน ตัวแปร และโทเค้น (Tokens) เป็นต้น นอกจากนี้แล้ว การแตกข้อมูลออกเป็นส่วนยังสามารถนำไปใช้กับการตรวจสอบการจับข้อมูลของเครื่องหมายวงเล็บในนิพจน์คณิตศาสตร์ได้อีกด้วย วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  24. ? ( ( A + B ) / C (a) Opening parenthesis not matched ? ( A + B ) / C ) (b) Closing parenthesis not matched รูปที่ 5.17 การแตกข้อมูลออกเป็นส่วนๆ เพื่อตรวจสอบการจับข้อมูลของเครื่องหมายวงเล็บ วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  25. การหน่วงเวลา (Postponement) เป็นการหน่วงเวลาของข้อมูลไว้ชั่วขณะหนึ่ง เพื่อรอการประมวลผลในช่วงจังหวะเวลาที่เหมาะสม ซึ่งกรณีดังกล่าว จะนำไปใช้กับการแปลงนิพจน์ Infix มาเป็นนิพจน์ Postfix การย้อนรอย (Backtracking Steps) เป็นการย้อนรอยเพื่อไปยังสถานะก่อนหน้า รวมถึงการค้นหาเส้นทางการเดินทางเพื่อไปยังเป้าหมายปลายทาง (Goal Seeking) วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  26. 6 7 4 Star node 8 5 11 9 10 The goal 1 2 3 13 12 14 15 16 17 18 รูปที่ 5.18 การค้นหาเส้นทางการเดินทางเพื่อไปยังเป้าหมาย วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  27. นิพจน์ทางคณิตศาสตร์ 1. นิพจน์ Infix คือ นิพจน์โดยทั่วไปที่มักจะใช้กับการคำนวณสูตรตัวเลขต่างๆ โดยโอเปอเรเตอร์จะอยู่ระหว่างโอเปอแรนด์ 2. นิพจน์ Postfix คือ นิพจน์ในรูปแบบโอเปอเรเตอร์จะอยู่ข้างหลังตัว โอเปอแรนด์ 3. นิพจน์ Prefix คือ นิพจน์ในรูปแบบโอเปอเรเตอร์จะอยู่ข้างหน้าตัว โอเปอแรนด์ วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  28. Operator A + X1 * 2 Operand Prefix : +AB Infix : A+B Postfix : AB+ รูปที่ 5.19 นิพจน์คณิตศาสตร์ประกอบไปด้วยโอเปอเรเตอร์และโอเปอแรนด์ วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  29. การแปลงนิพจน์ Infix มาเป็น Postfix ด้วยมือ คอมไฟเลอร์หรือตัวแปลภาษายุคใหม่ในปัจจุบัน จะไม่สามารถแปลนิพจน์ Infix เป็นภาษาเครื่องได้โดยตรง อันเนื่องมาจากการจัดลำดับความสำคัญของโอเปอเรเตอร์ที่แตกต่างกันในนิพจน์ Infix จึงทำให้การคำนวณแต่ละเทอมในนิพจน์มาเป็นไปตามลำดับ และยิ่งสูตรการคำนวณที่ซับซ้อน ก็ยิ่งทวีความยุ่งยากให้กับคอมไพเลอร์ในการคำนวณหาผลลัพธ์มากเท่านั้น แต่อย่างไรก็ตามคอมไพเลอร์สามารถแก้ปัญหาโยการแปลงนิพจน์ Infix ให้มาเป็นนิพจน์แบบ Postfix หรือ Prefix เสียก่อน วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  30. กฎเกณฑ์สำหรับการแปลงนิพจน์ Infix มาเป็น Postfix ด้วยมือ 1. ให้ทำการใส่เครื่องหมายวงเล็บให้กับทุกๆ นิพจน์ด้วยการคำนึงถึงลำดับการคำนวณ เช่น เครื่องหมายคูณและหารต้องมาก่อนเครื่องหมายบวกและลบ เป็นต้น 2. ทำการเปลี่ยนสัญลักษณ์ Infix ในแต่ละวงเล็บให้มาเป็นสัญลักษณ์แบบ Postfix โดยให้เริ่มต้นจากนิพจน์ที่อยู่วงเล็บในสุดก่อน จากนั้นก็ดำเนินการแปลงเป็นนิพจน์ Postfix ด้วยการย้ายโอเปอเรเตอร์ตรงตำแหน่งวงเล็บนั้นไปยังตำแหน่งวงเล็บปิดของคู่นั้นๆ 3. ถอดเครื่องหมายวงเล็บออกทิ้งให้หมด วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  31. ตัวอย่างที่ 5.1 จงแปลงนิพจน์ A + B * C มาเป็น Postfix ด้วยมือ นิพจน์ Infix ที่ให้มา A + B * C ขั้นตอนที่ 1 ใส่วงเล็บให้ทั้งหมดตามลำดับความสำคัญ (A + (B * C)) ขั้นตอนที่ 2 พิจารณานิพจน์ที่อยู่ในวงเล็บในสุด โดยย้ายเครื่องหมาย * ไปข้างหลัง C (A + (BC*)) จากนั้นให้ย้ายโอเปอเรเตอร์ + ซึ่งอยู่ที่ตำแหน่งวงเล็บเปิดภายนอกของคู่ตัวเอง (A (BC*) + ) ขั้นตอนที่ 2 ถอดเครื่องหมายวงเล็บทิ้งออกให้หมด ABC*+ วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  32. ตัวอย่างที่ 5.2 จงแปลงนิพจน์ 5 + 6 - 10 มาเป็น Postfix ด้วยมือ 5 * 6 -10 = ((5 * 6)-10) = ((56*)- 10) = ((56*)10-) = 56*10- และจากนิพจน์ Postfix ที่ได้จากตัวอย่างที่ 5.2 นั้น คือผลลัพธ์จากการเรียงลำดับตามกฎเกณฑ์ของ postfix ดังนั้นคอมไพเลอร์ก็สามารถทำการคำนวณหาผลลัพธ์ได้อย่างง่ายดาย วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  33. Expression Action Stack 5 6 * 10 - Push 5 5 5 6 * 10 - Push 6 6 5 5 6 * 10 - Pop 6 and 5 Evaluate 5 * 6 Push 30 30 5 6 * 10 - Push 10 10 30 5 6 * 10 - Pop 10 and 30 Evaluate 30 - 10 Push 20 20 5 6 * 10 - Pop 20 Stack is Empty Result is 20 รูปที่ 5.20 แสดงการคำนวณหาผลลัพธ์นิพจน์ Postfix ในสแต็ก วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  34. อัลกอริทึมสำหรับการแปลงนิพจน์ Infix มาเป็น นิพจน์ Postfix (Algorithmic Transformation) อัลกอริทึมการแปลงนิพจน์ Infix มาเป็น Postfix มีขั้นตอนดังนี้ 1. ถ้าข้อมูลเข้ามาเป็นโอเปอแรนด์ ให้เอาต์พุตไป Postfix 2. ถ้าข้อมูลเข้าเป็นโอเปอเรเตอร์ - ถ้าสแต็กว่างให้ Push ลงในสแต็ก - ถ้าภายในสแต็กมีข้อมูลอยู่ ให้ทำการเปรียบเทียบ ดังนี้ -ถ้าโอเปอเรเตอร์ที่อินพุตเข้ามามีลำดับความสำคัญน้อยกว่า หรือ เท่ากับโอเปอเรเตอร์ที่อยู่ส่วนบนของสแต็ก ให้ดำเนินการ Pop วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  35. - สแต็กออกไปที่ Postfix โดยทำการเปรียบเทียบกับโอเปอเรเตอร์ ที่มีอยู่ในสแต็กไปเรื่อยๆ จนกระทั้งโอเปอเรเตอร์ที่อินพุตเข้ามามีลำดับความสำคัญมากกว่าโอเปอเรเตอร์ในสแต็ก จากนั้นดำเนินการ Push โอเปอเรเตอร์ที่อินพุตเข้ามาลงในสแต็ก 3. ถ้าข้อมูลเข้าเป็นเครื่องหมายวงเล็บเปิด ให้ดำเนินการ Push ลงในสแต็ก4. ถ้าข้อมูลเข้าเป็นเครื่องหมายวงเล็บปิด ให้ดำเนินการ Pop สแต็กไปยัง Postfix จนกระทั้งพบเครื่องหมายปิด จากนั้นให้นำเครื่องหมายวงเล็บทั้งสองลบทิ้งไป5. หากดำเนินการขนเสร็จสิ้นแล้วยังมีข้อมูลอยู่ในสแต็ก ให้ดำเนินการ Pop ที่เหลืออยู่ทั้งหมดไปยัง Postfix วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  36. Infix Stack Postfix (a) A A (b) + + A (c) B + A B (d) * * A B + (e) * * A B C + (f) - A B C * + - (g) D A B C * + D - (h) / / A B C * + D - (i) E / A B C * + D E - (j) A B C * + D E / - รูปที่ 5.21 การแปลงนิพจน์ Infix มาเป็นนิพจน์ Postfix วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  37. อัลกอริทึมที่ 5.9 การแปลงนิพจน์ Infix มาเป็น Postfix (Convert Infix to Postfix) วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  38. ตัวอย่างที่ 5.3 จงแปลง A * B –(C + D) ให้เป็น Postfix Input (Infix) Operator Stack Output String (Postfix) A A * * A B * A B - - A B * ( - ( A B * C -( A B * C + - ( + A B * C D - ( + A B * C D ) - A B * C D + + + A B * C D + - E + A B * C D + - E A B * C D + - E + วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  39. การผลลัพธ์จากนิพจน์ Postfix (Evaluation Postfix Expressions) หลักการหาผลลัพธ์จากนิพจน์ Postfix ก็คือ จะทำการสแกนนิพจน์ Postfix จากซ้ายไปขวา โดยโอเปอแรนด์ที่พบจะถูกใส่ไว้ในสแต็กเรื่อยๆ จนกระทั้งพบตัวโอเปอเรเตอร์ เมื่อพบแล้วจึงดำเนินการหาผลลัพธ์จากคู่โอเปอแรนด์ที่พบก่อนหน้า ผลการคำนวณจะเป็นไปตามขั้นตอนดังรูปที่ 5.22 ส่วนอัลกอริทึมการหาผลลัพธ์จากนิพจน์ Postfix แสดงไว้ในอัลกอริทึมที่ 5.10 ในที่นี้ขอยกตัวอย่างนิพจน์ Postfix เพื่อนำไปคำนวณหาผลลัพธ์ดังนี้ วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  40. A B C + * โดยที่ A=2 B = 4 และ C = 6 Postfix Stack (a) 2 4 6 + * (b) 4 6 + * 2 4 (c) 6 + * 2 6 (d) + * 4 2 4 * 6 = 10 (e) * 10 2 2 * 10 = 20 (f) 20 รูปที่ 5.22 การคำนวณหาผลลัพธ์ของนิพจน์ Postfix วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  41. Algorithm postFixEvaluate (expr) This algorithm evaluates a postfix expression and returns its value. Pre a valid expression Post postfix value computed Return value of expression 1 ereateStack (stack) 2 loop (for each character) 1 if (character is operand) 1 pushstaek (stack, character) 2 else 1 popStaek (stack, oper2) 2 popStack (stack, operl) 3 operator = character 4 set value to calculate (operl, operator, oper2) 5 pushstack (stack, value) 3 end if 3 end loop 4 popStack (stack, result) 5 return (result) end postFixEvaluate อัลกอริทึมที่ 5.10 การหาผลลัพธ์จากนิพจน์ Postfix (Evaluation of Postfix Expressions วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  42. อัลกอริทึมการสร้างสแต็กด้วยอาร์เรย์ (Stack Array Algorithm) สำหรับการสร้างสแต็กด้วยอาร์เรย์ในที่นี้ จะเริ่มต้นที่ลำดับที่ 0 (ในภาษา C) โดยภายในอาร์เรย์จะมีข้อมูลเพิ่มในกรณีที่มีการเพิ่มราบการข้อมูลเข้าไปด้วยฟังก์ชัน Push ในขณะที่ภายในอาร์เรย์จะมีข้อมูลลดน้อยลงเมื่อมีการนำข้อมูลออกไปด้วยฟังก์ชัน Pop และการ Push รายการเข้าไป ก็จะมีการเพิ่มตัวนับอีกตัวเข้าไป ซึ่งจะใช้ซับสคริปต์เป็นตัวอ้างอิงที่ส่วนบนสุดของสแต็ก และการ Pop ก็จะทำการคัดลอกข้อมูลข้อมูลตำแหน่งซับสคริปต์ที่อยู่ส่วนบนสุดของสแต็กไปยังโมดูลที่เรียกใช้แล้วจึงลดค่าของซับสคริปต์ลงอีกหนึ่งจากส่วนบนสุดลงมา วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  43. Algorithm createStack (stackElem <integer>) Allocates memory for a. stack head node from, dynamic memory and returns its address to the caller. Pre stackElem contains size of stack Post head node and array allocated or error returned Return pointer to head node or null pointer if no memory 1 if(memory not available 1 stackPtr = null ) 2 else } 1 allocate (stackPtr) Head allocated. Now initialize and allocate stack array. 2 stackPtr -> count = 0 3 stackPtr -> top = -1 4 stackPtr -> stackMax = stackElem 5 if (memory not available) 1 recycle (stackPtr) 2 stackPtr = null 6 else Allocate memory for stack array 1 allocate (stackPtr -> stackAry) 3 return stackPtr end createStack อัลกอริทึมที่ 5.11 Create Stack วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  44. Algorithm pushstack (val stack <head pointer>, val data <dataType>) Insert (push) one item into the stack. Pre stack is a pointer to the stack head structure data contains data to be pushed into stack Post data have been pushed in stack Return true if successful false if memory overflow 1 if (stack -> count is at maximum) 1 success = false 2 else 1 stack -> count = stack -> count + 1 2 stack -> top = stack -> top + 1 3 stack -> stack&Ary[stack -> top] = data 4 success = true 3 return success end pushstack อัลกอริทึมที่ 5.12 Push Stack วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  45. Algorithm popStack (val stack <head pointer>, ref dataOut <dataType>) This algorithm pops the item on the top of the stack and returns it to the user. Pre stack is a pointer to the stack head structure dataOut is a reference variable to receive the data Post data have been returned to calling algorithm Return true if successful false if underflow 1 if (stack empty) 1 success = false 2 else 1 dataOut = stack -> staek&ry [stack -> top] 2 stack -> top = stack -> top - 1 3 stack -> count = stack -> count - 1 4 success = true 3 return success end popStack อัลกอริทึมที่ 5.13 Pop Stack วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  46. Algorithm stackTop (val stack <head pointer>,ref dataOut <dataType>) This algorithm retrieves the data from the top of the stack without changing the stack. Pre stack is a pointer to the stack head structure Post data have been returned to calling algorithm Return true if data returned false if underflow 1 if (stack -> count zero) 1 success = false 2 else 1 dataOut = stack -> stack&ry [stack -> top].data 2 success = true 3 return success end stackTop อัลกอริทึมที่ 5.14 Stack Top วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  47. Algorithm emptyStack (val stack <head pointer>) Determines if stack is empty and return a Boolean. Pre stack is a pointer to the stack head structure Post returns stack status Return Boolean, true if stack empty false if stack contains data 1 if (stack -> count > 0) 1 result = false 2 else 1 result = true 3 return result end emptyStack อัลกอริทึมที่ 5.15 Empty Stack วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  48. Algorithm fullStack (val stack <head pointer>) Determines if stack is full and return a Boolean. Pre stack is a pointer to the stack head structure Post returns stack status Return Boolean, true if stack full false if memory available 1 if (stack -> count < MAX_STACK) 1 result = false 2 else 1 result = true 3 return result end fullStack อัลกอริทึมที่ 5.16 Full Stack วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  49. Algorithm stackCount (val stack <head pointer >) Return the number of elements currently in stack. Pre stack is a pointer to the stack head structure Post returns stack count Return integer count of number of elements in stack 1 return (stack -> count) end stackCount อัลกอริทึมที่ 5.17 Stack Count วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

  50. Algorithm destroyStack (val stack <typeStack>) This algorithm releases all nodes back to the dynamic memory. Pre stack is a pointer to the stack head structure Post head structure and array recycled Return null pointer 1 If (stack not empty) 1 recycle (stack -> stackAry) 2 recycle (stack) 2 return null pointer end destroyStack อัลกอริทึมที่ 5.18 Destroy Stack วิชาโครงสร้างข้อมูล (Data Structure) รหัส 4122202

More Related