ลูกแรดเตรียมพร้อมล่าเหยื่อ

สรุปสิ่งที่ได้จากการเรียน การเตรียมฝึกประสบการณ์วิชาชีพบริหารธุรกิจ
จากทีได้เรียนเตรียมฝึกประสบการณ์วิชาชีพบริหารธุรกิจเเล้ว ดิฉันคิดว่าได้ประสบการณ์ต่างๆมากมาย
ไม่ว่าจะเป็น

-การได้เรียนรู้เกี่ยวกับคุณธรรมจริยธรรม เพื่อที่จะนำไปใช้ประโยนช์ในการทำงานในบริษัท
-ได้เรียนรู้เกี่ยวกับการเงินส่วนตัวทำให้รู้ว่าควรจะใช้จ่ายอย่างไร
-ได้เรียนรู้ว่าเทคโนโลยีในปัจจุบันนี้ว่ามีความก้าวหน้ามากน้อยเพียงใด เพื่อที่เราจะได้เป็นคนที่ทันต่อโลกในปัจจุบันและในอนาคต
-ได้เรียนรู้เกี่ยวกับการดูแลบุคลิกภาพ ทางการพูดหรือการสนทนากับบุลคลอื่นๆ บุคลิกภาพในการแต่งตัวให้เหมาะสมกับสถานที่
-ได้เรียนรู้เกี่ยวกับวัฒนธรรมของต่างชาติ เพื่อในวันข้างหน้าจะได้ใช้ในการติดต่อสื่อสารทางธุรกิจ ถ้าเรารู้เกี่ยวกับวัฒนธรรมของคนอื่นๆแล้วจะทำให้เราได้เปรียบในการติดต่อสื่อสาร
-ได้เรียนรู้เกี่ยวกับการใช้ภาษาไทยในการสื่อสาร ในการติดต่อสื่อสารงานกับคนอื่น ได้รู้หลักในการใช้ภาษาไทย ว่าจะใช้ยังไงจึงจะเหมาะสมกับการวาระต่างๆ และได้รู้เกี่ยวกับระดับภาษาที่จะใช้ในการติดต่อสื่อสารในวาระโอกาสต่างๆ ทุกสิ่งที่ได้เรียนมานี้สามารถนำไปประยุกต์ใช้กับการทำงานได้ในทุกเรื่อง ไม่ว่าเราจะทำงานอะไร

DTS10-15-09-52

สรุป Sorting
การเรียงลำดับ (sorting) เป็นการจัดให้เป็นระเบียบ มีแบบแผน ช่วยให้การค้นหาสิ่งของหรือข้อมูล สามารถทำได้รวดเร็วและมีประสิทธิภาพ
การเรียงลำดับอย่างมีประสิทธิภาพ
หลักเกณฑ์ในการพิจารณาเพื่อเลือกวิธีการเรียงลำดับที่ดีและเหมาะสมกับระบบงาน
1.เวลาและแรงงานที่ต้องใช้ในการเขียนโปรแกรม
2.เวลาที่เครื่องคอมพิวเตอร์ต้องใช้ในการทำงานตามโปรแกรมที่เขียน
3.จำนวนเนื้อที่ในหน่วยความจำหลักมีเพียงพอหรือไม่
วิธีการเรียงลำดับ มีหลายวิธีที่สามารถใช้ในการเรียงลำดับข้อมูลได้
วิธีการเรียงลำดับแบ่งออกเป็น 2 ประเภท
1.การเรียงลำดับภายใน (internal sorting) เป็นการเรียงลำดับที่ข้อมูลทั้งหมดต้องอยู่ในหน่วยความจำหลัก
2.การเรียงลำดับแบบภายนอก (external sorting) เป็นการเรียนลำดับข้อมูลที่เก็บอยู่ในหน่วยความจำสำรอง เป็นการเรียงลำดับข้อมูลในแฟ้มข้อมูล (file)
การเรียงลำดับแบบเลือก (selection sort)
ข้อมูลจะอยู่ทีละตัว โดยทำการค้นหาข้อมูลในแต่ละรอบแบบเรียงลำดับ ถ้าเป็นการเรียงลำดับจากน้อยไปมาก
1.ในรอบแรกจะทำการค้นหาข้อมูลตัวที่มีค่าน้อยที่สุดมาเก็บไว้ที่ตำแหน่งที่ 1
2.ในรอบที่สองนำข้อมูลตัวที่มีค่าน้อยรองลงมาไปเก็บไว้ที่ตำแหน่งที่สอง
3.ทำแบบนี้ไปเรื่อยๆ จนครบทุกค่า ในที่สุดจะได้ข้อมูลเรียงลำดับจากน้อยไปมากตามที่ต้องการ
การจัดเรียงลำดับแบบเลือกเป็นวิธีที่ง่ายและตรงไปตรงมา แต่มีข้อเสียตรงที่ใช้เวลาในการจัดเรียงนาน เพราะแต่ละรอบต้องเปรียบเอียบกับข้อมูลทุกตัว
การเรียงลำดับแบบฟอง (Bubble Sort)
เป็นวิธีการเรียงลำดับที่มีการเปรียบเทียบข้อมูลในตำแหน่งที่อยู่ติดกัน
1.ถ้าข้อมูลทั้งสองไม่อยู่ในลำดับที่ถูกต้องให้สลับตำแหน่งที่อยู่กัน
2.ถ้าเป็นการเรียงลำดับจากน้อยไปมากให้นำข้อมูลตัวที่มีค่าน้อยกว่าอยู่ในตำแหน่งก่อนข้อมูลที่มีค่ามาก ถ้าเป็นการเรียงลำดับจากมากไปน้อยให้นำข้อมูล ตัวที่มีค่ามากกว่าอยู่ในตำแหน่งก่อนข้อมูลที่มีค่าน้อย
การจัดเรียงลำดับแบบฟองเป็นวิธีที่ไม่ซับซ้อนมาก เป็นวิธีการเรียงลำดับที่นิยมใช้กันมากเพราะมีรูปแบบที่เข้าใจง่าย

DTS09-08-09-2552

กราฟ Graph
เป็นโครงสร้างข้อมุลแบบไม่เชิงเส้น อีกชนิดหนี่ง กราฟเป็นดครงสร้างข้อมูลที่มีการนำไปใช้ในงานที่เกี่ยวข้องกับการแก้ไขปัญหาที่ค่อนข้างซับซ้อน เช่น การวางข่าย งานคอมพิวเตอร์ การวิเคราะห์เส้นทางวิกฤต และปัญหาเส้นทางที่สั้นที่สุด เป็นต้น

นิยามของกราฟกราฟ เป็นโครงสร้างข้อมูลแบบไม่เชิงเส้นที่ประกอบ ด้วยกลุ่มของสิ่งสองสิ่งคือ
1. โหนด (Nodes) หรือ เวอร์เทกซ์ (Vertexes)
2. เส้นเชื่อมระหว่างโหนด เรียก เอ็จ (Edger) การเชื่อมต่อ
กราฟที่มีเอ็จเชื่อมต่อระหว่างโหนดสองโหนดถ้าเอ็จไม่มีลำดับ ความสัมพันธ์จะเรียกกราฟนั้นว่ากราฟแบบไม่มีทิศทาง (Undirected Garphs)
และถ้ากราฟนั้นมีเอ็จที่มีลำดับความสัมพันธ์หรือมีทิศทางกำกับด้วยเรียกกราฟนั้นว่า การฟแบบมีทิศทาง(Directed Deaphs)
หรือมีลูกศร เป็นกราฟที่แสดงการเชื่อม ระหว่าง Vertex โดยแสดงทิศทางการเชื่อมต่อด้วย บางครั้งเรียกว่า ไดกราฟ (Digraph)
ถ้าต้องการอ้างถึงเอ็จแต่ละเส้นสามารถเขียนชื่อเอ็จกำกับไว้ก็ได้การเขียนกราฟแสดงโหนดและเส้นเชื่อมความสัมพันธ์ ระหว่างโหนดไม่มีรูปแบบที่ตายตัวการสากเส้นความสัมพันธ์เป็นเส้นลักษณะไหนก็ได้ที่สามารถแสดงความสัมพันธ์ระหว่างโหนดได้ถูกต้อง
นอกจากนี้เอ็จจากโหนดใดๆ สามารถวนเข้ามาหาตัวมันเองได้โดยทั่วๆไป การเขียนกราฟเพื่อแสดงให้เห็นด้วยความสัมพันธ์ ของสิ่งที่เราสนใจแทนโหนดด้วยจุด (Pointes) หรือวงกลม (circles) ที่มีชื่อหรือข้อมูลกำกับ เพื่อบอกความแตกต่างของแต่ละโหนดและเอ็จแทนด้วยเส้นหรือเส้นโค้งเชื่อมต่อระหว่างโหนดสองโหนดถ้าเป็นกราฟแบบมีทิศทางเส้นหรือเส้นโค้งต้องมีหัวลูกศรกำกับทิศทางของความสัมพันธ์ด้วยกราฟแบบไม่มีทิศทางเป็นเซตแบบจำกัดของโหนดและเอ็จ โดยเซตอาจจะว่างไม่มีโหนดหรือเอ็จเลยเป็นกราฟว่าง(Empty Graph) แต่ละเอ็จชะเชื่อมระหว่างโหนดสองโหนด หรือเชื่อมตัวเอง อ็จไม่มีทิศทางกำกับ ลำดับของการเชื่อมต่อกันไม่สำคัญ นั่นคือไม่มีโหนดใดเป็นโหนดแรก (First Node)หรือไม่มีโหนดเริ่มต้น และไม่มีโหนดใดเป็นโหนดสิ้นสุดกราฟแบบมีทิศทาง เป็นเซตแบบจำกัดของโหนดและเอ็จ โดยเซตอาจว่างไม่มีโหนดหรือเอ็จเลยป็นกราฟว่าง(Empty Graph) แต่ละเอ็จจะเชื่อมระหว่างโหนดสองโหนด เอ็จมีทิศทางกำกับแสดงลำดับของการเชื่อมต่อกัน โดยมีโหนดเริ่มต้น (Source Node)และโหนดสิ้นสุด (Target Node)รูปแบบต่างๆ ของกราฟแบบมีทิศทางเหมือนกับรูปแบบ ของกราฟแบบไม่มีทิศทาง ต่างกันตรงที่กราฟแบบนี้จะมีทิศทางกำกับด้วยเท่านั้น

การท่องไปในกราฟ (Graph traversal) คือ การเข้าไปเยือนโหนดในกราฟ หลักการทำงาน คือ แต่ละโหนดจะถูกเยือนเพียงครั้งเดียวเทคนิคการท่องไปในกราฟมี 2 แบบ

1.การท่องแบบกว้าง (Breadth First Traversal) โดยเลือกโหนดที่เป็นจุดเริ่มต้น ต่อมาให้เยือนโหนดอื่นที่ใกล้กันกับโหนดเริ่มต้นที่ละระดับ จนเยือนหมดทุกโหนดในกราฟ (แบบคิว)

2.การท่องแบบลึก (Depth First Traversal) คล้ายกับการท่องทีละระดับของทรี กำหนดเริ่มต้นที่โหนดแรกและเยือนโหนดถัดไปตามแนววิถีจนไปสู่ปลายวิถี จากนั้นย้อนกลับ (backtrack) ตามแนววิถีเดิม จนสามารถดำเนินการต่อเนื่องเข้าสู่แนววิถีอื่นๆ เพื่อเยือนโหนดอื่นๆ ต่อไปจนครบทุกโหนด (แบบสแตก)

สรุป Sortingการเรียงลำดับ (sorting) เป็นการจัดให้เป็นระเบียบ มีแบบแผน ช่วยให้การค้นหาสิ่งของหรือข้อมูล สามารถทำได้รวดเร็วและมีประสิทธิภาพการเรียงลำดับอย่างมีประสิทธิภาพหลักเกณฑ์ในการพิจารณาเพื่อเลือกวิธีการเรียงลำดับที่ดีและเหมาะสมกับระบบงาน
1.เวลาและแรงงานที่ต้องใช้ในการเขียนโปรแกรม
2.เวลาที่เครื่องคอมพิวเตอร์ต้องใช้ในการทำงานตามโปรแกรมที่เขียน3.จำนวนเนื้อที่ในหน่วยความจำหลักมีเพียงพอหรือไม่วิธีการเรียงลำดับ มีหลายวิธีที่สามารถใช้ในการเรียงลำดับข้อมูลได้
วิธีการเรียงลำดับแบ่งออกเป็น 2 ประเภท
1.การเรียงลำดับภายใน (internal sorting) เป็นการเรียงลำดับที่ข้อมูลทั้งหมดต้องอยู่ในหน่วยความจำหลัก
2.การเรียงลำดับแบบภายนอก (external sorting) เป็นการเรียนลำดับข้อมูลที่เก็บอยู่ในหน่วยความจำสำรอง เป็นการเรียงลำดับข้อมูลในแฟ้มข้อมูล (file)

DTS08-25-08-2552

Tree (ทรี)
ทรี หรือโครงสร้างข้อมูลแบบต้นไม้
ประกอบด้วยโหนด (node) ซึ่งเป็นส่วนที่เก็บข้อมูล ในทรีหนึ่งทรีจะประกอบไปด้วยรูทโหนด (root node) เพียงหนึ่งโหนด แล้วรูทโหนดสามารถแตกโหนดออกเป็นโหนดย่อยๆ ได้อีกหลายโหนดเรียกว่าโหนดลูก (Child node) เมื่อมีโหนดลูกแล้ว โหนดลูกก็ยังสามารถแสดงเป็นโหนดพ่อแม่ (Parent Node) โดยการแตกโหนดออกเป็นโหนดย่อยๆได้อีก โหนดที่มีโหนดแม่เป็นโหนดเดียวกันเรียกว่า โหนดพี่น้อง (Siblings) โหนดที่ไม่มีโหนดลูกเรียกว่า โหนดใบ (Leave Node) เส้นเชื่อมแสดงความสัมพันธ์ระหว่างโหนดเรียกว่า กิ่ง (Beanch) คือ โหนดที่ไม่ใช่ Leaf Node

นิยามของทรี
1. นิยามทรีด้วยนิยามของกราฟทรี คือ กราฟที่ต่อเนื่องโดยไม่มีวงจรปิด (loop) ในโครงสร้าง โหนดสองโหนดใดๆ ในทรีต้องมีทางติดต่อกัน ทางเดียวกันนั้น และทรีที่มี N โหนด ต้องมีกิ่งทั้งหมด N -1เส้น การเขียนรูปแบบทรี
อาจเขียนได้ 4 แบบ คือ
1. แบบที่มีรากอยู่ด้านบน
2. แบบที่มีรากอยู่ด้านล่าง
3. แบบที่มีรากอยู่ด้านซ้าย
4. แบบที่มีรากอยู่ด้านขวา

2. นิยามทรีด้วยรูปแบบเคอร์ซีฟ คือ การเรียกตัวเองมาใช้ โหนด โดยที่ถ้าว่าง ไม่มีโหนดใดๆ เรียกว่า นัลทรี (Null Tree) และถ้ามีโหนดหนึ่งเป็นโหนดราก ส่วนที่เหลือจะแบ่งเป็นทรีย่อย (Sub Tree)T1,T2,T3,....,Tk โดยที่ k>=0 และทรีย่อยต้องมีคุณสมบัติเป็นทรีนิยามที่เกี่ยวข้องกับทรี1. ฟอร์เรสต์ (Forest) ป่า หมายถึง กลุ่มของทรีที่เกิดจากการเอาโหนดรากของทรีออก หรือ เซตของทรีที่แยกจากกัน (Disjoint Trees)
2. ทรีที่มีแบบแผน (ordered Tree) ทรีแบบลำดับ หมายถึง ทรีที่โหนดต่างๆ ในทรีนั้นมีความสัมพันธ์ที่แน่นอน เช่น ปทางขวา ไปทางซ้าย เป็นต้น
3. ทรีคล้าย (similar Tree) คือ ทรีที่มีโครงสร้างเหมือนกัน หรือทรีที่มีรูปร่างของทรีเหมือนกัน โดยไม่คำนึงถึงข้อมูลที่อยู่ในแต่ละโหนด
4. ทรีเหมือน (Equivalent Tree) คือทรีที่เหมือนกันโดยสมบูณ์ โดยต้องเป็นทรีที่คล้ายกันและแต่ละโหนดในตำแหน่งเดียวกันมีข้อมูลเหมือนกัน
5. กำลัง (Degree) หมายถึงจำนวนย่อยของโหนด นั้นๆ
6. ระดับของโหนด (Level of Node) คือระยะทางในแนวดิ่งของโหนดนั้นๆ ที่อยู่ห่างจากโหนดราก เมื่อกำหนดให้โหนดรากของทรีนั้นอยู่ระดับ 1 และกิ่งแต่ละกิ่งมีความเท่ากันหมด คือ ยาวเท่ากับ 1 หน่วย ซึ่งระดับของโหนดจะเท่ากับจำนวนกิ่งที่น้อยที่สุดและจำนวนเส้นทางตามแนวดิ่งของโหนดใดๆ ซึ่งห่างจากโหนดราก เรียกว่า ความสุง( Height) หรือความลึก (Depth)การแทนที่ทรีในหน่วยความจำหลักการแทนที่โครงสร้างข้อมูลแบบทรีในความจำหลัก จะมีพอยเตอร์เชื่อมโยงจากโหนดแม่ไปยังโหนดลูก แต่ละโหนดต้องมีลิงค์ฟิลด์เพื่อเก็บที่อยู่ของโหนดลูกต่าง ๆ นั่นคือ จำนวนลิงค์ฟิลด์ของแต่ละโหนดขึ้นอยู่กับจำนวนของโหนดลูก การแทนที่ทรี ซึ่งแต่ละโหนดมีจำนวนลิงค์ฟิลด์ไม่เท่ากัน ทำให้ยากต่อการปฏิบัติการ วิธีการแทนที่ที่ง่ายที่สุด คือ ทำให้แต่ละโหนดมีจำนวนลิงค์ฟิลด์เท่ากัน โดยอาจใช้วิธีการต่อไปนี้1. แต่ละโหนดเก็บพอยเตอร์ชี้ไปยังโหนดลูกทุกโหนด

2. แทนทรีด้วยไบนารีทรี เป็นวิธีแก้ปัญหาเพื่อลดการ สิ้นเปลืองเนื้อที่ในหน่วยความจำไบนารีทรีที่ทุก ๆ โหนดมีทรีย่อยทางซ้ายและทรีย่อยทางขวา ยกเว้นโหนดใบและโหนดใบทุกโหนดจะต้องอยู่ที่ระดับเดียวกันเรียกว่า ไบนารีทรีแบบสมบูรณ์ (complete binary tree) สามารถคำนวณจำนวนโหนดทั้งหมดในไบนารีทรีแบบสมบูรณ์ได้
ถ้ากำหนดให้ L คือระดับของโหนดใด ๆ และ N คือจำนวนโหนดทั้งหมดในทรีจะได้ว่าระดับ 1 มีจำนวนโหนด 1 โหนด ระดับ 2 มีจำนวนโหนด 3 โหนด ระดับ 3 มีจำนวนโหนด 7 โหนด ระดับ 4 มีจำนวนโหนด 15 โหนด ระดับ L มีจำนวนโหนด 2L – 1 โหนด นั่นคือ จำนวนโหนดทั้งหมดในทรีสมบูรณ์ที่มี L ระดับสามารถคำนวณได้จากสูตรดังนี้การแปลงทรีทั่วไปให้เป็นไบนารีทรีขั้นตอนการแปลงทรีทั่วๆ ไปให้เป็นไบนารีทรี มีลำดับขั้นตอนการแปลงดังต่อไปนี้
1. ให้โหนดแม่ชี้ไปยังโหนดลูกคนโต แล้วลบความสัมพันธ์ระหว่างโหนดแม่และโหนดลูกอื่น ๆ
2. ให้เชื่อมความสัมพันธ์ระหว่างโหนดพี่น้อง
3. จับให้ทรีย่อยทางขวาเอียงลงมา 45 องศาการท่องไปในทรี

การท่องไปในไบนารีทรี (Traversing Binary Tree) คือ การเข้าไปเยือนทุก ๆ โหนดในทรี วิธีการท่องเข้าไปต้องเป็นไปอย่างมีระบบแบบแผน สามารถเยือนโหนดทุก ๆ โหนด ๆ ละหนึ่งครั้ง วิธีการท่องไปนั้นมีด้วยกันหลายแบบ โหนดที่ถูกเยือนอาจเป็นโหนดแม่ (แทนด้วย N)ทรีย่อยทางซ้าย (แทนด้วย L) หรือทรีย่อยทางขวา (แทนด้วย R)
วิธีการท่องเข้าไปในทรีมี 6 วิธี คือ NLR LNR LRN NRL RNL และ RLN
แต่วิธีการท่องเข้าไปในทรีที่นิยมใช้กันมากเป็นการท่องจากซ้ายไปขวา 3 แบบแรก คือ
NLR
LNR
LRN ซึ่งลักษณะการนิยามเป็นนิยามแบบ รีเคอร์ซีฟ (Recursive)

ขั้นตอนการท่องไปในแต่ละแบบมีดังนี้
1. การท่องไปแบบพรีออร์เดอร์ (Preorder Traversal) เป็นการเดินเข้าไปเยือนโหนดต่าง ๆ ในทรีด้วยวิธี NLR
2. การท่องไปแบบอินออร์เดอร์ (Inorder Traversal) เป็นการเดินเข้าไปเยือนโหนดต่าง ๆ ในทรีด้วยวิธี LNR
3. การท่องไปแบบโพสออร์เดอร์ (Postorder Traversal) เป็นการเดินเข้าไปเยือนโหนดต่าง ๆ ในทรีด้วยวิธี LRN

เอ็กซ์เพรสชันทรีเป็นการนำเอาโครงสร้างทรีไปใช้เก็บนิพจน์ทางคณิตศาสตร์โดยเป็นไบนารีทรี ซึ่งแต่ละโหนดเก็บตัวดำเนินการ (Operator) และและตัวถูกดำเนินการ (Operand) ของนิพจน์คณิตศาสตร์นั้น ๆ ไว้ หรืออาจจะเก็บค่านิพจน์ทางตรรกะ (Logical Expression) นิพจน์เหล่านี้เมื่อแทนในทรีต้องคำนึงลำดับขั้นตอนในการคำนวณตามความสำคัญของเครื่องหมายด้วย โดยมีความสำคัญตามลำดับดังนี้
1. ฟังก์ชัน
2. วงเล็บ
3. ยกกำลัง
4. ครื่องหมายหน้าเลขจำนวน (unary)
5. คูณ หรือ หาร
6. บวก หรือ ลบ
7. ถ้ามีเครื่องหมายที่ระดับเดียวกันให้ทำจากซ้ายไปขวาการแทนนิพจน์ในเอ็กซ์เพรสชันทรี
ตัวถูกดำเนินการจะเก็บอยู่ที่โหนดใบ ส่วนตัวดำเนินการจะเก็บในโหนดกิ่ง หรือโหนดที่ไม่ใช่โหนดใบ เช่น นิพจน์ A + Bไบนารีเซิร์ชทรี (Binary Search Tree)เป็นไบนารีทรีที่มีคุณสมบัติที่ว่าทุก ๆ โหนดในทรี ค่าของโหนดรากมีค่ามากกว่าค่าของทุกโหนดในทรีย่อยทางซ้าย และมีค่าน้อยกว่าหรือเท่ากับค่าของทุกโหนดในทรีย่อยทางขวา และในแต่ละทรีย่อยก็มีคุณสมบัติเช่นเดียวกัน ค่าข้อมูลในทรีย่อยทางซ้าย < ค่าข้อมูลที่โหนดราก < ค่าข้อมูลในทรีย่อยทางขวา ปฏิบัติการในไบนารีเซิร์ชทรี เพิ่มโหนดเข้าหรือดึงโหนดออกจากไบนารีเซิร์ชทรี ค่อนข้างยุ่งยาก เนื่องจากหลังปฏิบัติการเสร็จเรียบร้อยแล้ว ต้องคำนึงถึงความเป็นไบนารีเซิร์ชทรีทรีนั้นด้วย
ซึ่งมีปฏิบัติการดังต่อไปนี้
1. การเพิ่มโหนดในไบนารีเซิร์ชทรี
2. การดึงโหนดในไบนารีเซิร์ชทรี

ขั้นตอนวิธีดึงโหนดออกอาจแยกพิจารณาได้ 3 กรณีดังต่อไปนี้

ก. กรณีโหนดที่จะดึงออกเป็นโหนดใบ
ข. กรณีโหนดที่ดึงออกมีเฉพาะทรีย่อยทางซ้ายหรือทรีย่อยทางขวาเพียงด้านใดด้านหนึ่ง
ค. กรณีโหนดที่ดึงออกมีทั้งทรีย่อยทางซ้ายและทรีย่อยทางขวา
- ถ้าโหนดที่มาแทนที่เป็นโหนดที่เลือกจากทรีย่อยทางซ้าย ต้องเลือกโหนดที่มีค่ามากที่สุดในทรีย่อยทางซ้ายนั้น
- ถ้าโหนดที่จะมาแทนที่เป็นโหนดที่เลือกมาจากทรีย่อยทางขวา ต้องเลือกโหนดที่มีค่าน้อยที่สุดในทรีย่อยทางขวานั้น

DTS07-11-08-2552

เรื่อง Queue
คิว Queue เป็นโครงสร้างข้อมูลแบบเชิงเส้นซึ่งการเพิ่มข้อมุลจะกระทำที่ปลายข้างหนึ่งซึ่งเรียกว่า
ส่วนท้ายหรือเรียร์ (rear)และการนำข้อมูลออกจะกระทำที่ปลายอีกข้างหนึ่งซึ่งเรียกว่า ส่วนหน้า
ลักษณะการทำงานของคิวเป็นลักษณะของการเข้าก่อนออกก่อนหรือที่เรียกว่า FIFO (First In First Out)
การทำงานของคิว
การใส่สมาชิกใหม่ลงในคิวเรียกว่า Enqueue ซึ่งมีรูปแบบคือ
enqueue หมายถึง การใส่ข้อมูล newElementลงไปที่ส่วนเรียร์ของคิว
การนำสมาชิกออกจากคิว เรียกว่า Dequeue หมายถึง การนำข้อมูลออกจากส่วนหน้าของคิวและให้ ข้อมุลนั้นกับ element
การนำข้อมูลที่อยู่ตอนท้ายของคิวมาแสดงจะเรียกว่า Queue Rear แต่จะไม่ทำการเพิ่มข้อมูลเข้าไปในคิว
การแทนที่ข้อมูลของคิว
การแทนที่ข้อมูลของคิวสามารถทำได้ 2 วิธี คือ
1.การแทนที่ข้อมุลของสแตกแบบลิงค์ลิสต์จะประกอบไปด้วย 2 ส่วน คือ
1.Head Node
จะประกอบไปด้วย 3 ส่วนคือพอยเตอร์จำนวน 2 ตัว คือ Front และ rear กับจำนวนสมาชิกในคิว
2.Data Node จะประกอบไปด้วยข้อมูล (Data) และพอยเตอร์ที่ชี้ไปยังข้อมูลตัวถัดไป
การดำเนินการเกี่ยวกับคิว
การดำเนินการเกี่ยวกับคิว ได้แก่
1.Create Queue คือ จัดสรรหน่อยความจำให้แก่ Head Node และให้ค่า ponter ทั้ง 2 ตัวมีค่าเป็น null
และจำนวนสมาชิกเป็น 0
2.Enqueue คือ การเพื่มข้อมูลเข้าไปในคิว
3.Dequeue คือ การนำข้อมุลออกจากคิว
4.Queue Front คือ เป็นการนำข้อมูลที่อยู่ส่วนต้นของคิวมาแสดง
5.Queue Rear คือ เป็นการนำข้อมุลที่อยุ่ส่วนท้ายของคิวมาแสดง
6.Empty Queue คือ เป็นการตรวจสอบว่าคิวว่างหรือไม่
7.Full Queue คือ เป็นการตรวจสอบว่าคิวเต็มหรือไม่
8.Queue Count คือ เป็นการนับจำนวนสมาชิกที่อยู่ในคิว
9.Destroy Queue คือ เป็นการลบข้อมุลทั้งหมดที่อยู่ในคิว
การนำข้อมูลเข้าสู่คิว จะไม่สามารถนำเข้าในขณะที่คิวเต็ม หรือไม่มีที่ว่าง ถ้าพยายามนำเข้าจะให้เกิด
ความผิดพลาดที่เรียกว่า Overflow
การนำข้อมุลออกจากคิว จะไม่สามารถนำอะไรออกจากคิวที่ว่างเปล่าได้ ถ้าพยายามจะทำให้เกิด
ความผิดพลาดที่เรียกว่า underflow

iostream

การนับจำนวนตัวอักษร
#include "iostream"
#include "conio.h"
using namespace std;
int main(){
char chr;
int count = 0;
cin>>chr;
while(true){
if(chr == '#')
break;
count++;
cin>>chr;
}
cout<<"total characher is : "<"count<"endl;
getch();
return 0;}

DTS06-04-08-2552

(Stack)
โครงสร้างสแตก (stack structure)

สแตก เป็นโครงสร้างข้อมูลอีกรูปแบบหนึ่งที่มีลักษณะของการจัดเก็บข้อมูลที่สามารถจัดเก็บได้แบบทั้งเรคอร์ด อาร์เรย์ หรือการจัดเก็บในลักษณะลิงค์ลิสต์ แต่โดยรูปแบบของการทำงานนั้นจะเป็นเหมือนการจัดเก็บหรือบันทึกสมาชิกในลักษณะของการพักไว้ สแตก เป็นโครงสร้างที่ถูกออกแบบมาให้มีลักษณะเป็นเชิงเส้น (linear list) สามารถที่จะทำการลบหรือเพิ่มจำนวนสมาชิกเข้ามาในโครงสร้างได้

Last In First Out : LIFO หมายถึงข้อมูลที่เข้ามาในลิสต์เป็นลำดับสุดท้าย จะถูกนำออกจากลิสต์เป็นอันดับแรก ตัวอย่างได้แก่การนำชั้นของปิ่นโตเข้าและออกจากเถาปิ่นโต พื้นฐานการดำเนินการกับสแตก

1.Push หรือการนำเข้าข้อมูล เป็นการดำเนินการในลักษณะของการเพิ่มข้อมูลในสแตกกรณีที่ไม่มีข้อมูลใดอยู่ก็จะ push เข้าไปตำแหน่งแรก ซึ่งถือว่าเป็นตำแหน่ง top แต่ถ้าหากนำข้อมูล push เข้ามาอีกก็จะดำเนินการจัดลงในตำแหน่งต่อจาก top และปรับค่า top มาอยู่ที่ตำแหน่งข้อมูลที่ push เข้ามาใหม่ จะต้องระวังปัญหา stack over flow คือไม่มีพื้นที่ว่างสำหรับการเพิ่มข้อมูลเข้าไปใน สแตก หรือ สแตก เต็ม

2.Pop หรือการดึงข้อมูลออก การดึงออกข้อมูล คือการนำเอาข้อมูลออกจากสแตก ซึ่งการดำเนินการก็จะต้องดำเนินการในตำแหน่ง top กรณีของการ pop ก็จะต้องตวรจสอบด้วยว่า หากไม่มีข้อมูลภายในสแตกแล้วยังมีการเรียก pop ข้อมูลอีกจะทำให้เกิดข้อผิพลาดที่เรียกว่า stack under flow

3. Top หรือตำแหน่งบนสุด ตำแหน่งบนสุดนั้นใช้ top เป็นตัวกำกับ ซึ่งบอกให้ทราบว่าหากต้องการ pop หรือ push ข้อมูลก็สามารถทำได้ ณ ตำแหน่งนี้ โดยลักษณะการดำเนินการของ top เป็นเพียงสิ่งที่บอกตำแหน่งของข้อมูลท่อยู่บนสุดเท่านั้น หากมีการ push ข้อมูลตำแหน่งของ top ก็จะชี้ไปค่าตำแหน่งสูงสุดใหม่ หรือ หากมีการ pop ข้อมูลออกไป top ก็ไม่ใช่ตัวลบค่า แต่จะเป็นการคืนค่าและลดตำแหน่งลงมา ซึ่งtop จะเกิดความผิดพลาดกรณีเดียวกันกับ pop คือ Underflow เมื่อ สแตกนั้นเกิดการว่าง


โครงสร้างของการแทนสแตกด้วยอาร์เรย์
การแทนสแตกด้วยโครงสร้างอาร์เรย์นั้น เนื่องจากอาร์เรย์เป็นโครงสร้างที่ต้องมีการกำหนดจองพื้นที่แน่นอน (static) จึงจำเป็นต้องมีการกำหนดขนาดพื้นที่จัดเก็บข้อมูลสูงสุดให้เหมาะสมเมื่อมีการนำเอาข้อมูลเข้ามาก็จะนำเข้ามาจัดไว้ในอาร์เรย์แรกสุดจากนั้นจึงเรียงลำดับกันไปตามพื้นที่ที่กำหนด

Operations พื้นฐานของ Stack ที่สร้างด้วย Linked list
1. Create stack: สร้าง stack head node
2. Push stack: เพิ่มรายการใน stack
3. Pop stack: การนำข้อมูลบนสุดออกจาก stack (ไม่บอกตำแหน่งเพราะเอาตัวบนสุดออกมาเท่านั้น)
4. Stack top: เป็นการคัดลอกข้อมูลที่อยู่บนสุดของ stack
5. Empty stack: ตรวจสอบว่า stack ว่างเปล่าหรือไม่
6. Full stack: ตรวจสอบว่า stack เต็มหรือไม่
7. Stack count: ส่งค่าจำนวนรายการใน stack
8. Destroy stack: คืนหน่วยความจำของทุก node ใน stack ให้ระบบ

>การประยุกต์ใช้งานสแตกในการแปลงรูปนิพจน์ทางคณิตศาสตร์

1.รูปแบบนิพจน์ทางคณิตศาสตร์ แบ่งเป็น 3 ประเภทคือ
1. นิพจน์ Infix คือ นิพจน์ที่มีเครื่องหมายดำเนินการอยู่กึ่งกลางตัวถูกดำเนินการ (operand)
2. นิพจน์ Postfix คือ นิพจน์ที่มีเครื่องหมายดำเนินการอยู่ด้านหลังตัวถูกดำเนินการ (operand)
3. นิพจน์ Prefix คือ นิพจน์ที่มีเครื่องหมายดำเนินการอยู่ด้านหน้าตัวถูกดำเนินการ (operand)

เครื่องหมายดำเนินการ (operand) ได้แก่เครื่องหมาย + - * ^
ตัวถูกดำเนินการ ได้แก่ สัญลักษณ์แทนค่าตัวเลข เช่น A B C D ….. หรือตัวแปรอื่น
รูปแบบนิพจน์ของ infix จะเป็นลักษณะของนิพจน์ที่ใช้งานกันทั่วไป เช่น a + b, A*B ซึ่งมีการนำเครื่องหมายการดำเนินการไว้ตรงกลาง นิพจน์ posfix เป็นนิพจน์ที่มีการจัดรูปแบบของการคำนวณโดยเอาเครื่องหมายดำเนินการไว้หลังตัวถูกดำเนินการเพื่อให้ระบบอ่านตัวถูกดำเนินการก่อนแล้วจึงทราบวิธีการคำนวณ เช่น AB + และนิพจน์ prefix เป็นนิพจน์ที่นำเครื่องหมายสำหรับการดำเนินการ วางไว้ด้านหน้าก่อนตัวถูกดำเนินการ เช่น + AB

Prefix : +AB
Infix : A+B
Posfix : AB+

2.การแปลงนิพจน์ infix เป็น posfix สำหรับการดำเนินการด้านการคำนวณนั้น ในระบบคอมพิวเตอร์ไม่สามารถที่จะจัดลำดับของการคำนวณในรูปแบบของ infix ได้ แต่จะแปลงเป็นนิพจน์ของ infix หรือ prefix เสียก่อน โดยลักษณะของการแปลงนิพจน์จะใช้การเปรียบเทียบความสำคัญของตัวดำเนินการ เครื่องหมายในการคำนวณทั้ง 5 ตัว และหลักการอัลกอริทึมของการแปลงนิพจน์

วิธีการเปลี่ยน Infix เป็น Postfix
•Algorithm การเปลี่ยน Infix เป็น Postfix
• ให้ EXP เป็นสมการคณิตศาสตร์ที่เป็น Infix และ Stack เป็น stack ใด ๆ NEXP เป็นสมการที่เป็น Postfix
•1. ใส่ “(“ เข้าไปใน Stack
•2. อ่าน EXP จากซ้ายไปขวา
2.1 ถ้าพบตัวถูกดำเนินการ(ตัวเลข) ให้ใส่เข้าไปใน NEXP
2.2 ถ้าพบ “(“ ให้ push ใส่ stack
2.3 ถ้าพบตัวดำเนินการ(เครื่องหมาย) ให้ทำดังนี้ - ให้ pop ตัวดำเนินการ ทุกตัวที่มีลำดับความสำคัญกว่าตัวดำเนินการที่พบใน 2.3 ออกมาใส่ใน NEXP ให้หมด - นำตัวดำเนินการที่พบใน
2.3 push เข้าใน stack แทนที่
2.4 ถ้าพบ “)” ให้ทำดังนี้ • - ให้ push ตัวดำเนินการ ทุกตัวมาใส่ไว้ใน NEXP ให้หมดจนพบ “(“ • - push “(“ ทิ้ง
3. จบการทำงาน

DTS05-28-07-2552

Linked List

ลิงค์ลิสต์เป็นการจัดเก็บชุดข้อมูลเชื่อมโยงต่อเนื่องกันไปตามลำดับ ซึ่งในลิสต์จะประกอบไปด้วยข้อมูลที่เรียกว่าโหนด (node) ในหนึ่งโหนดจะประกอบด้วยส่วนของข้อมูลที่ต้องการจัดเก็บ เรียกว่าส่วน Info และส่วนที่เป็นพอยน์เตอร์ที่ชี้ไปยังโหนดถัดไป (Link) หรือชี้ไปยังโหนดอื่นๆที่อยู่ในลิสต์ หากไม่มีโหนดที่อยู่ถัดไป ส่วนที่เป็นพอยน์เตอร์หรือ Link จะเก็บค่า NULL หรือ NILL ใช้สัญลักษณ์ ^

โครงสร้างข้อมูลแบบลิงค์ลิสต์

โครงสร้างข้อมูลแบบลิงค์ลิสต์จะแบ่งเป็น 2ประเภทคือ

1.Head Structrue จะประกอบไปด้วย3ส่วน ได้แก่ จำนวนโหนดในลิสต์(count) พอยเตอร์ที่ชี้ไปยังโหนดที่เข้าถึง(pos) คือ รายการเก็บข้อมูลปัจจุบันที่มีการท่องเข้าไปในลิสต์แทนด้วยpos และพอยเตอร์ที่ชี้ไปยังโหนดข้อมูลแรกของลิสต์(head)

2.Data Node Structure จะประกอบไปด้วยข้อมูล(Data) และพอยเตอร์ที่ชี้ไปยังข้อมูลตัวถัดไป ประกอบไปด้วย 2 ฟิลด์ ฟิลด์แรกเก็บในส่วนของข็อมูล ฟิลด์ที่ 2 เก็บส่วนของการเชื่อโยง ก็จะใช้พอยเตอร์เป็นตัวเชื่อมไปยังโหนดอื่นๆ

กระบวนงานและฟังชั่นที่ใช้ดำเนินงานพื้นฐาน

1. กระบวนงาน Create List
หน้าที่ สร้างลิสต์ว่าง
ผลลัพธ์ ลิสต์ว่าง

2. กระบวนงาน Insert Note การแทรกโหนดคือการเพิ่มสมาชิกใหม่ลงในรายการ เพิ่มข้อมูลลงไปในลิสต์บริเวณตำแหน่งที่ต้องการ
กระบวนนำเข้า ลิสต์ ข้อมูล และตำแหน่ง
ผลลัพธ์ ลิสต์ที่มีการเปลี่ยนแปลง

3. กระบวนงาน Delete Note
หน้าที่ ลบสมาชิกในลิสต์บริเวณตำแหน่งที่ต้องการ ในการลบโหนดโดยจะทำการลบทั้งโหนดและข็อมูลที่ไมต้องการออกไป หลักง่ายๆ ด้วยการเปลี่ยนลิงค์ของโหนดก่อนหน้าโหนดที่ต้องการลบให้ชี้ไปยังลิงค์ของโหนดที่ต้องการลบ และคืนค่าของโหนดที่ต้องการลบแก่หน่วยความจำไป
ข้อมูลนำเข้า ข้อมูลและตำแหน่ง
ผลลัพธ์ ลิสต์ที่มีการเปลี่ยนแปลง

4. กระบวนงาน Search Iist ในการ Search ต้องมี Condition
หน้าที่ ค้นหาข้อมูลในลิสต์ที่ต้องการข้อมูลนำเข้า
ผลลัพธ์ ค่าจริงถ้าพบข้อมูล ค่าเท็จถ้าไม่พบข้อมูล

5. กระบวนงาน Traverse
หน้าที่ ท่องไปในลิสต์เพื่อเข้าถึงและประมวลผลข้อมูลนำเข้าลิสต์
ผลลัพธ์ ขึ้นกับการประมวลผล เช่น เปลี่ยนแปลงค่าใน node , รวมฟิลด์ในลิสต์,คำนวนค่าเฉลี่ยของฟิลด์ เป็นต้น

6. กระบวนงาน Retrieve Nodeการแสดงขอมูลในโหนด
หน้าที่ หาตำแหน่งของข้อมูลจากลิสต์ข้อมูลนำข้าลิสต์
ผลลัพธ์ ตำแหน่งข้อมูลที่อยู่ในลิสต์ หากต้องการนำข้อมูลในโหนดขึ้นมาแสดง เพียงทราบถึงตำแหน่งของลิสต์ที่จัดเก็บข้อมูล ก็สามารถนำข้อมูลนั้นๆ มาแสดงได้

7. ฟังก์ชั่น Emptylist
หน้าที่ ทดสอบว่าลิสต์ว่างข้อมูลนำเข้าลิสต์
ผลลัพธ์ เป็นจริง ถ้าลิสต์ว่าง Count= ถ้าไม่เท่า Count# ตรวจสอบโดยการกำหนดวนลูบค่าหากตรวจสอบว่าไม่มีข้อมูลกำหนดค่าเป็นจริง

8. ฟังก์ชั่น Fulllist การตรวจสอบลิสต์เต็ม
หน้าที่ ทดสอบว่าลิสต์เต็มหรือไม่ข้อมูลนำเข้าลิสต์ ตรวจสอบว่าลิสต์นั้นเต็มหรือไม่ มีพื้นที่ว่างในหน่วยความจำสำหรับลิสต์หรือไม่
ผลลัพธ์ เป็นจริง ถ้าหน่วยความจำเต็ม เป็นเท็จ ถ้าสามารถมีโหนดอื่น

9. ฟังก์ชั่น list countการนับจำนวนลิสต์ทำใหทราบว่าในโครงสร้างของลิสต์ปัจจุบันมีจำนวนลิสต์อยู่เท่าใดและสามารถตรวจสอบได้จากหนดต้นลิสต์ เนื่องจากเก็บค่าไว้ที่ count
หน้าที่ นับจำนวนข้อมูลที่อยู่ในลิสต์
ผลลัพธ์ จำนวนข้อมูลที่อยู่ในลิสต์

10. กระบวนงาน Destroy listการยกเลิกลิสต์ลบแล้วก็ต้องคืนค่าให้หน่วยความจำเพื่อไปใช้งานอื่นต่อไป
หน้าที่ ทำลายลิสต์
ข้อมูลนำเข้า ลิสต์
ผลลัพธ์ ไม่มีลิสต์

2. Double Linked List ลิงค์ลิสต์คู่ เป็นลิงค์ลิสต์ที่มีทิศทางการทำงานแบบ 2 ทิศทาง ในลิงค์ลิสต์แบบ 2 ทิศทาง ส่วนข้อมูลจะมีตัวชี้ไปที่ข้อมูล ก่อนหน้า (backward pointer:B) และตัวชี้ข้อมูลถัดไป (forward pointer :F)

DTS04-14-07-2552

สรุป Set and String
โครงสร้างข้อมูลแบบเซต (Set) เป็นโครงสร้างที่ข้อมูลแต่ละตัวไม่มีความสัมพันธ์กันเลย
ตัวดำเนินการของเซ็ต
-Set intersection การซ้ำกัน
-Set union การรวมกัน
-Set difference ความแตกต่าง
เช่น สมาชิกในห้อง 323 เป็น union กัน เพราะมีตอนเรียน A และตอนเรียน B
แต่ไม่เป็น intersection กัน เพราะคนๆหนึ่งไม่สามารถอยู่ในอีกห้องหนึ่งได้

สตริง String) หรือ สตริงของอักขระ เป็นข้อมูลที่ประกอบด้วยตัวอักษร ตัวเลข หรือเครื่องหมาย
สตริงในภาษา C ก็คือ อาร์เรย์ของตัวอักษร ที่มีข้อมูลชนิดตัวอักษรเรียงกันไป แต่จะต้องมีจุดสิ้นสุดด้วย โดยจะใช้ตัวอักษรวางหรือ Null Character เป็นจุดสิ้นสุดของสตริง ซึ่งจะต่างจากอาร์เรย์ปกติที่ไม่ต้องมีจุดสิ้นสุดของอาร์เรย์

การเก็บข้อมูลของสตริง การเก็บข้อมูลของสตริงนั้น จะมีการเก็บข้อมูลอยู่ 2 ส่วน ส่วนแรกจะเป็นข้อมูลตัวอักษรโดยเก็บเรียงกันไป แบะส่วนที่ 2 จะเก็บจุดสิ้นสุดของสตริง ซึ่งจุสิ้นสุดของสตริงจะใช้ Null Characterหรือ ‘\0’

ตัวอักษรที่เก็บอยู่ในหน่วยความจำ ข้อมูลชนิดตัวอักษรต้องการหน่วยความจำเพียง 1 ส่วน ส่วนข้อมูลชนิดสตริงตัวอักษร 1 ตัว ต้องการหน่วยความจำ 2 ส่วน ส่วนแรกใช้เก็บข้อมูล และส่วนที่สองใช้เก็บจะสิ้นสุดของสตริง
char a[ ]={‘H’, ‘E’, ‘L’, ‘L’, ‘O’, ‘\0’};
char a[ ]=“HELLO”;
จะรู้ได้อย่างไรว่าตัวไหนเป็น Character ตัวไหนเป็น String ดูได้จาก Single quote กับ double quote = “”
double quote หรือฟันหนู หรืออัญประกาศ หรือเขาคู่ หรือเครื่องหมายคำพูด
single quote หรือ apostrophe หรือฝนทอง หรือเขาเดี่ยว

(ความยาวของสตริงจพถูกกำหนดโดยขนาดของสตริง)

การกำหนดตัวแปรสตริง
ในการกำหนดตัวแปรของสตริง อาศัยหลักการของอะเรย์ เพราะ สตริงก็คืออะเรย์ของอักขระที่ปิดท้ายด้วย null character (\0) และมีฟังก์ชันพิเศษสำหรับทำงานกับสตริงโดยเฉพาะ

ฟังก์ชัน getch() ใช้รับตัวอักขระ 1 ตัวจากแป้นพิมพ์ แต่ขณะรับไม่แสดงทางจอภาพ
ฟังก์ชัน gets() เป็นฟังก์ชันใช้สำหรับรับข้อมูลชนิด Stringหรือข้อความซึ่งป้อนทางแป้นพิมพ์
รับข้อมูลที่เป็นข้อความจากเป็นฟังก์ชันที่ใช้ในการแป้นพิมพ์เข้ามาเก็บไว้ในตัวแปรแบบอาเรย์ การใช้ฟังก์ชัน gets(); จะต้องมีการประกาศตัวแปรแบบอาเรย์ และกำหนดจำนวนตัวอักษร ที่ต้องการป้อน โดยคอมพิวเตอร์จะจองพื้นที่ไว้ตามจำนวนตัวอักษร แต่จะป้อนได้น้อยกว่าที่จองไว้ 1 ตัว เพื่อให้ตัวแปรเก็บ 0 อีก 1
รูปแบบการใช้งานฟังก์ชัน
ตัวอย่าง โปรแกรม
#include”stdio.h”
main()
{
char message[50];
printf(“ Enter a message(less than 49 characters)\n”);
gets(message);
printf(“ The message you entered is %s\n”,message);
}
ผลลัพธ์
Enter a message(less than 49 characters)
Kiss and say good-by
The message you entered is Kiss and say good-bye

อะเรย์ของสตริง
ถ้าหากมีสตริงจำนวนมาก ก็ควรจะทำให้เป็นอะเรย์ของสตริง เพื่อที่จะเขียน
โปรแกรมได้สะดวก การสร้างอะเรย์ของสตริง สามารถสร้างได้ทั้งแบบที่ให้ค่าเริ่มต้นและแบบที่กำหนดเป็นตัวแปร
อะเรย์ของสตริงที่ยาวไม่เท่ากัน

ฟังก์ชันอื่นที่ใช้กับสตริง การใช้สตริงนั้น จะมีฟังก์ชันในการกระทำกับสตริงอีกมาก จะช่วยให้การทำงานนั้นสะดวดมากยิ่งขึ้น ซึ่งการใช้ฟังก์ชันต่าง ๆ ที่เกี่ยวกับสตริงนั้นจะต้องนำเข้าไลบรารีไฟล์ strintg.h ด้วยเสมอ ซึ่งมีฟังก์ชันต่าง ๆ ดังนี้

ฟังก์ชั่นStrlen เป็นฟังก์ชั่นที่ใช้ในการหาขนาดความยาวของข้อความนั้นว่ามีความยาวของข้อมูลกี่ตัวอักษร
รูปแบบการใช้ฟังก์ชั่นint strlen (const char *string);
ตัวอย่างด้านล่างนี้เป็นการใช้ฟังก์ชัน strlenx = strlen(“Sorapong”);หรือ
char str[] = “Good Morning”;x = strlen(str);

คัดลอกสตริง ( strcpy, strncpy )ในภาษา C จะมีฟังก์ชันในการคะดลอกสตริงหนึ่งไปใส่ในอีกสตริงหนึ่ง อยู่ 2 ฟังก์ชัน คือ strcpy และ strncpy ทั้ง 2 ฟังก์ชันนี้ จะเป็นฟังก์ชันในการคัดลอกสตริง แต่ในฟังก์ชันที่ 2 สามารถกำหนดความยาวของสตริงที่ต้องการจะคัดลอกได้ strcpy ฟังก์ชัน strcpy เป็นฟังก์ชันในการคัดลอกสตริงพื้นฐาน การทำงาน คือ จะทำการคัดลอกสตริงต้นทั้งหมด ซึ่งจะรวมไปถึง Null Character ด้วย ไปใส่ในสตริงปลายทาง

โดยการประกาศฟังก์ชัน strcpy เป็นดังนี้char*strcpy (char *to_string, const char *from_string);ตัวอย่างด้านล่างนี้เป็นตัวอย่างการใช้ฟังก์ชัน strcpy strcpy(s1,s2);

เปรียบเทียบสตริง (strcmp,strncmp)ฟังก์ชันในการเปรียบเทียบสตริงในภาษา c จะมีอยู่ 2 ฟังก์ชัน คือ ฟังก์ชัน strcmp และฟังก์ชัน strncmp ซึ่งฟังก์ชันทั้งสองจะทำการเปรียบเทียบเหมือนกัน แต่ฟังก์ชัน strncmp จะกำหนดความยาวในการเปรียบเทียบได้ ซึ่งผลของฟังก์ชันที่จะส่งกลับมาให้จะมีดังนี้
1. ถ้าทั้ง 2 สตริงเท่ากันจะส่งค่ากลับมาเป็น 0 โดยที่สตริงจะเท่ากัน ได้จะต้องมีความยาวที่เท่ากัน แบะมีตัวอักษรเหมือนกันทุกตัว
2. ถ้าสตริงตัวแรกน้อยกว่าสตริงตัวที่สอง จะส่งค่ากลับเป็นค่าที่น้อยกว่า 0 โดยสตริง s1 จะน้อยกว่า s2 ก็เมื่อทำการเปรียบเทียบไปที่ละตัวอักษร แล้วพบว่าตัวอักษรใน s1 มีค่าน้อยกว่าตัวอักษรของ s2 (โดยเทียบจากรหัส ACSII) หรือจุดสิ้นสุดของ s1 อยู่ก่อน s2
3. ถ้าสตริงตัวแรกมากกว่าสตริงตัวที่สอง จะส่งค่ากลับเป็นค่าที่มากกว่า 0 สตริง s1 จะน้อยกว่า s2 ก็เมื่อทำการเปรียบเทียบไปที่ละตัวอักษรแล้วพบว่าตัวอักษรใน s1 มีค่ามากกว่าตัวอักษรของ s2 (โดยเทียบจากรหัส ACSII) หรือถ้าจุดสิ้นสุดของ s1 อยู่หลัง s2 Strcmp ฟังก์ชัน strcmp
การประกาศฟังก์ชันดังนี้char *strcmp(const char *string1, const char *string2);
ตัวอย่างด้านล่างนี้ เป็นตัวอย่างการใช้ฟังชัน strcmpif (strcmp(str1,str2) = = 0)
*ชุดคำสั่งเมื่อเท่ากัน*/else
;">/*ชุดคำสั่ง เมื่อไม่เท่ากัน*/
Strncmp ฟังก์ชัน strncmp จะกำหนดความยาวในการเปรียบเทียบได้
การประกาศฟังก์ชันดังนี้char *strncmp (const char *string1,const char *string2,int size);

ต่อสตริง (strcat, strncat)ฟังก์ชันที่ใช้ในการต่อสตริง มีฟังก์ชัน strcat และฟังก์ชัน strncat ซึ่งการทำงานของฟังก์ชันทั้งคือ จับสตริงชุดหนึ่งไปต่อท้ายกับสตริงอีกชุดหนึ่งstrcat การประกาศฟังก์ชัน strcat เป็นดังนี้char *strcat (const char *string1,const char *string2);strncat การประกาศฟังก์ชัน strncat เป็นดังนี้
char *strncat (const sschar*string1,const char *string2,int

สรุปข้อแนะนำการใช้ฟังก์ชันรับข้อมูล (input functions)
1. เมื่อต้องการรับค่าข้อมูล string ควรใช้ฟังก์ชัน gets( ) หรือ scanf( )
2. เมื่อต้องการรับตัวเลขหรือตัวอักษรเพียง 1 ตัว ที่ไม่ต้องการเห็นบนจอภาพ และไม่ต้องกดแป้น enter ควรใช้ฟังก์ชัน getch( ) แต่ถ้าต้องการเห็นบนจอภาพด้วยควรใช้ฟังก์ชัน getche( )
3. เมื่อต้องการรับข้อมูลตัวเลขที่มากกว่า 1 ตัว เช่น ตัวเลขจำนวนเต็มหรือตัวเลขทศนิยม ควรใช้ฟังก์ชัน scanf( )
4. กรณีที่ใช้ฟังก์ชัน scanf( ) รับข้อมูลติดต่อกันมากกว่า 2 ครั้ง อาจเกิดความผิดพลาดในการรับข้อมูล ดังนั้นจึงควรใช้คำสั่ง ch = getchar( ); คั่นก่อนที่จะรับข้อมูลครั้งที่ 3 โดยจะต้องมีคำสั่งประกาศตัวแปร char ch; ไว้ด้วย

DTS03-23-06-2552

อะเรย์ เป็นโครงสร้างข้อมูลแบบง่าย ที่พบมากในการเขียนโปรแกรมภาษาคอมพิวเตอร์ทุกภาษา และมักใช้เป็นพื้นฐานในการทำความเข้าใจโครงสร้างข้อมูลตัวอื่น ๆ อะเรย์ เป็นโครงสร้างข้อมูลที่เรียกว่า Linear List มีลักษณะคล้าย เซ็ตในคณิตศาสตร์ คือ อะเรย์จะประกอบด้วยสมาชิกที่มีจำนวนคงที่ มีรูปแบบข้อมูลเป็นแบบเดียวกับสมาชิกแต่ละตัวใช้เนื้อที่จัดเก็บที่มีขนาดเท่ากัน เรียงต่อเนื่องในหน่วยความจำหลัก อะเรย์ ถือเป็นโครงสร้างข้อมูลแบบสแตติค (Static data structure) โดยอะเรย์จะมีขนาดคงที่ เป็นแถวลำดับแบบอันดับ (Ordered list ) ที่ประกอบด้วยชุดของตัวแปรที่มีลักษณะเป็นช่องหลาย ๆ ช่องที่มีชื่อเดียวกัน สำหรับใช้เก็บข้อมูลชนิดเดียวกัน โดยข้อมูลที่อยู่ในช่องแต่ละช่อง จะเรียกว่า เป็นสมาชิกของอะเรย์
อะเรย์ มีคุณสมบัติหลัก ๆ ดังนี้
มีขนาดคงที่
ข้อมูลที่จัดเก็บแสดงผลออกมาแบบเรียงลำดับ (inorder)
สามารถดึงสมาชิกลำดับที่ i ใด ๆ ออกมาได้
สามารถแทนที่สมาชิกลำดับที่ i ใด ๆ ได้
สามารถเพิ่มสมาชิกใหม่เข้าไปในแถวลำดับได้
สามารถลบสมาชิกที่มีอยู่ออกจากแถวลำดับได้
การเข้าถึงข้อมูลใน Arrays
เราสามารถอ้างถึงสมาชิกทุกตัวภายในอาเรย์อย่างอิสระ ภายในขอบเขตของขนาดที่ได้ประกาศอะเรย์ไว้
โครงสร้างข้อมูลอะเรย์ (Array) เป็นโครงสร้างข้อมูลที่มีการจองพื้นที่หน่วยความจำ (Memory) เป็นชุด ๆ แต่ละชุดประกอบด้วยจำนวนช่องข้อมูลหลายช่อง พื้นที่แต่ละช่องข้อมูลจะอยู่ในตำแหน่งที่ต่อเนื่องกันไปตามลำดับ การเข้าถึงข้อมูล (Access) ข้อมูลใด ๆ ในโครงสร้าง สามารถกระทำได้โดยการระบุหมายเลขกำกับช่องข้อมูล ที่เรียกว่า ตัวดัชนี (Index) หรือบางครั้งเรียกว่า ตัวชี้ หรือ ซับสคริปต์ (Sub Script)
การกำหนด Array
การกำหนดอะเรย์จะต้องกำหนดชื่ออะเรย์ พร้อม subscript ซึ่งเป็น ตัวกำหนดขอบเขตของอะเรย์ มีได้มากกว่า 1 ตัว จำนวน subscript จะเป็นตัวบอกมิติของอะเรย์นั้น อะเรย์ที่มี subscript มากกว่า 1 ตัวขึ้นไป จะเรียกว่า อะเรย์หลายมิติ การกำหนด subscript แต่ละตัวจะประกอบไปด้วย ค่าสูงสุดและค่าต่ำสุดของ subscript นั้น การประกาศค่าตัวแปรอะเรย์ในภาษาคอมพิวเตอร์บางภาษา
ลักษณะโครงสร้างข้อมูลอะเรย์
ข้อกำหนดของการกำหนดค่าต่ำสุดและค่าสูงสุดของ subscript คือ
ค่าต่ำสุดต้องมีค่าน้อยกว่าหรือเท่ากับค่าสูงสุดเสมอ
ค่าต่ำสุด เรียกว่า ขอบเขตล่าง (lower bound)
ค่าสูงสุด เรียกว่า ขอบเขตบน (upper bound)
ค่า subscript ที่ใช้อ้างอิงถึงสมาชิก จะต้องมีค่ามากกว่า หรือเท่ากับขอบเขตล่าง และน้อยกว่าหรือเท่ากับขอบเขตบน
lower bound ≤ subscript ≤ upper bound ขนาดของ index แต่ละตัว ของ Array หาได้จาก ขนาดของ subscript = upper bound – lower bound + 1
อะเรย์ใช้ index ในการบ่งชี้ตำแหน่ง ดังนั้นการดึงข้อมูลและการจัดเก็บข้อมูลใดๆลงในอะเรย์ สิ่งที่ต้องคำนึงถึงคือ
ค่าต่ำสุด Lower bound ในแต่ละมิติ แทนด้วย L
ค่าสูงสุด Upper bound ในแต่ละมิติ แทนด้วย U
จำนวนหรือขนาดของอะเรย์ Range = ( U -L ) + 1

จำนวนสมาชิก หรือขนาดของอะเรย์ n มิติ หาได้จาก
ขนาดของอะเรย์ = ผลคูณของขนาดของ subscript แต่ละตัว
เช่น ขนาดของอะเรย์ A[1…
10] = Upper bound – lower bound+1
ขนาดของอะเรย์ K [1..5,1..10] = ผลคูณของขนาดของ subscript แต่ละตัว

Arrays หลายมิติ
การจัดเก็บอะเรย์ในหน่วยความจำหลัก จะใช้เนื้อที่ขนาดเท่ากัน เพื่อเก็บสมาชิกแต่ละตัว โดยเนื้อที่จะเรียงต่อเนื่องกัน การจัดเก็บอะเรย์ในหน่วยความจำหลัก จะพิจารณาตามประเภทของอะเรย์ในมิติต่าง ๆ ดังนี้
โครงสร้างข้อมูลอะเรย์หนึ่งมิติ (One-Dimensional Array)
โครงสร้างข้อมูลอะเรย์สองมิติ (Two-Dimensional Array)
โครงสร้างข้อมูลอะเรย์สามมิติ (Three-Dimensional Array)
รูปแบบ
Array
[l..u]
แถวลำดับ 1 มิติ
Array
[l1..u1,l2..u2]
แถวลำดับ 2 มิติ
Array
[l1..u1,l2..u2,l3..u3]
แถวลำดับ 3 มิติ
โครงสร้างข้อมูลอะเรย์หนึ่งมิติ (One-Dimensional Array)
คือ โครงสร้างข้อมูลแถวลำดับที่มีการจัดเก็บข้อมูลต่อเนื่องกันไปเป็นแถวต่อเนื่องกันตลอด ซึ่งเปรียบเหมือนกับตารางแถวเดียว โดยมีดัชนีอ้างอิงเพียง 1 ตัว
รูปแบบ data-type array-name[expression]
data-type คือ ประเภทของข้อมูลอะเรย์ เช่น int char float
array-name คือ ชื่อของอะเรย์
expression คือ นิพจน์จำนวนเต็มซึ่งระบุจำนวนสมาชิกของอะเรย์

ตัวอย่าง char a[4]; int num[10]; Char a[4];
หมายถึง คอมพิวเตอร์จะจองเนื้อที่ในหน่วยความจำสำหรับตัวแปร a ให้เป็นตัวแปรชุดชนิด character ขนาดสมาชิก 4 สมาชิก โดยหน่วยความจำจะเตรียมเนื้อที่ให้ 1 byte สำหรับ 1 ชื่อตัวแปร

ถ้าเป็นอะเรย์มิติเดียว สามารถทำได้ทั้งหมด 3 วิธี
1. มีการประกาศขนาดของอะเรย์ที่ทำหน้าที่ในการรับค่า
ตัวอย่าง
#define N 5; void display(int b[N]) { int i; for(i=0; i
2. ไม่ต้องมีการประกาศขนาดของอะเรย์ที่ทำหน้าที่ในการรับค่า
ตัวอย่าง
void display(int b[ ]) { int i; for(i=0; i<10;i++) printf(“%d\t”,b[i]); printf(“\n”); }
3. ตัวแปรที่ทำหน้าที่รับค่าถูกกำหนดเป็นพอยน์เตอร์
ตัวอย่าง
void display(int *b);
การส่งผ่านอะเรย์ให้กับฟังก์ชันเป็นการส่งผ่านโดยการอ้างอิงเรียกว่า Pass by reference คือ ค่าของสมาชิกแต่ละตัวจะไม่ได้ถูกส่งไปให้ฟังก์ชันแต่ชื่อของอะเรย์จะถูกมองเป็นตำแหน่งในหน่วยความจำที่ใช้เก็บสมาชิกตัวแรกซึ่ง address นี้จะถูกส่งให้กับอาร์กิวเมนต์ที่ตรงกัน ดังนั้น อาร์กิวเมนต์จึงเป็น pointer ชี้ไปยังสมาชิกตัวแรกของอะเรย์
Pass by value คือ การส่งค่าไปยังฟังก์ชันที่ถูกเรียกใช้โดยส่งค่าของตัวแปรหรือค่าคงที่ไปโดยตรง ค่าของอาร์กิวเมนต์ที่ผ่านให้กับฟังก์ชันจะถูกคัดลอกส่งให้กับฟังก์ชัน และจะถูกเปลี่ยนแปลงเฉพาะภายในฟังก์ชันโดยค่าของอาร์กิวเมนต์ในโปรแกรมที่เรียกใช้จะไม่เปลี่ยนแปลง
Pass by reference คือ การส่งค่าไปยังฟังก์ชันที่ถูกเรียกใช้โดยส่งเป็นค่าตำแหน่งที่อยู่ของตัวแปรไปซึ่งหากภายในฟังก์ชันมีการเปลี่ยนแปลงค่าของอาร์กิวเมนต์ที่ส่งไป ก็จะมีผลทำให้ค่าของอาร์กิวเมนต์นั้นในโปรแกรมที่เรียกใช้เปลี่ยนไปด้วย

โครงสร้างข้อมูลอะเรย์สองมิติ (Two-Dimensional Array)

คือ โครงสร้างข้อมูลที่มีการจัดเก็บข้อมูลแบบตารางสองทางข้อมูลมีการจัดเรียงกันตามแนวแถว(Row) และ แนวหลัก (Column) การอ้างถึงข้อมูลต้องระบุตำแหน่งแถว และตำแหน่งหลักที่ข้อมูลนั้นอยู่
สำหรับ Array 2 มิตินั้น ในการเข้าถึงสมาชิกตัวใดต้องใช้ตัวบอกลำดับ2 ตัว โดยโครงสร้างสามารถมองได้ในลักษณะ Matrix หรือ Table คือ สมาชิกถูกจัดเรียงให้อยู่ในลักษณะแถว (Row) และคอลัมน์ (Column)
รูปแบบทั่วไปของโครงสร้างข้อมูลอะเรย์ 2 มิติ A[L1 : U1 , L2 : U2]
เมื่อ A คือ ชื่อของโครงสร้างข้อมูลอะเรย์
L1 คือ ค่าขอบเขตต่ำสุด (lower Bound) ของแถว U1 คือ ค่าขอบเขตสูงสุด (Upper Bound) ของแถว
L2 คือ ค่าขอบเขตต่ำสุด (lower Bound) ของหลัก U2 คือ ค่าขอบเขตสูงสุด (Upper Bound) ของหลัก
Structure คือ โครงสร้างที่สมาชิกแต่ละตัวมีประเภทข้อมูลแตกต่างกันได้ โดยที่ใน structure อาจมีสมาชิกเป็นจำนวนเต็ม ทศนิยม อักขระ อะเรย์หรือพอยเตอร์ หรือแม้แต่ structure ด้วยกันก็ได้
Structure กับ pointer
เราสามารถที่จะอ้างถึงที่อยู่เริ่มต้นของ structure ได้เหมือนกับตัวแปรอื่น ๆ โดยใช้ตัวดำเนินการ & ดังนั้น ถ้า variable เป็นตัวแปรประเภท structure &variable จะเป็นเลขที่อยุ่เริ่มต้นของตัวแปร
Pointer เป็นตัวแปรชนิดหนึ่งที่ทำหน้าที่เก็บตำแหน่งที่อยู่ (Address) ของตัวแปรที่อยู่ในหน่วยความจำ
ความรู้ทั่วไป
-Character หรือเรียกอีกอย่างหนึ่งว่า String
-การนับสมาชิกในอะเรย์ 1 มิติ ตัวที่หนึ่งต้องเริ่มที่ 0 เสอม
-วงเล็บคือสิ่งที่บอกฟัง์ชัน
-Input Process Output = IPO
-ถ้าตัวแปลที่เป็นตัวอักษรจะไม่ใช้ = เด็ดขาด จะใช้ “”
ความรู้นอกบทเรียน
-ดูแลตัวเองก่อนไปดูแลคนรอบข้าง
-การทำบุญให้ตัวเอง
-จิตอาสา จิตสาธารณะ
-การทำงานกับส่วนรวม

DTS02-23-06-2552

ความหมายของ Structure
หรือโครงสร้าง คือ กลุ่มของข้อมูลที่มีชนิดเหมือนกัน
หรือต่างกันก็ได้ซึ่งนำมารวมกลุ่มแล้วเรียกเป็นชื่อเดียวกัน
• Structure มีประโยชน์มากในการสร้างและจัดการโครงสร้างข้อมูลที่ซับซ้อน
ประเภทของตัวแปร
• ตัวแปรเดี่ยว คือตัวแปรที่ขณะใดขณะหนึ่ง จะเก็บข้อมูลได้ค่าเดียว เช่น
– char ch1;
– int x;
• ตัวแปรชุด คือตัวแปรที่เก็บข้อมูลประเภทเดียวกัน ได้หลายค่า เช่น
– int num[ ] = {5, 7, 1, 18, 20};
– float f[10];
• ตัวแปรชนิด Structure คือตัวแปรที่สามารถเก็บข้อมูลหลายประเภท ภายใต้ชื่อเดียวกัน
การประกาศชนิดข้อมูลแบบ Structure

รูปแบบของ structure
struct struct_name
{
type1 variable1;
type2 variable2;
...
typeN variableN;
} ;

ตัวอย่าง structure
struct Camera {
char series[20];
char brand[10];
float Price;
char type[20];
float effective;
float weight;
char type_picture[10];
char Memory_type[10];

จากตัวอย่าง เป็นการสร้างโครงสร้างข้อมูล ชื่อว่า Camera ซึ่งประกอบด้วยข้อมูล 8 ตัว คือ
series (char)
brand (char)
Price (float)
type (char)
effective (float)
weight (float)
type_picture (char)
Memory_type (char)

การประกาศตัวแปรแบบ Structure
struct Camera {
char series[20];
char brand[10];
float Price;
char type[20];
float effective;
float weight;
char type_picture[10];
char Memory_type[10];} ;
struct Camera product={"DST","SONY",5990.00,"compact",
10,135,"JPEG","Memory stick"};

การประกาศตัวแปรเป็นตัวแปรโครงสร้างชนิด Camera
จากรูปตัวอย่าง เป็นตัวแปรซึ่งมีชนิดข้อมูลเป็นข้อมูลแบบโครงสร้างชนิดใหม่ที่เรากำหนดขึ้นเองโดยใน 1 ตัวแปร สามารถเก็บข้อมูล series (รุ่น) , brand (ยี่ห้อ) ,Price (ราคา), type (ชนิดของกล้อง), effective (ความละเอียด), weight (น้ำหนัก), type_picture (ชนิดของรูปภาพ), Memory_type (ชนิดของความจำ)

การกำหนดค่าเริ่มต้นให้กับตัวแปรแบบ Structure
หลักการคล้ายกับการกำหนดค่าเริ่มต้นให้กับอาร์เรย์
• จะทำการกำหนดค่าเริ่มต้นไว้ในเครื่องหมาย { }และแยกแต่ละค่าออกจากกันด้วยเครื่องหมาย ,

การอ้างถึงตัวแปรที่เป็นสมาชิกของตัวแปรชนิด Structureการอ้างถึงตัวแปรที่เป็นสมาชิกของตัวแปรชนิดโครงสร้าง ทำได้โดยใช้
Struct Camera.product
โดย Struct Camera ชื่อตัวแปรชนิด Structure
product ชื่อตัวแปรที่อยู่ภายใน Structure

ตัวอย่าง
struct Camera {
char series[20];
char brand[10];
float Price;
char type[20];
float effective;
float weight;
char type_picture[10];
char Memory_type[10];
} ; struct Camera product

จากตัวอย่าง ถ้าต้องการนำตัวแปร Memory_type มาใช้งาน
จะอ้างถึงตัวแปร Memory_type ได้โดยใช้ product .Memory_type

โปรแกรม
#include
#include
int main(void)
{
struct Camera {
char series[20];
char brand[10];
float Price;
char type[20];
float effective;
float weight;
char type_picture[10];
char Memory_type[10];
} product;
strcpy(product .series,"DSC");
strcpy(product .brand,"SONY");
product.Price = 5990;
strcpy(product .type,"Compact");
product.effective = 10;
product.weight = 135;
strcpy(product .type_picture,"JPEG");
strcpy(product .Memory_type,"Memory stick");
printf("Series: %s\n”);
printf(“Brand: %s\n”);
printf(“Price: %f\n type: %s\n”);
printf(“effective pixel: %f\n”);
printf(“weight: %f\n”);
printf(“type picture :%s\n”);
printf(“Memory type:%s\n”);
product.series,product.brand,product.Price,
product.type,product.effective,product.weight,product.type_picture,
product.Memory_type);
return 0;
}
การแสดงผล
Series=DSC
Brand =SONY
Price =5990.00
effective pixel=10.00
weight=135.00
type picture= JPEG
Memory type= Memory stick

ประวัติ

นางสาวเอมิกา ศิริขันธ์ รหัสประจำตัว 50172792005

Miss.Amika Sirikhant

หลักสูตร การบริหารธุรกิจ (คอมพิวเตอร์ธุรกิจ) คณะวิทยาการจัดการ

มหาวิทยาลัยราชภัฏสวนดุสิต

E-mail: U50172792005@gmail.com