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

จากการที่ข้าพเจ้าเรียนวิชา การเตรียมฝึกประสบการณ์วิชาชีพบริหารธุรกิจ ทำให้ข้าพเจ้าได้ความรู้จากการเรียน ดังนี้
1. ได้รู้จักการจัดระเบียบในตนเอง เช่น การตรงต่อเวลา การแต่งกายให้ถูกระเบียบ
2. รู้จักมารยาทในการนั่งฟังคำบรรยายจากวิทยากรในห้อง เช่น การไม่พูดกันเสียงดังหรือพูดแทรกระหว่างฟังคำบรรยาย
3. รู้จักการทำงานกันเป็นกลุ่ม ได้รับความรู้ใหม่ๆในเรื่องของการทำโครงการ การทำกิจกรรมร่วมกันกับตอนเรียนอื่น ช่วยให้รู้จักเพื่อนจากตอนเรียนอื่นมากขึ้น
4. จากการฟังคำบรรยายของวิทยากร ทำให้รู้จักสวนดุสิตมากขึ้น เช่น ประวัติของมหาวิทยาลัยราชภัฎสวนดุสิต สถานที่ต่างๆในมหาวิทยาลัย เป็นต้น
5. ได้รู้จักการพัฒนาบุคลิกภาพของตนเอง ตลอดจนวิธีการปรับปรุงบุคลิกภาพของตนเองให้ดูดีขึ้น
6. ได้เรียนรู้ทักษะทางด้านภาษา ทั้งภาษาไทยและภาษาอังกฤษ มีการทำแบบทดสอบทั้งแบบภาษาไทยและภาษาอังกฤษ ทำให้เข้าใจในเรื่องของการเขียนจดหมายสมัครงานเป็นภาษาอังกฤษมากขึ้น รู้จักการใช้ภาษาไทยในการพูดตามโอกาสต่างๆ การใช้คำราชาศัพท์ เป็นต้น
7. ได้เรียนรู้ประสบการณ์การทำงาน ในเรื่องการลงรับหนังสือเอกสาร งานถ่ายเอกสารต่างๆ จากการที่ได้ไปฝึกงานในห้องคณะวิทยาการจัดการ ก่อนการฝึกงานจริง
8. ได้ทราบถึงการประกันสุขภาพของสถานศึกษา ว่าถ้าสถานศึกษาได้ที่มีระบบการประกันสุขภาพจะทำให้สถานศึกษานั้นมีความน่าเชื่อถือ และเป็นสถานศึกษาที่มีมาตรฐาน

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

DTS : 11-16/09/2552

Summary B4 Final

ทรี (Tree)

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

การท่องไปในไบนารีทรี

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

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

ไบนารีเซิร์ชทรี (Binary Search Tree)
เป็นไบนารีทรีที่มีคุณสมบัติที่ว่าทุกๆโหนดในทรี ค่าของโหนดรากมีค่ามากกว่าค่าของทุกโหนดในทรีย่อยทางซ้าย และมีค่าน้อยกว่าหรือเท่ากับค่าของทุกโหนดในทรีย่อยทางขวาและในแต่ละทรีย่อยก็มี คุณสมบัติเช่นเดียวกัน

กราฟ (Graph)

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

การท่องไปในกราฟ
1. การค้นหาแบบกว้าง(Breadth-first Search) ในกราฟแบบไม่มีทิศทาง รายชื่อโหนดที่พบจากการค้นหา มีได้หลายรายการขึ้นกับลำดับการเรียงโหนดประชิด ในกราฟแบบมีทิศทาง การค้นหาโหนดทำได้ง่ายขึ้นถ้าใช้คิวเก็บลำดับของโหนดประชิดที่ต้องเยี่ยมต่อไป
2. การค้นหาแบบลึก (Depth-first Search)

กราฟมีน้ำหนัก หมายถึง กราฟที่ทุกเอดจ์มีค่าน้ำหนักกำกับ ซึ่งค่าน้ำหนักอาจสื่อถึงระยะทาง เวลา ค่าใช้จ่าย เป็นต้น

Sorting
การเรียงลำดับแบบเร็ว (quick sort)
เป็นวิธีที่ใช้เวลาน้อย เหมาะสำหรับข้อมูลที่มีจำนวนมากที่ต้องการความรววดเร็วในการทำงาน วิธีนี้จะเลือกข้อมูลจากกลุ่มข้อมูลขึ้นมาหนึ่งค่าเป็นค่าหลัก แล้วหาตำแหน่งที่ถูกต้องให้กับค่าหลักนี้ จากนั้นแบ่งข้อมูลจากค่าหลักออกเป็นสองส่วน ถ้าเป็นการเรียงลำดับจากน้อยไปหามาก ส่วนแรกอยู่ตอนหน้าของข้อมูล ทั้งหมดจะมีค่าน้อยกว่าค่าหลักที่เป็นตัวแบ่งส่วน อีกส่วนจะอยู่ตอนหลังของข้อมูล จะมีค่ามากกว่าค่าหลัก นำแต่ละส่วนย่อยไปแบ่งย่อยในลักษณะเดียวกันต่อไป จนกระทั่งไม่สามารถแบ่งส่วนย่อยได้อีก ถ้าเป็นการเรียงลำดับจากมากไปหาน้อยการเปรียบเทียบเพื่อหาตำแหน่งให้กับค่าหลักตัวแรกเริ่มจากข้อมูลในตำแหน่งแรกหรือสุดท้ายก็ได้ ถ้าให้ตำแหน่งที่ 1 เป็นค่าหลัก พิจารณาเปรียบเทียบค่าหลักกับข้อมูลในตำแหน่งสุดท้าย ถ้าค่าหลักมีค่าน้อยกว่าให้เปรียบเทียบข้อมูลในตำแหน่งรองสุดท้ายไปเรื่อยๆจนกว่าจะพบค่าน้อยกว่าค่าหลัก แล้วสลับตำแหน่งกัน เมื่อสลับตำแหน่งแล้วนำค่าหลักมาเปรียบเทียบกับข้อมูลในตำแหน่งที่ 2, 3 ไปเรื่อยๆจนกว่าจะพบ่าที่มีมากกว่าค่าหลัก ทำเช่นนี้ไปเรื่อยๆจนกว่าจะได้ตำแหน่งที่ถูกต้อง จากนั้นแบ่งข้อมูลออกเป็นสองส่วน ส่วนแรกข้อมูลทั้งหมดจะมีค่าน้อยกว่าค่าหลัก และส่วนที่สองข้อมูลทั้งหมดจะมีค่ามากกว่าค่าหลัก

การค้นหาข้อมูล (Searching)

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

วิธีการค้นหาข้อมูล
1. การค้นหาแบบเชิงเส้นหรือการค้นหาตามลำดับ(Linear) เป็นวิธีที่ใช้กับข้อมูลที่ยังไม่ได้เรียงลำดับ วิธีการ คือ นำข้อมูลที่จะหามาเปรียบเทียบกับข้อมูลลูกค้าแรกในแถวลำดับ ถ้าไม่เท่ากันให้เปรียบเทียบข้อมูลถัดไป ถ้าเท่ากันให้หยุดค้นหา
2. การค้นหาแบบเซนทินัล(Sentinel) เป็นวิธีที่การค้นหาแบบเดียวกับวิธีการค้นหาแบบเชิงเส้นแต่ประสิทธิภาพดีกว่าตรงที่เปรียบเทียบน้อยครั้งกว่า วิธีการ คือ

- เพิ่มขนาดของแถวลำดับ ที่ใช้เก็บข้อมูลอีก 1 ที่
- นำข้อมูลที่จะใช้ค้นหาข้อมูลใน Array ไปฝากที่ต้นหรือ ท้าย Array
- ตรวจสอบผลลัพธ์จากการหา โดยตรวจสอบจากตำแหน่งที่พบ ถ้าตำแหน่งที่พบมีค่าเท่ากับ n-1แสดงว่าหาไม่พบ นอกนั้นถือว่าพบข้อมูลที่ค้าหา
3. การค้นหาแบบไบนารี(Binary Search) การค้นหาแบบไบนารีใช้กับข้อมูลที่ถูกจัดเรียงแล้วเท่านั้น วิธีการ คือ ข้อมูลถูกแบ่งออกเป็นสองส่วน แล้วนำค่ากลางข้อมูลมาเปรียบเทียบกับคีย์ที่ต้องการหา

- หาตัวแทนข้อมูลเพื่อนำมาเปรียบเทียบกับค่าที่ต้องการค้นตำแหน่งตัวแทน หาได้จากสูตร

mid = (low+high)/2
mid คือ ตำแหน่งกลาง ,low คือ ตำแหน่งต้นแถวลำดับ
high คือ ตำแหน่งท้ายของแถวลำดับ

- นำผลการเปรียบเทียบ กรณีที่หาไม่พบมาใช้ในการค้นหารอบต่อไป

DTS : 10-09/09/2552

Sorting

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

วิธีการเรียงลำดับ
1. การเรียงลำดับแบบภายใน(Internal sorting) การเรียงข้อมูลทั้งหมดให้อยู่ในหน่วยความจำหลัก เวลาที่ใช้ในการเรียงจะคำนึงถึงเวลาที่ใช้ในการเปรียบเทียบ และเลื่อนข้อมูลภายในหน่วยความจำหลัก
2. การเรียงลำดับแบบภายนอก(External sorting) การเรียงข้อมูลในหน่วยความจำสำรอง เวลาที่ใช้ในการเรียงต้องคำนึงถึงเวลาที่เสียไประหว่างการถ่ายเทข้อมูลในหน่วยความจำหลัก

การเรียงลำดับแบบเลือก(Selection sorting)
ทำการเลือกข้อมูลมาเก็บในตำแหน่งที่ข้อมูลควรจะอยู่ทีละตัว โดยการค้นหาข้อมูลแต่ละรอบแบบเรียงลำดับจากน้อยไปหามาก
1) รอบแรกจะค้นหาข้อมูลที่น้อยที่สุดมาเก็บในตำแหน่งที่ 1
2) รอบสองนำตัวเลขที่มีค่าน้อยรองลงมาเก็บในตำแหน่งที่สอง
3) ทำเช่นนี้ไปเรื่อยๆจนครบทุกค่า การเรียงลำดับแบบเลือกเป็นวิธีที่ง่ายที่สุด แต่มีข้อเสียในการใช้เวลาจัดเรียงนาน เพราะแต่ละรอบต้องเปรียบเทียบข้อมูลทุกตัว ถ้ามีข้อมูล n ตัว ต้องเปรียบเทียบทั้งหมด n-1 รอบ และจำนวนครั้งในการเปรียบเทียบมีดังนี้
รอบที่ 1 มีการเปรียบเทียบ n-1 ครั้ง
รอบที่ 2 มีการเปรียบเทียบ n-2 ครั้ง
....
รอบที่ n-1 มีการเปรียบเทียบ 1 ครั้ง

การเรียงลำดับแบบฟอง(Bubble sort)
เป็นวิธีเรียงลำดับที่มีการเปรียบเทียบข้อมูลที่มีตำแหน่งติดกัน
1. ถ้าข้องมูลทั้งสองอยู่ตำแหน่งที่ไม่ถูกต้อง ให้สลับกันตำแหน่งกัน
2. ถ้ามีการเรียงลำดับข้อมูลจากน้อยไปมาก ให้นำข้อมูลที่มีค่าน้อยอยู่ก่อนข้อมูลที่มีค่ามาก ถ้าเรียงลำดับข้อมูลจากมากไปน้อย ให้นำข้อมูลที่มีค่ามากอยู่ก่อนที่มีค่าน้อย การเรียงลำดับข้อมูลแบบฟองเป็นวิธีการที่ไม่ซับซ้อน เป็นวิธีการที่นิยมใช้กันมากเพราะเป็นรูปแบบที่เข้าใจง่าย แต่มีประสิทธิภาพค่อนข้างต่ำ

การเรียงลำดับแบบเร็ว(Quick sort)
เป็นวิธีการเรียงลำดับที่ใช้เวลาน้อย ใช้กับข้อมูลที่มีจำนวนมากที่ต้องความรวดเร็วในการทำงาน วิธีนี้จะเลือกข้อมูลขึ้นมาหนึ่งค่าเป็นค่าหลัก แล้วหาตำแน่งที่ถูกต้องให้กับค่าหลัก เมื่อได้ตำแน่งที่ถูกต้องแล้ว ใช้ค่าหลักเป็นตัวแบ่งข้อมูลออกเป็นสองส่วน ถ้าเป็นการเรียงลำดับจากค่าน้อยไปหาค่ามาก ส่วนแรกอยู่ตอนหน้าของข้อมูล ข้อมูลทั้งหมดจะมีค่าน้อยกว่าค่าที่เป็นตัวแบ่งส่วนเสมอ

การเรียงลำดับแบบแทรก(Insertion sort) เป็นการเรียงลำดับที่เพิ่มสมาชิกใหม่เข้าไปในเซ็ต ที่มีการเรียงลำดับข้อมูลอยู่แล้ว แล้วทำให้เซ็ตใหม่มีการเรียงลำดับด้วย
1. เริ่มเปรียบเทียบข้อมูลตำแหน่งที่ 1 และ 2 หรือข้อมูลตำแหน่งสุดท้ายกับรองสุดท้าย
2. ถ้าเป็นการเรียงข้อมูลจากค่าน้อยไปมาก จัดเรียงข้อมูลที่มีค่าน้อยอยู่ก่อนข้อมูลที่มีค่ามาก ถ้าเป็นการเรียงข้อมูลจากมากไปน้อย จัดเรียงข้อมูลที่มีค่ามากอยู่ก่อนข้อมูลที่มีค่าน้อย

การเรียงลำดับแบบฐาน(Radix sort)
การเรียงลำดับโดยการพิจารณาข้อมูลทีละหลัก
1. พิจารณาจากค่าน้อยที่สุดก่อน โดยถ้าข้อมูลเป็นเลขจำนวนเต็มจะพิจารณาหลักหน่วยก่อน
2. จัดเรียงนำข้อมูลเข้ามาทีละตัว แล้วนำไปเก็บไว้ในที่ซึ่งจัดไว้สำหรับค่านั้นเป็นกลุ่มๆ ตามลำดับการเข้ามา
3. เมื่อจัดกลุ่มในแต่ละรอบแล้ว ให้รวบรวมข้อมูลทุกกลุ่มเข้าด้วยกัน โดยเริ่มเรียงจากลุ่มที่มีค่าน้อยสุด เรียงไปเรื่อยๆจนหมด
4. ในรอบต่อไปนำข้อมูลทั้งหมดที่จัดเรียงในหลักหน่วยเรียบร้อยแล้ว มาพิจารณาเรียงหลักสิบต่อไป ทำเช่นนี้ไปเรื่อยๆจนครบทุกหลัก วิธีการนี้เป็นวิธีที่ไม่ซับซ้อนแต่ใช้พื้นที่ในหน่วยความจำค่อนข้างมาก เนื่องจากการจัดเรียงแต่ละรอบต้องเตรียมเนื้อที่สำหรับสร้างที่เก็บข้อมูลในแต่ละกลุ่ม

DTS : 09-02/09/2552

Grapt

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

นิยามของกราฟ

1) โหนด(Node) หรือเวอร์เทกซ์(Vertexes)

2) เส้นเชื่อมระหว่างโหนด เรียก เอ็จ(Edges)

กราฟที่มีเอ็จเชื่อมโหนดสองโหนด ถ้าเอ็จไม่มีลำดับ เรียกว่า กราฟแบบไม่มีทิศทาง(Undirected Grapts) ถ้ากราฟเป็นเอ้จที่มีลำดับ เรียกว่า กราฟแบบมีทิศทาง(Directed Grapts) ถ้าต้องการอ้างชื่อเอ็จ สามารถเขียนชื่อเอ็จกำกับไว้ได้

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

กราฟแบบไม่มีทิศทาง เป็นเซตแบบจำกัดของโหนดและเอ็จ โดยเซ็ตว่างที่ไม่มีโหนดหรือเอ็จ เรียกว่า กราฟว่าง(Empty grapt) แต่ละเอ็จเชื่อมระหว่างโหนดสองโหนดหรือเชื่อมตัวเอง เอ็จที่ไม่มีทิศทางกำกับลำดับของการเชื่อมต่อไม่สำคัญ นั่นคือไม่มีโหนดใดเป็นโหนดแรก หรือโหนดใดเป็นโหนดสิ้นสุด

กราฟแบบมีทิศทาง เป็นเซตแบบจำกัดของโหนดและเอ็จ โดยเซ็ตอาจว่างไม่มีโหนดหรือเอ็จ เรียกว่า กราฟว่าง(Empty grapt) แต่ละเอ็จเชื่อมระหว่างโหนดสองโหนด เอ็จมีทิศทางกำกับแสดงลำดับของการเชื่อมต่อ มีโหนดที่เป็นโหนดแรก และมีโหนดสิ้นสุดการแทนกราฟในหน่วยความจำ

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

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

วิธีแอดจาเซนซีลิสต์(Adjacency) ใช้กับกราฟที่มีการเปลี่ยนแปลงตลอดเวลา ซึ่งมีวิธีคล้ายกับการจัดเก็บกราฟดวยโหนดและพอยเตอร์ ต่างกันตรงที่ใช้ลิงลิสต์แทน เพื่อความสะดวกในการเปลี่ยนแปลงแก้ไข

การท่องไปในกราฟ

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

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

DTS : 08-26/08/2552

Tree

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

นิยามของทรี
1. นิยามทรีด้วยนิยามกราฟ
ทรี คือ กราฟที่ต่อเนื่องโดยไม่มีวงจรปิด(loopในโครงสร้าง โหนด 2 โหนดในทรีต้องมีทางติดต่อกันทางเดียวเท่านั้น และทรีที่มี N โหนด ต้องมีกิ่งทั้งหมด N-1 เส้น
2. นิยามทรีด้วยรูปแบบรีเคอร์ซีฟ
ทรี ประกอบด้วยสมาชิก เรียกว่า โหนด โดยถ้าโหนดว่าง เรียกว่า นัลทรี(Null Tree)และถ้ามีโหนดหนึ่งเป็นโหนดราก ส่วนที่เหลือเป็นทรีย่อย(Sub Tree)

นิยามที่เกี่ยวข้องกับทรี
1. ฟอร์เรสต์(Forest) กลุ่มของทรีที่เกิดจากการเอาโหนดรากของทรีออก
2. ทรีมีแบบแผน(Ordered Tree) ทรีที่โนดต่างๆในทรีมีความสัมพันธ์ที่แน่นอน เช่น ไปทางซ้าย ไปทางขวา เป็นต้น
3. ทรีคล้าย(Similar Tree)ทรีที่มีโครงสร้างเหมือนกัน หรือทรีที่มีรูปร่างเหมือนกัน โดยไม่คำนึงถึงข้อมูลที่อยู่แต่ละโหนด
4. ทรีเหมือน(Equivalent Tree) ทรีที่เหมือนกันโดนสมบูรณ์ โดยต้องเป็นทรีที่คล้ายกันและแต่ละโหนดเดียวกันมีข้อมูลเหมือนกัน
5. กำลัง(Degree) จำนวนทรีย่อยของโหนดนั้นๆ
6. ระดับของโหนด(Level of Node) ระยะในแนวดิ่งของโหนดนั้นๆที่อยู่ห่างจากโหนดราก และจำนวนเส้นทางตามแนวดิ่งของโหนดใดๆ ซึ่งห่างจากโหนดราก เรียกว่า ความสูง หรือความลึก

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

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

การท่องไปในไบนารีทรี
1. การท่องแบบพรีออร์เดอร์(Preorder Traversal) เป็นการเดินเข้าไปเยือนโหนดต่างๆด้วยวิธี NLR มีขั้นตอน ดังนี้
- เยือนโหนดราก
- ท่องไปในทรีย่อยทางซ้ายแบบพรีออร์เดอร์
- ท่องไปในทรีย่อยทางขวาแบบพรีออร์เดอร์

2. การท่องไปแบบอินออร์เดอร์(Inorder Traversal)เป็นการเยือนโหนดต่างๆด้วยวิธี LNR มีขั้นตอน ดังนี้
- ท่องไปในทรีย่อยทางซ้ายแบบอินออร์เดอร์
- เยือนโหนดราก
- ท่องไปในทรีย่อยทางขวาแบบอินออร์เดอร์

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

DTS : 07-05/08/2552

Queue

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

การทำงานของคิว
- การใส่สมาชิกใหม่ลงไปในคิว เรียกว่า Enqueue คือ การใส่ข้อมูล newenqueue ลงไปในที่ส่วนเรียร์ของคิว - การนำสมาชิกออกจากคิว เรียกว่า dequeue คือ การนำออกจากส่วนหน้าของคิว และให้ข้อมูลนั้นกับ element

- การนำข้อมูลที่อยู่ตอนต้นของคิวมาแสดง เรียกว่า Queue Front
- การนำข้อมูลตอนท้ายของคิวมาแสดง เรียกว่า Queue Rear

การแทนที่ข้อมูลของคิว
สามารถทำได้ 2 วิธี
1. การแทนที่ข้อมูลแบบลิงค์ลิสต์
2. การแทนที่ข้อมูลแบบอะเรย์

การแทนที่ข้อมูลในคิวแบบลิงค์ลิสต์ ประกอบไปด้วย 2 ส่วน คือ
1. Head Node จะประกอบด้วย 3 ส่วน คือ พอยเตอร์จำนวน 2 ตัว คือ Front และ rear กับจำนวนสมาชิกในคิว
2. Date Node ประกอบไปด้วยข้อมูล และพอยเตอร์ชี้ไปยังข้อมูลตัวถัดไป
การแทนที่ข้อมูลในคิวแบบอะเรย์
การนำข้อมูลเข้าสู่คิว ไม่สามารถนำเข้าในขณะที่คิวเต็มได้ ถ้าพยายามนำข้าจะเกิดข้อผิดพลาด เรียกว่า overflow
การนำข้อมูลออกจากคิว จะไม่สามารถนำอะไรออกจากคิวที่ว่างเปล่าได้ ถ้าพยายามจะทำให้เกิดความผิดพลาด เรียกว่า underflow
วิธีการแก้ปัญหาในการนำเข้าข้อมูลในกรณีที่คิวเต็ม ในสภาพที่ front ไม่ได้อยู่ในช่องแรกของคิว ให้ใช้คิวที่เป็นวงกลม(Circular Queue) กรณีที่เป็นคิวแบบวงกลม คิวจะเต็มก็ต่อเมื่อมีการเพิ่มข้อมูลเข้าไปในคิวเรื่อยๆจนกระทั่ง rear มีค่าน้อยกว่า front อยู่หนึ่งค่า rear=front-1

การประยุกต์ใช้คิว
คิวถูกประยุกต์ใช้มากในการจำลองระบบงานธุรกิจ เช่น การใช้บริการลูกค้า ต้องวิเคราะห์จำนวนลูกค่าที่เหมาะสมว่าควรเป็นจำนวนเท่าใด เพื่อให้ลูกค้าเสียเวลาน้อยที่สุด ในด้านคอมพิวเตอร์ ใช้คิวในระบบปฎิบัติการ ในเรื่องของคิวของงานที่เข้ามาทำงาน(ขอใช้ทรัพยากรระบบของ CPU) จะจัดให้งานที่เข้ามาได้ทำงานตามลำดับความสำคัญ

iostream

การแปลงค่าชั่วโมงเป็นวินาที โดยรับค่าชั่วโมงทางแป้นพิมพ์


#include
main()
{
int hour,second;
printf("Enter your hour: ");
scanf("%d",&hour);
second=hour*60;
printf("Second is %d\n",second);
}


#include
main()
{
int hour,second;
cout<<"Enter your hour:";
cin>>hour;
second=hour*60;
cout<<"Second is "<}

DTS : 06-29/07/2552

Stack

สแตก (Stack) เป็นโครงสร้างข้อมูลแบบลิเนียร์ลิสต์ ที่มีคุณสมบัติที่ว่า การเพิ่มหรือลบข้อมูลในสแตก จะกระทำที่ ปลายข้างเดียวกัน เรียกว่า Top ของสแตก (Top Of Stack) ลักษณะที่สำคัญของสแตก คือ ข้อมูลที่ใส่หลังสุดจะถูกนำออกมา จากสแตกเป็นลำดับแรกสุด เรียกคุณสมบัตินี้ว่า LIFO (Last In First Out)

การดำเนินงานพื้นฐานของสแตก
1. Push การเพิ่มข้อมูลลงในสแตก คือ การนำเข้ามูลเข้าสู่สแตกโดยทับข้อมูลที่อยู่บนสุดของสแตก ข้อมูลจะสามารถนำเข้าได้เรื่อยๆ จนกว่าสแตกจะเต็ม สมมติว่าสแตคจองเนื้อที่ไว้ N ตัว ถ้าหากค่า TOP เป็น 0 แสดงว่าสแตคว่าง หากค่า TOP = N แสดงว่าสแตคเต็มไม่สามารถเพิ่มข้อมูลลงในสแตคได้อีก

2. Pop การนำข้อมูลออกจากส่วนบนสุดของสแตก การนำข้อมูลออกจากสแตก ถ้าสแตกมีสมาชิกเพียง 1 ตัว แล้วนำสมาชิกออกจากสแตก จะเกิดสภาวะสแตกว่าง (Stack Empty) คือ ไม่มีสมาชิกอยู่ในสแตกเลย
แต่ถ้าไม่มีสมาชิกในสแตก แล้วทำการ pop สแตก จะทำให้ เกิดความผิดพลาดที่เรียกว่า Stack Underflow

การแทนที่ข้อมูลของสแตค ทำได้ 2 วิธี คือ

1. การแทนที่แบบลิงค์ลิสต์ ประกอบด้วย 2 ส่วน คือ

- Head Node ประกอบด้วย top pointer และจำนวนสมาชิกในสแตค

- Data Node ประกอบด้วยข้อมูลและพอยเตอร์ที่ชี้ไปยังข้อมูลตัวถัดไป

2. การแทนที่แบบอะเรย์

การดำเนินการเกี่ยวกับสแตค
1. Create Stack จัดสรรหน่วยความจำและส่งค่าตำแหน่งที่ชี้ไปยัง 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 เป็นการลบข้อมูลในสแตคทั้งหมด

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

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

การคำนวณนิพจน์ทางคณิตศาสตร์
สามารถเขียนได้ 3 รูปแบบ คือ
1. นิพจน์ Infix นิพจน์รูปแบบนี้ operator จะอยู่กลางระหว่างตัวถูกดำเนินการ 2 ตัว
2. นิพจน์ Postfix นิพจน์รูปแบบนี้จะเขียนตัวดำเนินการตัวที่ 1 และ 2 แล้วตามด้วย operator
3. นิพจน์ Prefix นิพจน์รูปแบบนี้จะเขียน operator ก่อนแล้วจึงตามด้วยตัวถูกดำเนินการตัวที่ 1 และ 2
การเขียนโปรแกรมคอมพิวเตอร์ด้วยภาษาระดับสูง คำสั่งที่เป็นพจน์ทางคณิตศาสตร์จะเขียนในรูปแบบ Infix การคำนวณ โดยการที่ตัวแปนภาษาต้องทำการตรวจสอบนิพจน์จากซ้ายไปขวา เพื่อหาเครื่องหมายที่ต้องคำนวณ จึงเริ่มคำนวณได้ ทำแบบนี้ซ้ำๆจนกว่าจะคำนวณเครื่องหมายครบทุกตัว

ตัวอย่างการทำงานแบบ Lifo ที่ข้าพเจ้าเห็นในชีวิตประจำวัน

เช่น ยาสีฟัน ที่มีการบรรจุยาสีฟันส่วนที่อยู่ล่างสุด แต่เมื่อเราบีบยาสีฟันออกมาใช้ เราบีบส่วนที่อยู่บนสุดของหลอดบรรจุยาสีฟันออกมาใช้ก่อน

DTS : 05-22/07/2552

Linked List

ลิงค์ลิสต์ คือ วิธีการเก็บข้อมูลอย่างต่อเนื่องของอิลิเมนต์ โดยมีพอยเตอร์เป็นตัวเชื่อม แต่ละอิลิเมนต์ เรียกว่า โหนด แต่ละโหนดประกอบด้วย 2 ส่วน คือ

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

โครงสร้างข้อมูลแบบลิงค์ลิสต์
1. Head Structure ประกอบด้วย 3 ส่วน คือ จำนวนโนดแต่ละลิสต์, พอยเตอร์ที่ชี้ไปยังโหนดที่เข้าถึง และพอยเตอร์ที่ชี้ไปยังข้อมูลแรกของลิสต์
2. Data Node Structure ประกอบด้วยข้อมูลและพอยเตอร์ที่ชี้ไปยังข้อมูลตัวถัดไป

กระบวนงานและฟังก์ชั่นที่ใช้ดำเนินงานพื้นฐาน
1. กระบวนงาน Create List ทำหน้าที่สร้างลิสต์ว่าง
2. กระบวนงาน Insert Node ทำหน้าที่เพิ่มข้อมูลในลิสต์ บริเวณที่ต้องการ
3. กระบวนงาน Delete Node ทำหน้าที่ลบสมาชิกในลิสต์ บริเวณตำแหน่งที่ต้องการ
4. กระบวนงาน Search list ทำหน้าที่ค้นหาข้อมูลในลิสต์ที่ต้องการ
5. กระบวนงาน Traverse ทำหน้าที่ท่องไปในลิสต์เพื่อเข้าถึงและประมวลผล
6. กระบวนงาน Retrieve Node ทำหน้าที่หาตำแหน่งข้อมูลจากลิสต์
7. ฟังก์ชั่น EmptyList ทำหน้าที่ทดสอบว่าลิสต์ว่าง
8. ฟังก์ชั่น FullList ทำหน้าที่ทดสอบว่าลิสต์เต็มหรือไม่
9. ฟังก์ชั่น list count ทำหน้าที่นับจำนวนข้อมูลที่อยู่ในลิสต์
10. กระบวนงาน destroy list ทำหน้าที่ทำลายลิสต์

Linked List แบบซับซ้อน
1. Circular Linked List หรือลิงค์ลิสต์ทางเดียว โดยปกติการใช้ลิงค์ลิสต์ทางเดียว เมื่อตัวพอยเตอร์ P ชี้ไปยังโหนดหนึ่งจะไม่สามารถชี้กลับไปยังโหนดก่อนหน้านี้ได้ วิธีการอย่าหนึ่งที่ทำให้สามารถวิ่งจากโหนดหนึ่งไปยังโหนดอื่นๆได้ในลิงค์ลิสต์ โดยให้ชี้ของโหนดสุดท้ายซึ่งเดิมเป็นค่า Null
2. Double Linked List ลิงค์ลิสต์ที่มีการทำงาน 2 ทิศทาง บางครั้งการทำงานแบบลิงค์ลิสต์อาจต้องการวิ่งไปยังโหนกต่างๆในลิงค์ลิสต์โดยการถอยกลับไปยังโหนดก่อนหน้าหรือลบแต่ละโหนด เพื่อให้เกิดความสะดวกและประสิทธิภาพ จึงนำลิงค์ลิสต์ 2 ทางมาใช้แทนลิงค์ลิสต์ทางเดียว

แบบฝึกบทที่ 2

แบบฝึกหัดท้ายบทที่ 2

1. ให้นักศึกษากำหนดค่าของ Array 1 มิติ และ Array 2 มิติ
ตอบ char name[15];
int b[4][5];

2.ให้นักศึกษาหาค่าของ A[2],A[6]จากค่า A={2,8,16,24,9,7,3,8}
ตอบ A[2]=16
A[6]=3

3.จากค่าของ int a[2][3]={{6,5,4},{3,2,1}};ให้นักศึกษา หาค่าของ a[1][0]และ a[0][2]
ตอบ a[1][0]=3
a[0][2]=4

4.ให้นักศึกษากำหนด Structure ที่มีค่าของข้อมูลจากน้อย 6 Records
ตอบ struct student
#include int main()

{

struct

{

char name;

char lastname;

char address;

char phoneno;

int age;

char sex;

5.ให้นักศึกษาบอกความแตกต่างของการกำหนดตัวชนิด Array กับ ตัวแปร Pointer ในสภาพของการกำหนดที่อยู่ของข้อมูล
ตอบ Array คือโครงสร้างข้อมูลชนิดหนึ่งซึ่งจะรวบรวมตัวแปรชนิดเดียวกัน และมีลักษณะการใช้งานเหมือนกันมารวมอยู่ด้วยกันภายใต้ชื่อตัวแปรเดียวกัน เช่น ตัวเลขจำนวนเต็ม 10 จำนวน ตัวอักขระ 5 จำนวน ตัวเลขทศนิยม 15 จำนวน เป็นต้น
ลักษณะของตัวแปร Array ในโปรแกรมภาษาซี สังเกตจากชื่อตัวแปรจะต่างจากชื่อตัวแปรธรรมดาคือ ชื่อของตัวแปร Array จะมีตัวต่อท้ายเสมอ เช่น A[1],B[3],C[4] เป็นต้น ตัวเลขที่อยู่ในเครื่องหมาย [ ] เรียกว่า ตัวชี้หรืออินเด็กซ์ (Index)
ลักษณะการทำงานของตัวแปร Array คือเมื่อเราประกาศตัวแปร Array ในโปรแกรมภาษาซีแล้วเมื่อเราประมวลผลโปรแกรมภาษาซีขึ้นมา ตัวแปรภาษาซีจะทำการจองพื้นที่ในหน่วยความจำของเครื่องคอมพิวเตอร์ เช่น int A[5];
พอยน์เตอร์ คือ ตัวแปรอย่างหนึ่ง ที่มีลักษณะพิเศษกว่าตัวแปรชนิดอื่นๆ ตรงที่จะเก็บ “ ตำแหน่ง ” (address) ของตัวแปร ที่ใช้อ้างอิงไปยัง “ ค่า ” (value) ของตัวแปร ที่เก็บอยู่ในหน่วยความจำ (memory)
ดังนั้น สิ่งที่พอยน์เตอร์เก็บ คือ ตัวเลขที่บอกตำแหน่งในหน่วยความจำ เป็นเหตุที่ทำให้พอยน์เตอร์แตกต่างไปจากตัวแปรชนิดอื่นๆ ตรงที่ตัวแปรชนิดอื่นๆ จะเก็บค่าข้อมูล ตามชนิดของตัวแปรที่ได้เคยประกาศไว้

DTS : 04-15/07/2552

Set and String

โครงสร้างข้อมูลแบบเซ็ต
เป็นโครงสร้างข้อมูลแต่ละตัวที่ไม่มีความสัมพันธ์กัน

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

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

การกำหนดตัวแปร country แตกต่างกับการกำหนดตัวแปรอะเรย์ เพราะเป็นการกำหนดตัวแปรพอยเตอร์ 4 ตัว
ในการเขียนค่าเริ่มต้น คือ ค่าคงตัวสติง เขียนไว้ในเครื่องหมายวงเล็บปีกกา แล้วข้อมูลในเครื่องหมายคำพูด คือ ค่าคงตัวสติง
ฟังก์ขัน puts() ใช้พิมพ์สตริงออกทางจอภาพ โดยการผ่านแอดเดรสของสตริงไปให้เท่านั้น

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

การดำเนินการเกี่ยวกับสตริง
จะมีฟังก์ชันที่อยู่ในแฟ้ม ข้อมูล stdio.h เก็บอยู่ใน C Library อยู่แล้วสามารถนำมาใช้ได้ โดยการใช้คำสั่ง #include ในการเรียกใช้ เช่น
- ฟังก์ชัน strlen(str) ใช้หาความยาวของสตริง

- ฟังก์ชัน strcpy (str1,str2) ใช้คัดลอกข้อมูลจากสตริงหนึ่งไปอีกสตริงหนึ่ง

- ฟังก์ชัน strcat (str1,str2) ใช้เชื่อมต่อข้อความ 2 ข้อความเข้าด้วยกัน

- ฟังก์ชัน strcmp(str1,str2) ใช้เปรียบเทียบข้อความ 2 ข้อความว่ามีค่าเท่ากันหรือไม่

DTS : 01-24/06/2552

ทบทวนเรื่องภาษา C

คำสั่งพื้นฐานที่สำคัญๆของภาษา C

เช่น pintf, scanf
Format code ที่นิยมใช้ในการแสดงผล เช่น %d-decimal integer, %c-character, %f-floating point number, %s-string
นิพจน์ หมายถึง การนำตัวแปรค่คงที่มาสัมพันธ์กันโดยใช้เครื่องหมายอย่างใดอย่างหนึ่ง

เช่น x+1, a*b/c นิพจน์จะทำงานจากซ้ายไปขวา

ข้อดีของฟังก์ชัน

1. เขียนครั้งเดียว แต่ใช้ได้หลายครั้ง

2. สามารถนำกลับมาใช้ใหม่ในโปรแกรมอื่นได้

3. ถ้าต้องการแก้ไข จะแก้ไขเพียงที่เดียว

4. ทำให้โปรแกรมมีความเป็นโครงสร้าง สามารถแบ่งเป็นโมดูลย่อยๆได้

ประเภทของฟังก์ชัน

แบ่งเป็น 2 ประเภท คือ
1. Library Function เก็บไว้ในแฟ้ม C Library เรียบร้อยแล้ว ผู้ใช้สามารถเรียกใช้ได้เลย
วิธีเรียกใช้งาน Library Function
- เรียกชื่อของฟังก์ชันที่ต้องการใช้งาน
- เอาค่าที่จะส่งไปทำงานในฟังก์ชันใส่ในวงเล็บตามหลังชื่อฟังก์ชันนั้น
2. User Defined Function คือ ฟังก์ชั่นที่ผู้เขียนโปรแกรมสามารถเขียนฟังก์ชั่นขึ้นใฃ้เอง โดยฟังก์ชั่นนี้อาจรวมอยู่กับโปรแกรมหลักเป็นแฟ้มเดียวกัน หรือแยกฟังก์ชั่นเหล่านี้ไว้คนละแฟ้มข้อมูลก็ได้

Function Prototype
เป็นตัวบอกให้ compiler ทราบว่ามีการประกาศฟังก์ชั่นขึ้นและฟังก์ชันนั้นมีค่าที่ส่งกลับเป็นอะไร มีการรับพารามิเตอร์อะไรบ้าง มีประโยชน์ในการตรวจสอบข้อผิดพลาดระหว่างการเรียกใช้ฟังก์ชั่น เราจะเขียน Function Prototype ไว้ที่ต้นโปรแกรม เอาไว้เหนือฟังก์ชั่น main เพื่อให้ทุกฟังก์ชั่นสามารถเรียกใช้ได้

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

การผ่านค่า Argument ให้ฟังก์ชั่น

ทำได้ 2 แบบ คือ
1. Pass by value คือ การส่งค่าไปยังฟังก์ชันที่ถูกเรียกใช้โดยส่งค่าของตัวแปรหรือค่าคงที่ไปโดยตรง ค่าของอาร์กิวเมนต์ที่ผ่านให้กับฟังก์ชั่นจะถูกคัดลอกส่งให้กับฟังก์ชั่น และจะถูกเปลี่ยนแปลงเฉพาะภายในฟังก์ชั่น โดยค่าของอาร์กิวเมนต์ในโปรแกรมที่เรียกใช้จะไม่เปลี่ยนแปลง
2. Pass by reference คือ การส่งค่าไปยังฟังก์ชั่นที่ถูกเรียกใช้โดยส่งเป็นค่าตำแหน่งที่อยู่ของตัวแปรไป ซึ่งหากภายในฟังก์ชันมีการเปลี่ยนแปลงค่าของอาร์กิวเมนต์ที่ส่งไป ก็จะมีผลทำให้ค่าของอาร์กิวเมนต์นั้นในโปรแกรมที่เรียกใช้เปลี่ยนไปด้วย

ฝึกทบทวนโดยการเขียนโปรแกรมภาษาซี ถามตอบเกี่ยวกับโปรแกรมภาษาซี

DTS : 03-24/06/2552

Pointer

เป็นตัวแปรชนิดหนึ่งที่ทำหน้าที่เก็บตำแหน่งที่อยู่ (Address) ของตัวแปรที่อยู่ในหน่วยความจำ
การกำหนด address ให้ pointer วิธีนำเลข address ไปใส่ pointer ทำได้โดยใช้เครื่องหมาย & (address operator)

Pointer ที่เกิดจากเครื่องหมาย &
เมื่อเครื่องหมาย & ถูกใส่ไว้หน้าตัวแปรใดๆ ก็ตาม จะมีความหมายถึงค่าของตำแหน่งในหน่วยความจำที่ใช้เก็บค่าของตัวแปรนั้น ที่เราจะเห็นกันอยู่บ่อยๆ ก็คือ ในคำสั่ง scanf เช่น
int x;
scanf(“%d”,&x);
มีความหมายว่า ให้รับค่าทางคีย์บอร์ดแล้วให้แปลงเป็น integer แล้วนำไปใส่ในหน่วยความจำที่เป็นตำแหน่งของ x

*** เราสามารถอ้างถึงค่าที่อยู่ในตัวแปร x ได้โดยการใส่ * หน้า &x ก็จะมีความหมายเช่นเดียวกับ x นั่นเอง เช่น
x=5;
printf(“%d %d”, x, *(&x) );
ผลรัน จะเป็น 5

Pointer ที่เกิดจากการกำหนดตัวแปร array
การอ้างถึงชื่อของตัวแปร array โดยไม่ได้ระบุตัวชี้ลำดับ(subscript) จะหมายถึงตำแหน่ง(ในหน่วยความจำ)ของ array ตัวแรก ในภาษาซีจะไม่อนุญาตให้เปลี่ยนแปลงตำแหน่งของตัวแปร array ดังกล่าวได้ เช่น
char a[100];
a+=10; // error
ในกรณีนี้ &a จะมีความหมายเช่นเดียวกับ a ซึ่งก็คือค่าตำแหน่งในหน่วยความจำของ array ตัวแรกนั่นเอง
การประกาศชนิดของตัวแปรพอยน์เตอร์

รูปแบบ
type *variable-name
type หมายถึง ชนิดของตัวแปร
* หมายถึง เป็นเครื่องหมายที่แสดงว่าตัวแปรที่
ตามหลังเครื่องหมายนี้เป็นตัวแปรพอยน์เตอร์
variable-name เป็นชื่อของตัวแปรที่ต้องการประกาศว่าเป็น
ชนิดพอยน์เตอร์

ข้อสรุปเรื่อง pointer

• ทำหน้าที่ชี้ไปยังตำแหน่งเก็บข้อมูลในหน่วยความจำ
• การประกาศ pointer ต้องกำหนด data type ด้วย

structure

#include
#include
void main()
{
struct
{
char name[50];
char lastname[50];
int idcard;
char gender[10];
char address[100];
char phoneno[10];
char datein[20];
int roomno;
} frm_info;
clrscr(); /* Clear screen */
/* Display Enter Data */
printf("\nPlease Enter All\n");
printf("--------------\n");
printf("Name : ");
scanf(" %[^\n]", frm_info.name);
printf("Lastname: ");
scanf(" %[^\n]", frm_info.lastname);
printf("ID-Card : ");
scanf(" %d", &frm_info.idcard);
printf("Gender : ");
scanf(" %[^\n]", frm_info.gender);
printf("Address : ");
scanf(" %[^\n]", frm_info.address);
printf("Phone No. : ");
scanf(" %[^\n]", frm_info.phoneno);
printf("Date-In : ");
scanf(" %[^\n]", frm_info.datein);
printf("Room No. : ");
scanf(" %d", &frm_info.roomno);
printf("\n"); /* Move cursor to new line */
/* Display data in newfrm_info */
clrscr();
printf("\nReport Enter\n");
printf("--------------\n");
printf("\nName : %s",frm_info.name);
printf("\nLastname : %s",frm_info.lastname);
printf("\nID-Card : %d",frm_info.idcard);
printf("\nGender : %s",frm_info.gender);
printf("\nAddress : %s",frm_info.address);
printf("\nPhone No. : %s",frm_info.phoneno);
printf("\nDate-In : %s",frm_info.datein);
printf("\nRoom No. : %d\n",frm_info.roomno);
printf("--------------\n");
printf("\nWelcome to Dusit Apartment\n");
}

ประวัติ

ชื่อ นางสาวรุจี ใจสุข

Miss Rujee Jaisuk

รหัสนักศึกษา 50152792049

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

คณะวิทยาการจัดการ

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

E-mail blue_bugs-bunny@hotmail.com

DTS : 02-24/06/2552

Array and Record

Array

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

อะเรย์ 1 มิติ

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

การส่งอะเรย์ให้ฟังก์ชัน สามารถกำหนดอะเรย์เป็นพารามิเตอร์ให้กับฟังก์ชันได้ 2 ลักษณะ คือ
- การกำหนด array element เป็นพารามิเตอร์ส่งค่าให้กับฟังก์ชัน ทำโดยอ้างถึงชื่ออะเรย์พร้อมระบุ subscript
- ส่งอะเรย์ทั้งชุดให้ฟังก์ชัน ทำโดยอ้างถึงชื่ออะเรย์โดยไม่มี subscript

การประกาศอาร์กิวเมนต์ให้ฟังก์ชันเป็นอะเรย์
- มีการประกาศขนาดของอะเรย์ที่ทำหน้าที่ในการรับค่า
- ไม่ต้องมีการประกาศขนาดของอะเรย์ที่ทำหน้าที่ในการรับค่า
- ตัวแปรที่ทำหน้าที่รับค่าถูกกำหนดเป็นพอยน์เตอร์

อะเรย์ 2 มิติ

หมายถึง อะเรย์ที่มีสมาชิกโครงสร้างข้อมูลอะเรย์ ลักษณะเป็ตารางที่มีแถวและคอลัมน์ หรือเรียกว่า แมตทริก (Matrix)

Record or Structure
เป็นโครงสร้างข้อมูลที่ประกอบขึ้นมาจากข้อมูลพื้นฐานต่างประเภทกัน รวมเป็น 1 ชุดข้อมูล จะประกอบด้วย data element หรือ field ต่างประเภทกันอยู่รวมกัน ในภาษาซีคือการกำหนดข้อมูลเป็นรูปแบบ Structure
Structure คือ โครงสร้างที่สมาชิกแต่ละตัวมีประเภทข้อมูลแตกต่างกันได้ โดยที่ใน structure อาจมีสมาชิกเป็นจำนวนเต็ม ทศนิยม อักขระ อะเรย์ หรือพอยเตอร์ หรือแม้แต่ structure ด้วยกันก็ได้

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

รูปแบบ
structure-variable.element-name
structure-variable ชื่อตัวแปรชนิดโครงสร้าง
element-name ชื่อตัวแปรที่อยู่ใน structure

Structure กับ pointer

เราสามารถอ้างถึงที่อยู่เริ่มต้นของ structure ได้เหมือนกับตัวแปรอื่น โดยใช้ตัวดำเนินการ &

ดังนั้น ถ้า variable เป็นตัวแปรประเภท structure&variable จะเป็นเลขที่อยู่เริ่มต้นของตัวแปร นอกจากนี้ยัสามารถประกาศตัวแปรพอยน์เตอร์เป็น structure ได้

การผ่าน structure ให้ฟังก์ชัน

1. ส่งสมาชิกแต่ละตัวของ structure สามารถส่งเป็นอาร์กิวเมนต์ของฟังก์ชันและส่งกลับจากฟังก์ชันได้โดยใช้คำสั่ง return ซึ่งมีทั้งการส่งค่าของตัวแปรที่อยู่ในตัวแปร structure และส่งตำแหน่งที่อยู่ของตัวแปรนั้นๆไปยังฟังก์ชัน

2. ส่งผ่านทั้ง structure ให้กับฟังก์ชัน จะส่งผ่านในลักษณะของพอยเตอร์ไปยัง structure โดยหลักการจะเหมือนกับการส่งผ่านอะเรย์ไปให้ฟังก์ชัน ซึ่งเป็นลักษณะที่เรียกว่า Pass by reference