วันพฤหัสบดีที่ 15 ตุลาคม พ.ศ. 2552
ลูกแรดเตรียมพร้อมล่าเหยื่อ
DTS 11-16-09-2552
การค้นหา คือ การใช้วิธีการค้นหากับโครงสร้างข้อมูล เพื่ือดูว่าข้อมูลตัวที่ต้องการถูกเก็บอยู่ในโครงสร้างแล้วหรือยัง
การค้นหาข้อมูล searching แบ่งเป็น 2 ประเภท
1.การค้นหาข้อมูลแบบภายใน
2.การค้นหาข้อมูลแบบภายนอก
การค้นหาแบบเชิงเส้นหรือการค้นหาตามลำดับ (Linear)
เป็นวิธีการที่ใช้กับข้อมูลที่ยังไม่ได้เรียงลำดับ มีวิธีโดยการนำข้อมูลที่ต้องการหามาเปรียบเทียบกับข้อมูลตัวเเรกในแถวลำดับ ถ้าค่าข้อมูลที่ต้องการหาไม่ตรงกับค่าข้อมูลในแถวลำดับก็ทำการค้นหาไป เรื่อยๆ จนเจอค่าข้อมูลที่ต้องการจึงจะหยุดการค้นหา หรือจะหยุด
การค้นหาก็ต่อเมื่อไม่พบค่าข้อมูลการค้นหาแบบเซนทินัล (Sentinel)
มีลักษณะเช่นเดียวกับการค้นหาแบบเชิงเส้น แต่ประสิทธิภาพดีกว่าตรงที่เปรียบเทียบค่าน้อยครั้งกว่าการค้นหาแบบเชิงเส้น มีวิธีโดยการเพิ่มพื้นที่ที่เก็บข้อมูลอีก 1 ที่ แล้วนำข้อมูลที่ต้องการค้นหาไปใส่ไว้ที่ต้น หรือท้ายอาเรย์ แล้วทำการตรวจสอบ ถ้าตำแหน่งที่พบเท่ากับ n-1 แสดงว่าหาข้อมูลไม่พบ นอกนั้นถือว่าพบข้อมูลที่ต้องการค้นหา
การค้นหาแบบไบนารี (Binary Search)
จะใช้กับข้อมูลที่เรียงลำดับแล้วเท่านั้น โดยแบ่งข้อมูลออกเป็นสองส่วน การค้นหาเป็นวิธีค้นหาที่ไปยังค่ากลางเพื่อตรวจสอบหรือเปรียบเทียบว่าใช่ ข้อมูลที่ต้องค้นหาหรือไม่ และจะละทิ้งข้อมูลส่วนหน้าหรือส่วนหลังขึ้นอยู่กับว่าข้อมูลที่ต้องการค้นหา มีค่ามากกว่า หรือน้อยกว่าข้อมูลค่ากลาง
วันเสาร์ที่ 12 กันยายน พ.ศ. 2552
DTS 10-09-09-2552
กราฟมีน้ำหนัก หมายถึง กราฟที่ทุกเอดจ์ มีค่าน้ำหนักกำกับ ซึ่งค่าน้ำหนักอาจสื่อถึงระยะทาง เวลา ค่าใช้จ่าย เป็นต้น นิยมนำไปใช้แก้ปัญหาหลัก ๆ 2 ปัญหา คือ
1. การสร้างต้นไม้ทอดข้ามน้อยที่สุด(Minimum Spanning Trees :MST)
1. เรียงลำดับเอดจ์ ตามน้ำหนัก
2. สร้างป่าที่ประกอบด้วยต้นไม้ว่างที่มีแต่โหนด และไม่มีเส้นเชื่อม
3. เลือกเอดจ์ที่มีน้ำหนักน้อยที่สุดและยังไม่เคยถูกเลือกเลย ถ้ามีน้ำหนักซ้ำกันหลายค่าให้สุ่มมา 1เส้น
4. พิจารณาเอดจ์ที่จะเลือก ถ้านำมาประกอบในต้นไม้ทอดข้ามน้อยที่สุดแล้วเกิด วงรอบ ให้ตัดทิ้งนอกนั้นให้นำมาประกอบเป็นเอดจ์ในต้นไม้ทอดข้ามน้อยที่สุด
5. ตรวจสอบเอดจ์ที่ต้องอ่านในกราฟ ถ้ายังอ่านไม่หมดให้ไปทำข้อ 3
2. การหาเส้นทางที่สั้นที่สุด (Shortest path) Dijkstra’s Algorithm
หาเส้นทางที่สั้นที่สุดจากโหนดต้นทางไปโหนดใด ๆ ในกราฟ มีน้ำหนัก และน้ำหนักไม่เป็นลบ
ข้อกำหนด
ให้ เซต S เก็บโหนดที่ผ่านได้และมีระยะทางห่างจากจุดเริ่มต้นสั้นที่สุดให้ W แทนโหนด นอกเซต Sให้ D แทนระยะทาง (distance) ที่สั้นที่สุดจากโหนดต้นทางไปโหนดใด ๆ ในกราฟ โดยวิถีนี้ประกอบด้วย โหนดในเชตให้ S ถ้าไม่มีวิถี ให้แทนด้วยค่าอินฟินีตี้ (Infinity) : ∞
(1)การเรียงลำดับแบบภายใน (internal sorting)เป็นการเรียงลำดับที่ข้อมูลทั้งหมดต้องอยู่ในหน่วยความจำหลัก เวลาที่ใช้ในการเรียงลำดับจะคำนึงถึงเวลาที่ใช้ในการเปรียบเทียบและเลื่อนข้อมูลภายในความจำหลัก
(2) การเรียงลำดับแบบภายนอก(external sorting) เป็นการเรียงลำดับข้อมูลที่เก็บอยู่ในหน่วยความจำสำรอง ซึ่งเป็นการเรียงลำดับข้อมูลในแฟ้มข้อมูล (file) เวลาที่ใช้ในการเรียงลำดับต้องคำนึงถึงเวลาที่เสียไประหว่างการถ่ายเทข้อมูลจากหน่วยความจำหลักและหน่วยความจำสำรองนอกเหนือจากเวลาที่ใช้ในการเรียงลำดับข้อมูลแบบภายในการเรียงลำดับแบบเลือก (selection sort)ทำการเลือกข้อมูลมาเก็บในตำแหน่งที่ ข้อมูลนั้นควรจะอยู่ทีละตัว โดยทำการค้นหาข้อมูลนั้นในแต่ละรอบแบบเรียงลำดับ
เป็นวิธีที่ง่าย แต่เสียเวลาในการจัดเรียงนาน โดยจะทำการเลือกข้อมูลมาเก็บไว้ตามตำแหน่งที่กำหนด คือ กำหนดให้เรียงข้อมูลจากค่าน้อยไปหาค่ามาก ก็จะทำการเลือกข้อมูลตัวที่มีค่าน้อยที่สุดมาอยู่ที่ตำแหน่งแรกสุด และค่าที่อยู่ตำแหน่งแรกก็จะมาอยู่แทนที่ค่าน้อยสุด แล้วทำการเลือกไปเรื่อยๆ จนครบทุกค่า ค่าที่ได้ก็จะเรียงจากน้อยไปหามาก
1. เริ่มต้นเปรียบเทียบจากข้อมูลในตำแหน่งที่ 1 กับ 2หรือข้อมูลในตำแหน่งสุดท้ายและรองสุดท้ายก็ได้ถ้าเป็นการเรียงลำดับจากน้อย ไปมาก
2. จะต้องจัดให้ข้อมูลที่มีค่าน้อยอยู่ในตำแหน่งก่อนข้อมูลที่มีค่ามาก และถ้าเรียงจากมากไปน้อยก็จะจัดให้ข้อมูลที่มีค่ามากอยู่ในตำแหน่งก่อน
เป็นวิธีที่พิจารณาเลขที่ละหลัก โดยจะพิจารณาเลขหลักหน่วยก่อน แล้วทำการจัดเรียงข้อมูลทีละตัวตามกลุ่มหมายเลข จากนั้นนำข้อมูลที่จัดเรียงในหลักหน่วยมาจัดเรียงในหลักสิยต่อไปเรื่อยๆจนครบทุกหลัก ก็จะได้ข้อมูลที่ต้องการ การเรียงลำดับแบบฐานไม่ซับซ้อน แต่ใช้เนื้อที่ในหน่วยความจำมาก
วันอาทิตย์ที่ 6 กันยายน พ.ศ. 2552
DTS 09-02-09-2552
เป็นการนำเอาโครงสร้างทรีไปใช้เก็บนิพจน์ทางคณิตศาสตร์โดยเป็นไบนารีทรี ซึ่งแต่ละโหนดเก็บตัวดำเนินการ (Operator) และและตัวถูกดำเนินการ (Operand) ของนิพจน์คณิตศาสตร์นั้น ๆ ไว้ หรืออาจจะเก็บค่านิพจน์ทางตรรกะ (Logical Expression) นิพจน์เหล่านี้เมื่อแทนในทรีต้องคำนึงลำดับขั้นตอนในการคำนวณตามความสำคัญของเครื่องหมายด้วย โดยมีความสำคัญตามลำดับดังนี้
1.ฟังก์ชัน
2.วงเล็บ
3.ยกกำลัง
4.เครื่องหมายหน้าเลขจำนวน (unary)
5.คูณ หรือ หาร
6.บวก หรือ ลบ
7.ถ้ามีเครื่องหมายที่ระดับเดียวกันให้ทำจากซ้ายไปขวา
การแทนนิพจน์ในเอ็กซ์เพรสชันทรี ตัวถูกดำเนินการจะเก็บอยู่ที่โหนดใบ ส่วนตัวดำเนินการจะเก็บในโหนดกิ่ง หรือโหนดที่ไม่ใช่โหนดใบ เช่น นิพจน์ A + B สามารถแทนในเอ็กซ์เพรสชันทรีได้ดังนี้
ตัวอย่างเอ็กซ์เพรสชันทรี
ไบนารีเซิร์ชทรี (Binary Search Tree)
เป็นไบนารีทรีที่มีคุณสมบัติที่ว่าทุก ๆ โหนดในทรี ค่าของโหนดรากมีค่ามากกว่าค่าของทุกโหนดในทรีย่อยทางซ้าย และมีค่าน้อยกว่าหรือเท่ากับค่าของทุกโหนดในทรีย่อยทางขวา และในแต่ละทรีย่อยก็มีคุณสมบัติเช่นเดียวกัน ค่าข้อมูลในทรีย่อยทางซ้าย < ค่าข้อมูลที่โหนดราก < ค่าข้อมูลในทรีย่อยทางขวา
ปฏิบัติการในไบนารีเซิร์ชทรี
ปฏิบัติการเพิ่มโหนดเข้า หรือดึงโหนดออกจากไบนารีเซิร์ชทรี ค่อนข้างยุ่งยากกว่าปฏิบัติการในโครงสร้างอื่น ๆ เนื่องจากหลังปฏิบัติการเสร็จเรียบร้อยแล้ว ต้องคำนึงถึงความเป็นไบนารีเซิร์ชทรีของทรีนั้นด้วย ซึ่งมีปฏิบัติการดังต่อไปนี้
1. การเพิ่มโหนดในไบนารีเซิร์ชทรี การเพิ่มโหนดใหม่เข้าไปในไบนารีเซิร์ชทรี ถ้าทรีว่างโหนดที่เพิ่มเข้าไปก็จะเป็นโหนดรากของทรี ถ้าทรีไม่ว่างต้องทำการตรวจสอบว่าโหนดใหม่ที่เพิ่มเข้ามานั้นมีค่ามากกว่าหรือน้อยกว่าค่าที่โหนดราก ถ้ามีค่ามากกว่าหรือเท่ากันจะนำโหนดใหม่ไปเพิ่มในทรีย่อยทางขวา และถ้ามีค่าน้อยกว่านำโหนดใหม่ไปเพิ่มในทรีย่อยทางซ้าย ในทรีย่อยนั้นต้องทำการเปรียบเทียบในลักษณะเดียวกันจนกระทั่งหาตำแหน่งที่ สามารถเพิ่มโหนดได้ ซึ่งโหนดใหม่ที่เพิ่มในทรีในที่สุดจะต้องเป็นโหนดใบ
2. การดึงโหนดในไบนารีเซิร์ชทรี หลังจากดึงโหนดที่ต้องการออกจากทรีแล้ว ทรีนั้นต้องคงสภาพไบนารีเซิร์ชทรีเหมือนเดิมก่อนที่จะทำการดึงโหนดใด ๆ ออกจากไบนารีเซิร์ชทรี ต้องค้นหาก่อนว่าโหนดที่ต้องการดึงออกอยู่ที่ตำแหน่งไหนภายในทรี และต้องทราบที่อยู่ของโหนดแม่โหนดนั้นด้วย แล้วจึงทำการดึง
โหนดออกจากทรีได้ ขั้นตอนวิธีดึงโหนดออกอาจแยกพิจารณาได้ 3 กรณีดังต่อไปนี้
ก. กรณีโหนดที่จะดึงออกเป็นโหนดใบ การดึงโหนดใบออกในกรณีนี้ทำได้ง่ายที่สุด โดยการดึงโหนดนั้นออกได้ทันที เนื่องจากไม่กระทบกับโหนดอื่นมากนัก วิธีการก็คือให้ค่าในลิงค์ฟิลด์ของโหนดแม่ซึ่งเก็บที่อยู่ของโหนดที่ต้องการดึงออกให้มีค่าเป็น Null
ข. กรณีโหนดที่ดึงออกมีเฉพาะทรีย่อยทางซ้ายหรือทรีย่อยทางขวาเพียงด้านใดด้านหนึ่ง วิธีการดึงโหนดนี้ออกสามารถใช้วิธีการเดียวกับการดึงโหนดออกจากลิงค์ลิสต์ โดยให้โหนดแม่ของโหนดที่จะดึงออกชี้ไปยังโหนดลูกของโหนดนั้นแทน
ค. กรณีโหนดที่ดึงออกมีทั้งทรีย่อยทางซ้ายและทรีย่อยทางขวา ต้องเลือกโหนดมาแทนโหนดที่ถูกดึงออก โดยอาจจะเลือกมาจากทรีย่อยทางซ้ายหรือทรีย่อยทางขวาก็ได้
- ถ้าโหนดที่มาแทนที่เป็นโหนดที่เลือกจากทรีย่อยทางซ้าย ต้องเลือกโหนดที่มีค่ามากที่สุดในทรีย่อยทางซ้ายนั้น
- ถ้าโหนดที่จะมาแทนที่เป็นโหนดที่เลือกมาจากทรีย่อยทางขวา ต้องเลือกโหนดที่มีค่าน้อยที่สุดในทรีย่อยทางขวานั้น
กราฟ(Graph)
กราฟ เป็นโครงสร้างข้อมูลแบบไม่ใช่เชิงเส้นที่ประกอบด้วยกลุ่มของสิ่งสองสิ่งคือ
1. โหนด (nodes) หรือ เวอร์เทกซ์ (vertexes)
2. เส้นเชื่อมระหว่างโหนด เรียก เอ็จ (edges)
กราฟที่มีเอ็จเชื่อมระหว่างโหนดสองโหนด ถ้าเอ็จไม่มีลำดับความสัมพันธ์จะเรียกกราฟนั้นว่า กราฟแบบไม่มีทิศทาง (undirected graphs) และถ้ากราฟนั้นมีเอ็จที่มีลำดับความสัมพันธ์หรือมีทิศทางกำกับด้วยเรียกกราฟนั้นว่า กราฟแบบมีทิศทาง (directed graphs) บางครั้งเรียกว่า ไดกราฟ (digraph)
โดยทั่ว ๆ ไปการเขียนกราฟเพื่อแสดงให้เห็นความสัมพันธ์ของสิ่งที่เราสนใจแทนโหนดด้วย จุด (pointes) หรือวงกลม (circles) ที่มีชื่อหรือข้อมูลกำกับ เพื่อบอกความแตกต่างของแต่ละโหนด และเอ็จแทนด้วยเส้นหรือเส้นโค้งเชื่อมต่อระหว่างโหนดสองโหนด ถ้าเป็นกราฟแบบมีทิศทางเส้นหรือเส้นโค้งต้องมีหัวลูกศรกำกับทิศทางของความสัมพันธ์ด้วย
** กราฟแบบไม่มีทิศทางเป็นเซตแบบจำกัดของโหนดและเอ็จ โดยเซตอาจจะว่างไม่มีโหนดหรือเอ็จเลยเป็นกราฟว่าง (empty graph) แต่ละเอ็จจะเชื่อมระหว่างโหนดสองโหนด หรือเชื่อมตัวเอง เอ็จไม่มีทิศทางกำกับ ลำดับของการเชื่อมต่อกันไม่สำคัญ นั่นคือไม่มีโหนดใดเป็นโหนดแรก (first node) หรือไม่มีโหนดเริ่มต้นไม่มีโหนดใดเป็นโหนดสิ้นสุด
**ส่วนกราฟแบบมีทิศทาง เป็นเซตแบบจำกัดของโหนดและเอ็จ โดยเซตอาจจะว่างไม่มีโหนดหรือเอ็จเลยเป็นกราฟว่าง (empty graph) แต่ละเอ็จจะเชื่อมระหว่างโหนดสองโหนด เอ็จมีทิศทางกำกับแสดงลำดับของการเชื่อมต่อกัน โดยมีโหนดเริ่มต้น (source node) และโหนดสิ้นสุด (target node)
การแทนกราฟในหน่วยความจำ
ในการปฏิบัติการกับโครงสร้างกราฟ สิ่งที่เราต้องการจัดเก็บจากกราฟโดยทั่วไปก็คือ เอ็จ ซึ่งเป็นเส้นเชื่อมระหว่างโหนดสองโหนด มีวิธีการจัดเก็บหลายวิธี วิธีที่ง่ายและตรงไปตรงมาที่สุดคือ การเก็บเอ็จในแถวลำดับ 2 มิติ
กราฟที่มีการเปลี่ยนแปลงตลอดเวลา อาจจะใช้วิธีแอดจาเซนซีลิสต์ (adjacency list) ซึ่งเป็นวิธีที่คล้ายวิธีจัดเก็บกราฟด้วยการเก็บโหนดและพอยน์เตอร์ แต่ต่างกันตรงที่แทนที่จะเก็บโหนดที่มีความสัมพันธ์ด้วยไว้ในแถวลำดับ 1 มิติ จะใช้ลิงค์ลิสต์แทนเพื่อความสะดวกในการเปลี่ยนแปลงแก้ไข
นอกจากนี้ยังมีวิธีแทนกราฟในความจำหลักอีกวิธีหนึ่งซึ่งเป็นที่นิยมใช้กันมากที่สุดคือ การแทนด้วยแอดจาเซนซีเมทริกซ์ (adjacency matrix)
การท่องไปในกราฟ
การท่องไปในกราฟ (graph traversal) คือ กระบวนการเข้าไปเยือนโหนดในกราฟ โดยมีหลักในการทำงานคือ แต่ละโหนดจะถูกเยือนเพียงครั้งเดียว สำหรับการท่องไปในทรีเพื่อเยือนแต่ละโหนดนั้นจะมีเส้นทางเดียว แต่ในกราฟระหว่างโหนดอาจจะมีหลายเส้นทาง ดังนั้นเพื่อป้องกันการท่องไปในเส้นทางที่ซ้ำเดิมจึงจำเป็นต้องทำเครื่องหมายมาร์คบิตบริเวณที่ได้เยือนเสร็จเรียบร้อยแล้วเพื่อไม่ให้เข้าไปเยือนอีก สำหรับเทคนิคการท่องไปในกราฟมี 2 แบบดังนี้
1. การท่องแบบกว้าง (breadth first traversal) วิธีนี้ทำโดยเลือกโหนดที่เป็นจุดเริ่มต้น ต่อมาให้เยือนโหนดอื่นที่ใกล้กันกับโหนดเริ่มต้นทีละระดับจนกระทั่งเยือนหมดทุกโหนดในกราฟ
2.การท่องแบบลึก (depth first traversal) การทำงานคล้ายกับการท่องทีละระดับของทรี โดยกำหนดเริ่มต้นที่โหนดแรกและเยือนโหนดถัดไปตามแนววิถีนั้นจนกระทั่งนำไปสู่ปลายวิถีนั้น จากนั้น ย้อนกลับ (backtrack) ตามแนววิถีเดิมนั้น จนกระทั่งสามารถดำเนินการต่อเนื่องเข้าสู่แนววิถีอื่น ๆ เพื่อเยือนโหนดอื่น ๆ ต่อไปจนครบทุกโหนด
วันเสาร์ที่ 29 สิงหาคม พ.ศ. 2552
DTS 08-26-08-2552
1. นิยามทรีด้วยนิยามของกราฟทรี คือ กราฟที่ต่อเนื่องโดยไม่มีวงจรปิด loop ในโครงสร้าง โหนดสองโหนดใดๆ ในทรีต้องมีทางติดต่อกันทางเดียวเท่านั้น และทรีที่มี N โหนด ต้องมีกิ่งทั้งหมด N-1 เส้น
2. นิยามทรีด้วยรูปแบบรีเคอร์ซีฟทรี ประกอบด้วยสมาชิกที่เรียกว่า โหนด โดยที่ถ้าว่าง ไม่มีโหนดใดๆ เรียกว่านัลทรี (Null Tree) และถ้ามีโหนหนึ่งเป็นโหนดราก ส่วนที่เหลือจะแบ่งเป็นทรีย่อย (Sub Tree)
1. ฟอร์เรสต์ (Forest)หมายถึง กลุ่มของทรีที่เกิดจากการเอาโหนดรากของทรีออกหรือ เซตของทรีที่แยกจากกัน(Disjoint Trees)
2. ทรีที่มีแบบแผน (Ordered Tree)หมายถึง ทรีที่โหนดต่าง ๆ ในทรีนั้นมีความสัมพันธ์ที่แน่นอน เช่น ไปทางขวาไปทางซ้าย เป็นต้น
3. ทรีคล้าย (Similar Tree) คือทรีที่มีโครงสร้างเหมือนกัน หรือทรีที่มีรูปร่างของทรีเหมือนกัน โดยไม่คำนึงถึงข้อมูลที่อยู่ในแต่ละโหนด
4. ทรีเหมือน (Equivalent Tree) คือทรีที่เหมือนกันโดยสมบูรณ์ โดยต้องเป็นทรีที่คล้ายกันและแต่ละโหนดในตำแหน่งเดียวกันมีข้อมูลเหมือนกัน
5. กำลัง (Degree) หมายถึงจำนวนทรีย่อยของโหนด นั้น ๆ
6. ระดับของโหนด (Level of Node) คือระยะทางในแนวดิ่งของโหนดนั้น ๆ ที่อยู่ห่างจากโหนดราก เมื่อกำหนดให้ โหนดรากของทรีนั้นอยู่ระดับ 1และกิ่งแต่ละกิ่งมีความเท่ากันหมด คือ ยาวเท่ากับ 1หน่วย ซึ่งระดับของโหนดจะเท่ากับจำนวนกิ่งที่น้อยที่สุดจากโหนดรากไปยังโหนดใด ๆ บวกด้วย 1และจำนวนเส้นทางตามแนวดิ่งของโหนดใด ๆ ซึ่งห่างจากโหนดราก เรียกว่า ความสูง (Height) หรือความลึก (Depth)
1.โหนดแต่ละโหนดเก็บพอยเตอร์ชี้ไปยังโหนดลูกทุกโหนด ซึ่งจะทำให้ฟิลด์มีจำนวนเท่ากัน มีขนาดเท่ากับโหนดที่มีลูกมากที่สุด โหนดที่ไม่มีลูกใส่ค่า Null แล้วให้ลิงค์ฟิลด์เก็บค่าพอยเตอร์ของโหนดลูกตัวถัดไปเรื่อยๆ เช่น ลิงค์ฟิลด์แรกเก็บค่าพอยเตอร์ชี้ไปยังโหนดลูกลำดับแรก แต่การแทนที่ทรีด้วยวิธีนี้เป็นการสิ้นเปลืองเนื้อที่โดยใช่เหตุเนื่องจากว่าโหนดบางโหนดอาจมีโหนดลูกน้อย หรือไม่มีโหนดลูกเลย
2.แทนทรีด้วยไบนารีทรี จะมีการกำหนดโหนดทุกโหนดให้มีจำนวนลิงค์ฟิลด์เพียงสองลิงค์ฟิลด์ โดยลิงค์ฟิลด์แรกเก็บที่อยู่โหนดลูกคนโต ลิงค์ฟิลด์ที่สองเก็บที่อยู่โหนดพี่น้อง กรณีไม่มีโหนดลูกและโหนดพี่น้องใส่ Null การแทนที่ทรีด้วยวินี้เป็นการประหยัดเนื้อที่ได้มาก
ไบนารีทรีแบบสมบูรณ์นั้นจะมีโหนดทรีย่อยทางด้านซ้ายและขวา ยกเว้นโหนดใบหรือโหนดที่ไม่มีลูก แต่โหนดใบจะต้องอยู่ในระดับเดียวกัน
1.ให้โหนดแม่ชี้ไปยังโหนดลูกคนโตแล้วตัดความสัมพันธ์ระหว่างโหนดลูกอื่นๆ
2.เชื่อมความสัมพันธ์ระหว่างโหนดพี่น้อง
3.ให้ทรีย่อยทางขวาเอียงลงมา 45 องศา
วันเสาร์ที่ 8 สิงหาคม พ.ศ. 2552
DTS 07-05-08-2552
คิว(Queue) จะมีโครงสร้างแบบเชิงเส้น และอันดับของการนำสมาชิกเข้าออกจากคิวมีความ สำคัญ คือ สมาชิกที่เข้าไปอยู่ในคิวก่อนจะออกจากคิวก่อนสมาชิกที่เข้าไปในคิวทีหลัง นั่นคือการเข้าก่อนออกก่อน ( First In First Out หรือ FIFO )
Queue จะมีงานหลัก ๆ ที่ต้องทำงานอยู่ด้วยกัน 2 อันก็คือ
1.ใส่ข้อมูลลงไปใน Queue เราเรียกว่า “Enqueue”
2.เอาข้อมูลออกจาก Queue เพื่อนำไปใช้ เราเรียกว่า “Dequeue”
ใช้ตัวชี้ 2 ตัวคือ front กับ rear ดังนั้นถ้า Enqueue คือเอาเข้า ก็ต้องเอามาต่อ rear คือข้างหลังถ้า Dequeue คือเอาออก ก็ต้องเอาตรง front ออกไป เพราะมันเข้ามาก่อน
การแทนที่ข้อมูลของคิว มี 2 วิธี คือ
1.การแทนที่ข้อมูลของคิวแบบอะเรย์ ซึ่งเป็นการจัดสรรเนื้อที่หน่วยความจำแบบสแตติก นั่นคือ มีการกำหนดขนาดของคิวล่วงหน้าว่ามีขนาดเท่าใดและจะมีการจัดสรรเนื้อที่หน่วยความจำให้เลย
2.1. Head Node มี 3 ส่วน มีพอยเตอร์ 2 ตัว และ จำนวนสมาชิก
2.2. Data Node จะมีข้อมูล และ พอยเตอร์ชี้ตัวถัดไป
1.Create Queue คือการสร้างคิวขึ้นมา แล้วจัดสรรหน่วยความจำให้กับ Head Node และพอยเตอร์มีค่าเป็น Null
2.Enqueue คือ การเพิ่มข้อมูลลงไปในคิวโดยการเพิ่มจะเพิ่มจากส่วนท้าย
3.Dequeue คือ การนำข้อมูลในคิวออก จะออกโดยข้อมูลที่เข้าไปตัวแรกจะออกก่อน
4.Queue Front คือ การนำข้อมูลตัวแรกที่เข้าไปในคิวออกมาแสดง
5.Queue Rear คือ การนำข้อมูลตัวสุดท้ายที่เข้ามาในคิวออกมาแสดง
6.Empty Queue คือ เป็นการตรวจสอบว่าคิวนั้นยังคงว่างอยู่หรือไม่
7.Full Queue คือ เป็นการตรวจสอบว่าคิวนั้นเต็มหรือไม่
8.Queue Count คือ เป็นการนับจำนวนข้อมูลที่อยูในคิว ว่ามีจำนวนเท่าไร
9.Destroy Queue คือ การลบข้อมูลที่อยูในคิวทิ้ง
วันอังคารที่ 4 สิงหาคม พ.ศ. 2552
DTS 06-29-07-2552
สแตค (Stack) ต่อ
1. การแทนที่ข้อมูลของสแตกแบบลิงค์ลิสต์
2. การแทนที่ข้อมูลของสแตกแบบอะเรย์
การแทนที่ข้อมูลของสแตกแบบลิงค์ลิสต์
การแทนสแตกด้วยโครงสร้างแบบลิงค์ลิสต์นั้น ไม่มีข้อจำกัดของขนาดของสแตกและหน่วยความจำจะถูกใช้ก็ต่อเมื่อมีข้อมูลจริงๆ แล้วเท่านั้น ซึ่งทำให้ประหยัดเนื้อที่ในหน่วยความจำมากกว่า แต่การเขียนโค้ดสำหรับการแทนที่ข้อมูลสแตกด้วยอะเรย์ง่ายกว่าการแทนที่ข้อมูลด้วยลิงค์ลิสต์
การแทนที่ข้อมูลของสแตกด้วยอาร์เรย์
การแทนสแตกด้วยโครงสร้างอาร์เรย์นั้น เนื่องจากอาร์เรย์เป็นโครงสร้างที่ต้องมีการกำหนดจองพื้นที่เท่ากับขนาดที่ใหญ่ที่สุด(static) จึงจำเป็นต้องมีการกำหนดขนาดพื้นที่จัดเก็บข้อมูลสูงสุดให้เหมาะสมเมื่อมีการนำเอาข้อมูลเข้ามาก็จะนำเข้ามาจัดไว้ในอาร์เรย์แรกสุดจากนั้นจึงเรียงลำดับกันไปตามพื้นที่ที่กำหนด
การดำเนินการเกี่ยวกับสแตกการดำเนินการเกี่ยวกับสแตก ได้แก่
1. Create Stack จัดสรรหน่วยความจำให้แก่ Head Nodeและส่งค่าตำแหน่งที่ชี้ไปยัง Head ของสแตกกลับมา
2.Push Stack การเพิ่มข้อมูลลงไปในสแตก
3.Pop stack การนำข้อมูลบนสุดออกจากสแตก
4. Stack Top เป็นการคัดลอกข้อมูลที่อยู่บนสุดของสแตกโดยไม่มีการลบข้อมูลออกจากสแตก
5.Empty Stack เป็นการตรวจสอบการวางของสแตกเพื่อไม่ให้เกิดความผิดพลาดในการนำข้อมูลออกจากสแตกที่เรียกว่า Stack Underflow
6. Full Stack เป็นการตรวจสอบว่าสแตกเต็มหรือไม่เพื่อไม่ให้เกิดความผิดพลาดในการนำข้อมูลเข้าสแตกที่เรียกว่า Stack Overflow
7. Stack Count เป็นการนับจำนวนสมาชิกในสแตก8.Destroy Stack เป็นการลบข้อมูลทั้งหมดที่อยู่ใน สแตก8.Destroy Stack เป็นการลบข้อมูลทั้งหมดที่อยู่ใน สแตก
การใช้ สแตค เพื่อแปลรูปนิพจน์ทางคณิตศาสตร์
รูปแบบนิพจน์ทางคณิตศาสตร์
• นิพจน์ Infix คือ นิพจน์ที่เครื่องหมายดำเนินการ (Operator) อยู่ระหว่างตัวดำเนินการ (Operands) เช่น A+B-C
• นิพจน์ Prefix คือ นิพจน์ที่เครื่องหมายดำเนินการ (Operator) อยู่หน้าตัวดำเนินการ (Operands) เช่น +-AB
• นิพจน์ Postfix คือ นิพจน์ที่เครื่องหมายดำเนินการ (Operator) อยู่หลังตัวดำเนินการ (Operands) เช่น AC*+
ลำดับการทำงานของตัวดำเนินการทางคณิตศาสตร์ (Operator Priority)
มีการลำดับความสำคัญของตัวดำเนินการจากลำดับสำคัญมากสุดไปน้อยสุด คือ ลำดับที่มีความสำคัญมากที่ต้องทำก่อน ไปจนถึงลำดับที่มีความสำคัญน้อยสุดที่ไว้ทำทีหลัง ดังนี้
1.ทำในเครื่องหมายวงเล็บ
2.เครื่องหมายยกกำลัง ( ^ )
3.เครื่องหมายคูณ ( * ) , หาร ( / )
4.เครื่องหมายบวก ( + ) , ลบ ( - )
แปลงนิพจน์ Infix ให้เป็น Postfix ได้ดังนี้
1. ถ้าข้อมูลเข้า (input) เป็นตัวถูกดำเนินการ (operand) ให้นำออกไปเป็นผลลัพธ์ (output)
2. ถ้าข้อมูลเข้าเป็นตัวดำเนินการ (operator) ให้ดำเนินการดังนี้
2.1 ถ้าสแตคว่าง ให้ push operator ลงในสแตค2.2 ถ้าสแตคไม่ว่าง ให้เปรียบเทียบ operator ที่เข้ามากับ operator ที่อยู่ในตำแหน่ง TOP ของสแตค
2.2.1 ถ้า operator ที่เข้ามามีความสำคัญมากกว่า operator ที่ตำแหน่ง TOP ของสแตคให้ push ลงสแตค2.2.2 ถ้า operator ที่เข้ามามีความสำคัญน้อยกว่าหรือเท่ากับ operator ที่อยู่ในตำแหน่ง TOP ของสแตค ให้ pop สแตคออกไปเป็นผลลัพธ์ แล้วทำการเปรียบเทียบ operator ที่เข้ามากับ operator ที่ตำแหน่ง TOP ต่อไป จะหยุดจนกว่า operator ที่เข้ามาจะมีความสำคัญมากกว่า operator ที่ตำแหน่ง TOP ของสแตค แล้วจึง push operator ที่เข้ามานั้นลงสแตค
3. ถ้าข้อมูลเข้าเป็นวงเล็บเปิด ให้ push ลงสแตค
4. ถ้าข้อมูลเข้าเป็นวงเล็บปิด ให้ pop ข้อมูลออกจากสแตคไปเป็นผลลัพธ์จนกว่าจะถึงวงเล็บ เปิด จากนั้นทิ้งวงเล็บเปิดและปิดทิ้งไป
5. ถ้าข้อมูลเข้าหมด ให้ pop ข้อมูลออกจากสแตคไปเป็นผลลัพธ์จนกว่าสแตคจะว่าง
วันอังคารที่ 28 กรกฎาคม พ.ศ. 2552
การบ้านstdio.h และ iostream.h
main()
{
char fruit[20];
float price;
float kilogram;
float total;
printf("----- Fruit Shop -----\n");
printf("Fruit:\n");
scanf("%s",&"fruit");
printf("price total \n");
scanf("%f",&price);
printf("How many kilogram \n");
scanf("%f",&kilogram);
total=price*kilogram;
printf("total=%f",total);
printf("-----Thank You-----");
}
#include
main()
{
char fruit[20];
float price;
float kilogram;
float total;
cout<<"----- fruit shop -----\n";
cout<<"fruit:\n";
cin>>fruit;
cout<<"price total\n";
cin>>price;
cout<<"How many kilogram\n";
cin>>kilogram;
cout<<"Total="price*kilogram;
cout<<"----- Thank You -----";
}
DTS 05-22-07-2552
1.Circular Linked List
หมายถึง ลิงค์ลิสต์ที่โหนดสุดท้ายสามารถวกกลับมาที่โหนดแรกได้ใช้ประโยชน์เมื่อต้องการให้ข้อมูลมีลักษณะเป็นวนรอบหรือลูป โดยแต่ละขั้นตอนการทำงานภายในลูป จะมีการย้ายตำแหน่งของพอยน์เตอร์ไปยังโหนดถัดไป
2.Double Linked List
หมายถึง ลิงค์ลิสต์ที่ทุกโหนดสามารถวกกลับมาที่โหนดก่อนหน้าของตนเองได้ ประกอบด้วยส่วนของ Info และ พอยน์เตอร์ที่ชี้ไป 2 ทิศทาง คือ ชี้ไปยังโหนดถัดไป และชี้ไปยังโหนดก่อนหน้า ดังนั้นเราจึงสามารถทำการอ่านข้อมูลได้ 2 วิธี คือ การอ่านไปข้างหน้า และอ่านไปทางข้างหลัง
1. การเพิ่มข้อมูลลงในสแตค (pushing stack)
2. การดึงข้อมูลออกจากสแตค (popping stack)
วันอาทิตย์ที่ 19 กรกฎาคม พ.ศ. 2552
DTS 04-15-07-2552
การแทนโครงสร้างข้อมูลลิงค์ลิสต์
โครงสร้างข้อมูลลิงค์ลิสต์ ประกอบด้วยส่วนสำคัญ 2 รวมเป็นโครงสร้างเรียกว่า โหนด
1. Data Field ทำหน้าที่เก็บข้อมูล
2. Link Field ทำหน้าที่เก็บตำแหน่งที่อยู่ของโครงสร้างสมาชิกตัวถัดไป
โครงสร้างข้อมูลแบบลิงค์ลิสตโครงสร้างข้อมูลแบบลิงค์ลิสตจะแบ่งเป็น 2 ส่วน คือ
1. Head Structure จะประกอบไปด้วย 3 ส่วน ได้แก่
1.1 จำนวนโหนดในลิสต (Count)
1.2 พอยเตอร์ที่ชี้ไปยัง โหนดที่เข้าถึง(Pos)
1.3 พอยเตอร์ที่ชี้ไปยังโหนดข้อูมลแรกของลิสต (Head)
2. Data Node Structure จะประกอบไปด้วยข้อมูล (Data) และพอยเตอร์ที่ชี้ไปยังข้อมูลตัวถัดไป
*การแทรกข้อมูลลงในลิงค์ลิสต์ สามารถจะกระทำได้โดยการเปลี่ยนพอยเตอร์บางตัว และค้นหาข้อมูลใน ลิงค์ลิสต์ เพื่อหาตำแหน่งของโหนดที่มาก่อนโหนดที่ต้องการแทรก สิ่งสำคัญในการแทรกข้อมูลในลิงค์ลิสต์ คือ ลำดับการ เปลี่ยนพอยเตอร์
*การลบโหนดออกจากลิงค์ลิสต์ จะกระทำโดยการเปลี่ยนพอยเตอร์บางตัว เริ่มต้นก็จะต้องหาโหนดที่มาก่อน โหนดที่ต้องการลบ จากนั้นก็ทำการเปลี่ยนพอยเตอร์
วันอังคารที่ 7 กรกฎาคม พ.ศ. 2552
DTS 03-1-07-2552
คือต้นฉบับของชนิดข้อมูล ที่สร้างจากข้อมูลมาตรฐานชนิดหนึ่งค่าของมันคือตำแหน่ง Address อยู่ในหน่วยความจำคอมพิวเตอร์ ใช้สำหรับกำหนดค่ามาจากความคิดพื้นฐานของ Pointer ConstantsPointer Values
การประกาศและกำหนดลักษณะของพอยเตอร์ การประกาศและกำหนดลักษณะของตัวแปรพอยเตอร์จะใช้เครื่องหมาย Indirection เมื่อทำตามแล้วพอยเตอร์จะยังไม่ชี้ไปยังตัวแปรใด
การประกาศตัวแปรพอยเตอร์แบบต่าง ๆ ที่มีข้อมูลตรงตามชนิดข้อมูล และพอยเตอร์ที่ประกาศจะมีชนิดข้อมูลดังนี้
p เป็นตัวอักษร (Character)
q เป็นตัวเลขจำนวนเต็ม (Integer)
r เป็นเลขทศนิยม (Floating-point)
การกำหนดค่าเริ่มต้นของพอยเตอร์ พอยเตอร์เปรียบเสมือนกับตัวแปร คือ เมื่อโปรแกรมเริ่มทำงานแล้ว ไม่ได้ทำการกำหนดค่าเริ่มต้นให้กับพอยเตอร์ก็จะทำให้ค่าบางอย่างอาจนำไปใช้ได้
เครื่องหมาย Indirection (*) และ Address (&) เป็นเครื่องหมายตรงกันข้าม เมื่อนำมารวมกัน
เช่น
*&x ก็จะมีความหมายเท่ากับ x
เซ็ต(Set)
เป็นโครงสร้างที่ข้อมูลแต่ละตัวไม่มีความสัมพันธ์กันเลย ตัวดำเนินการของเซ็ต ประกอบด้วย
1.set intersection การนำตัวเลขที่เสมอและจริงแท้เพียงหนึ่งเดียวมารวมกัน
2.set union การนำสองเซ็ตที่อยู่ในกลุ่มตัวแปรมารวมกัน
3.set difference ผลต่าง
สตริง(String)
การกำหนดเป็นอาร์เรย์ของข้อมูลชนิด char หลายๆตัวนำมาเชื่อมต่อกันเป็น string เช่น character ‘c’, ‘m’, ‘p’, ‘u’, ‘t’, ‘e’, ‘r’ เก็บไว้ในอาร์เรย์รวมเป็นข้อมูล string ซึ่งจะได้ข้อความ “computer” ข้อมูล string เป็นได้ทั้งค่าคงที่ (constant) และตัวแปร(variable)
สำหรับ ‘\0’ หมายถึงเครื่องหมาย mull ซึ่งใช้เป็นรหัสจบสตริง
วันจันทร์ที่ 29 มิถุนายน พ.ศ. 2552
DTS 02-24-06-2552
Array and Record
Array หมายถึงเนื้อที่หน่วยความจำที่เรียงต่อกันใช้เก็บข้อมูลชนิดเดียวกัน เนื้อที่หน่วยความจำนี้มีชื่อเดียวกันแต่แยกตำแหน่งหรือระบุตำแหน่งของข้อมูลแต่ละตัวด้วยการใช้ดรรชนีกำกับ (Index) หรือ Subscript ซึ่งเราสามารถทราบขนาดและมิติ (Dimension) ของ Array เหล่านั้นได้ด้วยการสังเกตที่ดรรชนีกำกับ (Index) หรือ Subscript จะพิจารณาตามประเภทของอะเรย์ในมิติต่างๆ ดังนี้
- อาร์เรย์ 1 มิติ
- อาร์เรย์ 2 มิติ
อาร์เรย์ 1 มิติ คือตัวแปรอาร์เรย์ที่ใช้เก็บข้อมูลเป็นกลุ่ม มีลักษณะตำแหน่งที่ตั้งเป็นลักษณะแถวเดียว(วางตามแนวนอน) หรือคอลัมน์เดียว(วางตามแนวตั้ง)
รูปแบบการประกาศตัวแปรอาร์เรย์มิติเดียว
Data – type array-name [expression]
อาร์เรย์ 2 มิติ คือใช้เก็บข้อมูลเป็นกลุ่ม ที่ข้อมูลนั้นใช้ตัวแปรชื่อเดียวกันแต่ต่างกันที่ตัวห้อย(subscript) ซึ่งจะบอกลำดับความแตกต่างของตัวแปรว่าอยู่ในแถวใด ในคอลัมน์ที่เท่าไร ลำดับใดในแถว
รูปแบบการประกาศตัวแปรอาร์เรย์สองมิติ
Data – type array – name [row size] [column size]
เช่น int a[3][3];
Structure
ตัวอย่างการกำหนดข้อมูลสตรักเจอร์
struct employee
{
char name[20];
int age;
float salary;
}employ ;
----------------------------------------------------------------------------------
#include
struct place
{
char name_of_place[50];
char phone_number[15];
char e_mail[30];
int month;
int year;
};
struct address
{
char city[20];
char country[20];
struct place place1;
} address1;
void input_data()
{
printf("place data\n");
printf("name_of_place=");
scanf("%s",& address1.place1.name_of_place);
printf("phone_number=");
scanf("%s",&address1.place1.phone_number);
printf("e-mail=");
scanf("%s",&address1.place1.e_mail);
printf("day=");
scanf("%d",&address1.place1.day);
printf("month=");
scanf("%d",&address1.place1.month);
printf("year=");
scanf("%d",&address1.place1.year);
printf("city=");
scanf("%s",&address1.city);
printf("country=");
scanf("%s",&address1.country);
}
void show_data()
{
printf("Display Data of place\n");
printf("name_of_place=%s\n",address1.place1.name_of_place);
printf("phone_number= %s\n",address1.place1.phone_number);
printf("e_mail=%s\n",address1.place1.e_mail);
printf("day=%d\n",address1.place1.day);
printf("month=%d\n",address1.place1.month);
printf("year=%d\n",address1.place1.year);
printf("city=%s\n",address1.city);
printf("country=%s\n",address1.country);
}
main()
{
input_data();
show_data();
}
วันเสาร์ที่ 27 มิถุนายน พ.ศ. 2552
ประวัติส่วนตัว
MISS SIRIPUN PUMPANERN
ชื่อเล่น :นิ้ง
รหัสนักศึกษา : 50152792007
หลักสูตร : การบริหารธุรกิจ (คอมพิวเตอร์ธุรกิจ) คณะ วิทยาการจัดการ
มหาวิทยาลัยราชภัฎสวนดุสิต
e-mail address : nu_ninknong@hotmail.com