โครงสร้างข้อมูลและอัลกอริทึม
โครงสร้างข้อมูล (Data Structure) คืออะไร
คือ รูปแบบของการจัดระเบียบของข้อมูล ซึ่งมีอยู่หลายรูปแบบ เช่น เขตข้อมูล(Field), แถวลำดับ(Array), ระเบียน(Record), ต้นไม้(Tree), ลิงค์ลิสต์(Link List) เป็นต้น (ทักษิณา สวนานนท์, 2544, หน้า 161) [4]p.12คือ รูปแบบวิธีการจัดระเบียบของข้อมูลที่ได้จากการดำเนินการทางคณิตศาสตร์(Operations) เพื่อให้สามารถจัดการกับข้อมูลที่ใช้กับระบบคอมพิวเตอร์ได้ [4]p.12คือ การรวบรวมข้อมูลเป็นกลุ่มอย่างมีรูปแบบ เพื่อให้การนำข้อมูลกลับมาใช้ หรือประมวลผลอย่างมีประสิทธิภาพ ด้วยขั้นตอนวิธีที่หลากหลาย แล้วนำเสนอได้อย่างถูกต้องรวดเร็วตามลักษณะงานที่ต้องการคือ การนำกลุ่มของข้อมูลขนาดใหญ่มาจัดรูปแบบ เพื่อให้เครื่องประมวลผลและแสดงผลอย่างมีขั้นตอน โดยเริ่มจากการรวบรวม เพิ่ม ลบ หรือเข้าถึงข้อมูลแต่ละรายการ
โครงสร้างข้อมูล (Data Structure)
- บิท (Bit) คือ ข้อมูลที่มีขนาดเล็กที่สุด เป็นข้อมูลที่เครื่องคอมพิวเตอร์เข้าใจ และใช้งานได้ ได้แก่ 0 หรือ 1
- ไบท์ (Byte) หรือ อักขระ (Character) คือ ตัวเลข หรือ ตัวอักษร หรือ สัญลักษณ์พิเศษ จำนวน 1 ตัว
- ฟิลด์ (Field) หรือ เขตข้อมูล คือ ไบท์ หรือ อักขระตั้งแต่ 1 ตัวขึ้นไปรวมกันเป็นฟิลด์ เช่น เลขประจำตัว หรือ ชื่อพนักงาน
- เรคคอร์ด (Record) หรือระเบียน คือ ฟิลด์ตั้งแต่ 1 ฟิลด์ขึ้นไป ที่มีความสัมพันธ์เกี่ยวข้องกันมารวมกัน
- ไฟล์ (File) หรือ แฟ้มข้อมูล คือ หลายเรคคอร์ดมารวมกัน เช่น ข้อมูลที่อยู่นักเรียนมารวมกัน
- ฐานข้อมูล (Database) คือ หลายไฟล์ข้อมูลมารวมกัน เช่น ไฟล์ข้อมูลนักเรียนมารวมกันในงานทะเบียน แล้วรวมกับไฟล์การเงิน
- phrase "a picture is worth a thousand words" [2]p.1
- โครงสร้างข้อมูลพื้นฐาน ประกอบด้วยแบบของข้อมูลเบื้องต้น คือ 1)บิท(Binary) 2)อักขระ(Character) 3)ฟิลด์(Field) 4)เรคอร์ด(Record) 5)ไฟล์(File) 6)ฐานข้อมูล(Database) [4]p.12
- วิเคราะห์ปัญหา (Problem Analysis) คือ การแยกปัญหาใหญ่ออกเป็นส่วน เพื่อนำไปสู่การแก้ปัญหาแต่ละส่วน
- อัลกอริทึม (Algorithm) (มีความเป็นนามธรรมอยู่ในตัวเป็นธรรมชาติ)
- คือ กลุ่มของขั้นตอนหรือกฎเกณฑ์ที่จะนำพาไปสู่การแก้ปัญหา [3]p.37
- คือ ขั้นตอนวิธีที่ประกอ้บด้วยชุดคำสั่งเป็นขั้นเป็นตอนที่ชัดเจน และรับประกันว่าเมื่อได้ปฏิบัติถูกต้องตามขั้นตอนจนครบก็จะได้ผลลัพธ์ที่ถูกต้องตามต้องการ [3]p.37
- คือ รูปแบบของการกำหนดการทำงานอย่างเป็นขั้นตอน ซึ่งผ่านการวิเคราะห์และแยกแยะ เพื่อการแก้ปัญหาต่าง ๆ ตามลำดับขั้น อาจเลือกใช้ภาษาไทยหรือภาษาอังกฤษตามความถนัด เพื่อนำเสนอขั้นตอนของกิจกรรมก็ได้ [4]p.17
- รหัสเทียม หรือซูโดโค้ด (Pseudo Code)
- คือ รหัสจำลองที่ใช้เป็นตัวแทนของอัลกอริทึม โดยมีถ้อยคำหรือประโยคคำสั่งที่เขียนอยู่ในรูปแบบของภาษาอังกฤษที่ไม่ขึ้นกับภาษาคอมพิวเตอร์ใดภาษาหนึ่ง [3]p.37
- คือ การแสดงขั้นตอนวิธีการที่ใช้ภาษาเขียนที่เข้าใจได้ง่าย อาจใช้ภาษาไทยหรือภาษาอังกฤษก็ได้ขึ้นอยู่กับความสะดวกของผู้เขียนและกิจกรรมที่จะนำเสนอ มักใช้รูปแบบคล้ายประโยคภาษาอังกฤษเพื่ออธิบายรายละเอียดของอัลกอริทึม
- ผังงาน (Flowchart)
- คือ การแสดงขั้นตอนวิธีการที่ใช้สัญลักษณ์ที่เข้าใจได้ง่าย แต่ให้รายละเอียดได้น้อยกว่า
- คือ รูปภาพ (Image) หรือสัญลักษณ์(Symbol) ที่ใช้เขียนแทนขั้นตอน คำอธิบาย ข้อความ หรือคำพูด ที่ใช้ในอัลกอริทึม (Algorithm) เพราะการนำเสนอขั้นตอนของงานให้เข้าใจตรงกัน ระหว่างผู้เกี่ยวข้อง ด้วยคำพูด หรือข้อความ ทำได้ยากกว่า [#]
- การโปรแกรมโครงสร้าง (Structured Programming) คือ การกำหนดขั้นตอนให้เครื่องคอมพิวเตอร์ทำงานโดยมีโครงสร้างการควบคุมพื้นฐาน 3 หลักการ ได้แก่ 1)การทำงานแบบตามลำดับ(Sequence) 2)การเลือกกระทำตามเงื่อนไข(Decision หรือ Selection) และ 3)การทำงานแบบทำงานซ้ำ (Repetition หรือ Iteration หรือ Loop) #
- อาร์เรย์ (Array)
- คือ ชุดของข้อมูลในชื่อเดียวกันที่มีได้หลายสมาชิก โดยสมาชิกถูกจัดเรียงเป็นลำดับ และมีรูปแบบเป็นแบบใดแบบหนึ่ง
- คือ การรวมกลุ่มของตัวแปรที่สามารถใช้ตัวแปรชื่อเดียวกันแทนข้อมูลสมาชิกได้หลาย ๆ ตัวในคราวเดียวกัน ด้วยการใช้เลขดรรชนี (Index) หรือซับสคริปต์ (Subscript) เป็นตัวอ้างอิงตำแหน่งสมาชิกบนแถวลำดับนั้น ๆ [3]p.80
- โอเปอเรชั่น (Operation) คือ การกระทำที่สามารถทำกับโครงสร้างนั้น เช่น โอเปอเรชั่นของอาร์เรย์ ได้แก่ 1)การท่องเข้าไป (Traversal) 2)การค้นหาข้อมูลที่ต้องการ(Searching) 3)การแทรกข้อมูลใหม่(Insertion) 4)การลบข้อมูล (Deletion) 5)การเรียงกลับหลัง(Reversing) 6)การเรียงลำดับ(Sorting) [1]p.14
- นามธรรม (Abstract) คือ เป็นแนวทางพื้นฐานของมนุษย์ที่ใช้จัดการกับความซับซ้อน (Grady Booch) [3]p.41 โดยเรื่องราวของนวนิยายเป็นจินตนาการในหัวของผู้เขียนถือเป็นนามธรรม เมื่อถ่ายทอดผ่านตัวแทน (Representation) ทางหนังสือด้วยภาษาต่าง ๆ ก็จะออกมาเป็นรูปธรรม ดังนั้นการเขียนโปรแกรมต้องเริ่มต้นด้วยนามธรรม หรือจินตนาการจัดการความซับซ้อนก่อนนำเสนอเป็นรูปธรรม เพื่อประมวลผล
- ชนิดข้อมูลนามธรรม (Abstract Data Type) คือ เครื่องมือกำหนดโครงสร้างข้อมูลที่ประกอบด้วยชนิดของโครงสร้างข้อมูล รูปแบบการดำเนินการ หรือแยกได้ 3 ส่วนคือ รูปแบบข้อมูล (Element) โครงสร้าง (Structure) และ การดำเนินการ (Operations) [4]p.25
- โปรแกรม (Program) คือ ตัวแทนของอัลกอริทึม
- โปรเซส (Process) คือ กิจกรรมที่ประมวลผลตามขั้นตอนของอัลกอริทึม
บทที่ 1
พื้นฐานโครงสร้างข้อมูล
วัตถุประสงค์เชิงพฤติกรรม (Behavioral Objectives)
หลังจากเรียนบทนี้แล้วนักศึกษาจะมีความสามารถดังนี้
1. ศึกษาขั้นตอนการพัฒนาซอฟต์แวร์
2. บอกลักษณะโครงสร้างข้อมูล + อัลกอริทึม = โปรแกรม
3. อธิบายความหมายโครงสร้างข้อมูล/ชนิดข้อมูล
4. เขียนโครงสร้างข้อมูลเบื้องต้นและโครงสร้างข้อมูลนามธรรม
5. เข้าใจโครงสร้างข้อมูลกับภาษาเขียนโปรแกรม
6. จัดบอร์ดเชิงปฏิบัติการ “พื้นฐานโครงสร้างข้อมูล”
7. สนทนาเชิงปฏิบัติการ “โครงสร้างข้อมูลเบื้องต้นและโครงสร้างข้อมูลนามธรรม”
8. อธิบายคำศัพท์ได้ 12 คำ
บทที่ 1 พื้นฐานโครงสร้างข้อมูล
คอมพิวเตอร์เป็นอุปกรณ์ที่สร้างขึ้นมาเพื่อใช้จัดการและเปลี่ยนแปลงข้อมูลข่าวสาร (Information) ดังนั้น จึงต้องมีการศึกษาถึงการควบคุมดูแลการทำงานของคอมพิวเตอร์ที่ยุ่งเกี่ยวกับข้อมูลข่าวสาร เมื่อมีการเปลี่ยนแปลงแก้ไขหรือเพื่ออำนวยประโยชน์ที่ต้องการการทำงานเพื่อนแก้ไขปัญหาต่าง ๆ ด้วยระบบคอมพิวเตอร์จะประกอบด้วยส่วนต่าง ๆ ทางด้านฮาร์ดแวร์ (Hardware) เช่น ซีพียู (CPU) หน่วยความจำ (Memory) อุปกรณ์รับส่งข้อมูล(Input/Output Device)และซอฟแวร์(Software)ที่นำมาใช้ควบคุมการทำงานของฮาร์ดแวร์ เพื่อแก้ไขปัญหานั้น ๆ ในการแก้ไขปัญหาจึงต้องมีกระบวนการพัฒนาซอฟต์แวร์ (Software Development) ที่เป็นขั้นตอนมาใช้ดังนี้
ขั้นตอนการพัฒนาซอฟแวร์
การแยกแยะและวิเคราะห์ปัญหา
ในขั้นตอนแรกเป็นการแก้ไขปัญหาโดยการวิเคราะห์และแยกแยะ สิ่งแรกที่ต้องพิจารณา คือ เอาต์พุต ที่ต้องการและมีข้อมูลข่าวสารอะไรบ้างที่ทำที่ทำให้สามารถแก้ไขปัญหาได้หลังจากพิจารณาเอ้าท์พุตก็คือพิจารณาอินพุต และมีข้อมูลข่าวสารอะไรบ้างที่ทำให้สามารถแกไขปัญหาได้ หลังจากแยกแยะเอ้าท์พุตและอินพุต รวมถึงข้อมูลข่าวสารที่ต้องการเสร็จสิ้นลงก้เป็นการพัฒนาเขียนอัลกอรึทึมและโปรแกรม
การออกแบบระบบ
เนื่องจากระบบคอมพิวเตอร์ไม่สามารถที่จะเข้าใจและแกไขปัญหาบางอย่างได้ จึงต้องมีวิธีการที่จะแก้ไขปัญหาโดยการออกแบบระบบ ซึ่งเป็นการวางแผนออกแบบที่แยกแยะออกเป็นปัญหาย่อย และพิจารณาสร้างชุดคำสั่งเพื่อแก้ไขปัญหาย่อยนั้น จากนั้นมารวมกันเป็นระบบที่สามารถแก้ไขปัญหาทั้งหมด มีลักษณะการวางแผนออกแบบจากบนลงล่าง (Top-down Design) ซึ่งประกอบด้วย 2 ส่วนหลัก ๆ คือ
1. โครงสร้างข้อมูล (Data Strutcure) ใช้ควบคุมและจัดการกับข้อมูลของปัญหานั้น ๆ หรือที่เรียกว่าชนิดข้อมูลมีโครงสร้าง เรียกสั้น ๆ ว่าชนิดข้อมูล เช่น ชนิดข้อมูลอาร์เรย์ ชนิดข้อมูลสแตก และชนิดข้อมูลลิ้งค์ ลิสต์ การออกแบบระบบต้องเลือกใช้โครงสร้างข้อมูลอย่างเหมาะสมเพื่อจัดการกับข้อมูลที่ใช้ในระบบ
2. การออกแบชุดคำสั่ง (Module Design) ในการแก้ไขปัญหาจะต้องมีกระบวนการทำงานเพื่อให้ได้มาซึ่งข้อมูลข่าวสารหรือเอ้าท์พุต ที่ต้องการโดยชุดคำสั่งเป็นส่วนประกอบของระบบ จึงต้องมีการออกแบบการทำงานที่เป็นชุดคำสั่งหรือโมดุลนั้นๆ และเรียกว่า อัลกอรึทึม ได้เป็น
โครงสร้างข้อมูล + อัลกอริทึม = โปรแกรม
การที่จะเลือกใช้โครงสร้างข้อมูลและอัลกอริทึมในการออกแบบให้การทำงานอย่สงมีประสิทธิภาพ ซึ่งถือว่าเป็นหัวใจสำคัญของการออกแบบซอฟต์แวร์จะพิจารณาได้จากลักษณะดังต่อไปนี้
1. ความถูกต้อง
2. ระยะเวลาการทำงาน
3. จำนวนพื้นที่ใช้งาน
4. ความเรียบง่าย
5. ความเหมาะสมที่สุด
การเขียนคำสั่งและรวมกัน
การเขียนคำสั่ง (Coding) คือ การเขียนคำสั่งต่าง ๆ ของโปรแกรมให้ทำงานเป็นไปตามโครงสร้างข้อมูลและอัลกอริทึมด้วยภาษาเขียน โปรแกรมภาหนึ่ง ถ้าโครงสร้างข้อมูลและอัลกอริทึมถูกออกแบบไว้เป็นอย่างดีทำให้กระบวนการแปลง คำสั่งจากภาษาเขียนให้เป็นภาษาเครื่องก็จะง่ายไม่ยุ่งยากลำบาก
การรวมกัน (Integration) เป็นกระบวนการนำคำสั่งต่าง ๆ ที่เขียนเป็นแต่ละชุดคำสั่งมารวมกันและให้มีการทำงานร่วมกันได้เป็นซอฟต์แวร์โปรแกรมขึ้นมา
การเขียนโปรแกรมที่ดีนั้นจะต้องมีความถูกต้องในการทำงาน สามารถอ่านคำสั่งและทำความเข้าใจได้ง่าย จึงต้องมีโครงสร้างการเขียนโปรแกรมที่ดี ซึ่งมีวิธีการเข้ามาช่วยเหลือในการเขียนโดยพิจารณาได้จากเรื่องต่อไปนี้
1. การเขียนโปรแกรมควรเป็นแบบบนลงล่าง (Top-Down) โดยเฉพาะกับปัญหาที่มีขนาดใหญ่หรือมีความซับซ้อน จึงควรแยกปัญหาใหญ่ออกเป็นปัญหาย่อย ๆ จากการเขียนคำสั่งทั้งหมดในโปรแกรม ก็แยกเป็นชุดคำสั่งย่อย ๆ
2. ใช้โครงสร้างควบคุมการทำงาน (Control Structure) ในการเขียนโปรแกรมหรือชุดคำสั่ง เช่น การใช้เงื่อนไข IF การใช้วนลูปแบบต่าง ๆ
3. ควรใช้ตัวแปรที่เป็นแบบโลคอล (Local Variable) และใช้กับชุดคำสั่งเพื่อแก้ปัญหาย่อย
4. ควรใช้ตัวแปรพารามิเตอร์ (Parameter) กับชุดคำสั่งเพื่อแก้ไขปัญหาย่อย หลีกเลี่ยงที่จะใช้ตัวแปรที่เป็นแบบโกลบอล และตัวพารามิเตอร์ควรมีการป้องกันหากมีการแก้ไขค่า
5. นำตัวแปรค่าคงที่ ( Constant Variable) มาใช้ จะช่วยให้การเขียนโปรแกรมมีความยืดหยุ่นมากขึ้นและอ่านเข้าใจง่าย
6. การเขียนโปรแกรมควรมีการจัดพื้นที่หรือบรรทัดว่างเพื่อให้อ่านสะดวก มีการย่อหน้าเพื่อจัดระดับของคำสั่งและมีลักษณะที่เป็นกรอบ
ทดสอบความถูกต้อง
1. การตรวจคำสั่ง (Validation) เป็นการตรวจสอบการเขียนโปรแกรมว่ามีความถูกต้องตามโครงสร้างของภาษาและทำงานตรงตามที่ต้องการหรือไม่
2. การตรวจสอบความจริง (Verification) เป็นการตรวจสอบขั้นตอนการทำงานของโปรแกรมว่ามีความถูกต้องและสอดคล้องกันหรือไม่
3. การทดสอบ (Testing) เป็นการทดสอบการทำงานว่าในแต่ละส่วนหรือชุดคำสั่งและการทำงานทั้งหมดในโปรแกรมมีความถูกต้องหรือไม่ มีการทดสอบแต่ละยูนิต ทดสอบการรวมกันของยูนิต
การดูแลระบบ
หลังจากการพัฒนาซอฟต์แวร์เสร็จสมบูรณ์และนำไปใช้งาน หากมีความต้องการที่จะเปลี่ยนแปลงแก้ไขเพื่อเติม หรือโปรแกรมมีปัญหาเกิดขึ้น จึงต้องมีการดูแลระบบ เพื่อนำกลับมาปรับปรุงแก้ไขใหม่ให้เป็นไปตามความต้องการ
ความหมายโครงสร้างข้อมูล/ชนิดข้อมูล
การทำงานของคอมพิวเตอร์จะมีการจัดการอย่างไรเพื่อให้ได้มาซึ่งข้อมูลข่าวสาร และสามารถนำมาใช้งานออกมาเป็นข้อมูลข่าวสารในรูปแบบต่าง ๆ ที่ทำความเข้าใจได้ แต่เนื่องจากคอมพิวเตอร์เป็นเพียงเครื่องจักรที่ไม่สามารถเข้าใจความหมายของข้อมูลข่าวสารได้เช่นเดียวกับคน จึงมีการกำหนดรูปแบบที่ใช้สื่อความหมายของข้อมูลข้าวสารให้คอมพิวเตอร์กับผู้ใช้งานเข้าในตรงกันเรียกว่า โครงสร้างข้อมูลหรือชนิดข้อมูล โดยแบ่งออกได้เป็นดังนี้
บิต (Bit)
เป็นหน่วยที่เล็กที่สุดในการทำงานของคอมพิวเตอร์ที่แสดงเป็นสถานะได้ 2 สถานะ คือ เปิดกับปิด จึงกำหนดเป็นการเก็บค่าได้ 2 ค่า คือ 0 กับ 1 เรียกว่าไบนารี่ดิจิต (Binary Digit)
ไบต์ (Byte)
เป็นการนำบิตหลาย ๆ บิตมาเรียงต่อรวมกันเพื่อกำหนดค่าได้มากขึ้น เช่น 3 บิต มาต่อเรียงกันจะทำให้เกิดสถานะที่ต่างกันคือ 000,001,010,100,011,010, และ 111 ก็จะได้เป็น 8 สถานะ เมื่อนำบิตมาเรียงต่อรวมกันเป็น 8 บิต เรียกว่าไบต์ มี 256 สถานะ และกำหนดเป็นโครงสร้างข้อมูลที่มีขนาดเล็กที่สุดที่ใช้งานได้ มีค่าตั้งแต่ 0 – 255 (00000000 – 11111111)
เลขจำนวนเต็ม (Integer)
เป็นการนำบิตหลาย ๆ บิตมาเรียงต่อรวมกันเพื่อกำหนดเป็นเลขจำนวนเต็ม ซึ่งได้เป็นระบบเลขฐานสอง โดยแต่ละบิตมีความหมายเป็นเลขยกกำลังสอง เช่น 20 = 1, 23 = 8 หรือ
21 + 22 +25 = 2+4+32 = 38 เลขที่ได้เป็นเลขจำนวนเต็มบวก ถ้าต้องการเป็นเลขจำนวนเต็มลบ จะต้องใช้วิธีการเรียกว่า One-complement Notation โดยการเปลี่ยนค่าของบิตที่เป็น 0 ให้เป็น 1 และค่าที่เป็น 1 ให้เป็น 0 เช่น 00100110 = 38 เมื่อสลับค่าจะได้บิต 11011001 = -38 ด้วยวิธีนี้ทำให้เก็บค่าได้ทั้งเลขจำนวนเต็มบวกและเต็มลบ ซึ่งมีบิตซ้ายสุดเป็นตัวกำหนดให้มีค่าบวกหรือลบเรียกว่า Sign Bit เมื่อนำบิตมาเรียงต่อกัน 16 บิตได้เป็นเลขจำนวนเต็มฐานสิบ มีอีกวิธีคือ Two-complement Notation โดยการบวกค่า 1 เข้าไปกับค่าของ One-complement Notation เช่นจาก 11011001 = -38 เมื่อบวก 1 จะได้ 11011010 = -38 เช่นกัน แต่วิธีนี้จำทำให้เก็บค่าได้มากกว่า คือ มีตั้งแต่ -2n-1 ถึง 2n-1 -1 ดังต่อไปนี้
1000000000000000 = -32768 0000000000000000 = 0
1000000000000001 = -32767 0000000000000001 = 1
1000000000000010 = -32766 0000000000000010 = 2
1111111111111101 = -3 0111111111111101 = 32765
1111111111111110 = -2 0111111111111110 = 32766
1111111111111111 = -1 0111111111111111 = 32767
เลขจำนวนจริง (Real Number)
เป็นรูปแบบของตัวเลขที่มีเลขทศนิยมเรียกว่า Floating – point Number โดยทำการแบ่งบิตออกเป็นสองส่วน โดยบิตที่อยู่ด้านซ้ายเก็บค่าเป็นตัวเลขจำนวนเต็ม เรียกว่า แมนทิสสา (Mantissa) การเก็บค่าเป็นแบบเดียวกับตัวเลขจำนวนเต็ม ส่วนบิตที่อยู่ด้านขวาเก็บค้าเป็นจำนวนหลักของ เลขทศนิยมเรียกว่า เอ็กซ์โพเนนท์ (Exponent) ในการเก็บจะใช้วิธี Two – complement Notation ซึ่งได้มาจากเลขยกกำลังของ 10 เช่น .01 = 10-2, 6.25 x 10-2 การเก็บค่าเลขทศนิยมจะใช้บิตจำนวน 32 บิต โดยแบ่งส่วนที่เป็นแมนทิสสาจำนวน 24 บิต และส่วนที่เป็นเอ็กซ์โพเนนท์จำนวน 8 บิต ดังนี้
00000000000000000000000000000000 = 0
00000000000000000000110000000011 = 12000
00000000000000000000010111111111 = 0.5
00000000000000000000010111111010 = 0.000005
11111111011010001001111111111110 = -387.53
ตัวอักษร (Character)
เป็นการเก็บค่าที่เป็นตัวอักษร แต่เนื่องจากคอมพิวเตอร์ไม่สามารถเข้าใจจึงใช้เลขจำนวนเต็มสื่อความหมายแทนโดยใช้บิตจำนวน 8 บิต เรียกว่า Bit String ซึ่งค่าตัวเลขที่ได้จะกำหนดเป็นตัวอกษรหนึ่งตัว ดังนั้นจะได้ตัวอักษรทั้งหมด 256 ตัวที่เรียกว่าเอ็บซีดิก (EBCDIC) เช่น
ตัวอักษรA จะมีค่า 01000001 = 65 หรือ B มีค่า 01000010 = 66 ประกอบด้วยอักษรตัวเล็ก ตัวใหญ่ ตัวเลข และตัวอักษรพิเศษ และที่ใช้เพียง 7 บิตเรียกว่าวหัสแอสกี (ASCII Code) ใช้ครึ่งเดียวของเอ็บซีดิกแต่การทำงานรวดเร็วกว่า เมื่อใดที่นำตัวอักษรหลาย ๆ ตัวมาเรียงต่อกันก็จะได้เป็นข้อความ เช่น AB จะได้เป็น 0100000101000010 หากต้องการเก็บจำนวนรูปแบบของตัวอักษรมากกว่านี้ก็สามารถทำได้โดยการเพิ่มจำนวนบิตเข้าไป ซึ่งขึ้นกับสถาปัตยกรรมของคอมพิวเตอร์จะรับได้หรือไม่ เช่นใช้ 10 บิตก็จะได้ตัวอักษร 1024 รูปแบบ
โครงสร้างข้อมูลเบื้องต้นและโครงสร้างข้อมูลนามธรรม
จากรูปแบบต่าง ๆ ของส่วนที่เป็นข้อมูลข่าวสาร คอมพิวเตอร์ไม่สามารถจะให้ความหมายได้ว่าคืออะไร แต่เมื่อนำการจัดการให้มีการทำงานที่เป็นรูปแบบตามที่กำหนดก็จะสามารถสื่อความหมายขึ้นมาได้ ด้วยกระบวนการจัดการแบบนี้จะเรียกว่าโครงสร้างข้อมูลหรือชนิดข้อมูลและด้วยวิธีการดังกล่าวจึงนำไปใช้ในการแก้ปัญหาต่าง ๆได้
โครงสร้างข้อมูลมีส่วนสำคัญในระบบคอมพิวเตอร์ ตัวแปรทุกตัวต้องมีการกำหนดชนิดข้อมูลซึ่งอาจเปิดเผยชัดเจน หรือปิดบังไว้ โครงสร้างข้อมูลเหล่านี้จึงมีลักษณะทางตรรกะ แต่ในทางกายภาพ อาจมีความแตกต่างกัน โครงสร้างข้อมูลสามารถแบ่งออกเป็นแต่ละประเภทดังในรูปที่ 1.1 ซึ่งแบ่งตามลักษณะวิธีการจัดเก็บข้อมูล
โครงสร้างข้อมูลเบื้องต้น
|
โครงสร้างข้อมูล
เรียบง่าย
|
โครงสร้างข้อมูลซับซ้อน
|
การจัดการแฟ้มข้อมูล
|
เชิงเส้น
|
ไม่เป็นเชิงเส้น
|
ไบนารี
|
N-อาร์เรย์
|
| เลขจำนวนเต็ม | อาร์เรย์ | สแตก | ไบนารีทรี | กราฟ | แฟ้มข้อมูลลำดับ |
| เลขทศนิยม | สตริง | คิว | ไบนารีเสิร์ชทรี | ทรี | แฟ้มข้อมูลโดยตรง |
| บูลีน | เรคคอร์ด | ลิ้งลิสต์ |
| เสิร์ชทรี M-ทาง | แฟ้มข้อมูลลำดับเชิงดัชนี |
| ตัวอักษร |
|
|
| บีทรี | แฟ้มข้อมูลหลายคีย์ |
|
|
|
| บี*-ทรีมบีพลัว-ทรี |
|
|
|
|
| ทราย |
|
รูปที่ 1.1 ประเภทของโครงสร้างข้อมูล
1. โครงสร้างข้อมูลเบื้องต้น (Primitive Data Structure) เป็นชนิดข้อมูลที่ไม่มีโครงสร้างข้อมูลอื่นมาเป็นส่วนประกอย เมื่อต้องการเก็บค่าสามารถเรียกใช้งานได้ทันที บางครั้งเรียกว่าชนิดข้อมูลพื้นฐาน (Base Type) หรือสร้างมาให้ใช้ด้วยภาษานั้น ๆ
ส่วน โครงสร้างข้อมูลแบบอื่น ๆ จะมีโครงสร้างข้อมูลอื่นเป็นส่วนประกอบ เมื่อต้องการใช้จะต้องกำหนดรูปแบบรายละเอียดโครงสร้างขึ้นมาก่อนเรียกว่า ข้อมูลชนิดผู้ใช้กำหนด
(Uses-defined Type) ดังนี้
2. โครงสร้างข้อมูลแบบเรียบง่าย (Simple Data Structure) จะมีสมาชิกที่เป็นโครงสร้างข้อมูลอื่นเป็นส่วนประกอบ มีรูปแบบง่าย ๆ ไม่ซับซ้อน สามารถทำความเข้าใจและสร้างขึ้นมาใช้งานได้ง่าย
3. โครงสร้างข้อมูลเชิงเส้น (Linear Data Structure) เป็นโครงสร้างที่ความซับซ้อนมากขึ้น ประกอบด้วยสมาชิกที่เป็นโครงสร้างข้อมูลอื่นจัดเรียงต่อกันเป็นแนวเส้น
4. โครงสร้างข้อมูลไม่เป็นเชิงเส้น (Nonlinear Data Structure) เป็นโครงสร้างที่มีความซับซ้อนเช่นกัน ประกอบด้วยสมาชิกที่เป็นโครงสร้างข้อมูลอื่นจัดเรียงกันในรูปแบบไบนารี่ ที่จัดเรียงสมาชิกมีการแยกออกเป็นสองทาง และแบบ N- อาร์เรย์ ที่จัดเรียงสมาชิกมีการแยกออกได้หลายทางหลายรูปแบบไม่แน่นอน
5. โครงสร้างการจัดการแฟ้มข้อมูล (File Organization) เป็นโครงสร้างสำหรับนำข้อมูลเก็บไว้ในหน่วยความจำสำรอง โดยข้อมูลจะอยู่ในรูปแบบโครงสร้างข้อมูลอื่น และมีวิธีการจัดการโดยการนำโครงสร้างข้อมูลอื่น ๆ มาช่วย
โครงสร้างข้อมูลต่าง ๆที่กล่าวมาอาจต้องมีการควบคุมการทำงานที่เกี่ยวข้องกับข้อมูลและส่วนที่มาเกี่ยวข้องให้เป็นไปตามที่ต้องการเรียกว่า โครงสร้างข้อมูลนามธรรม ลักษณะโครงสร้างจะแบ่งออกเป็น 2 ส่วน คือ ส่วนข้อมูลและส่วนปฏิบัติการ โดนภายในจะมีรายลเอียดการทำงานต่าง ๆ ประกอบด้วยโครงสร้างการจัดเก็บข้อมูลและอัลกอริทึม เมื่อใดที่เรียกใช้งานโครงสร้างนามธรรมในส่วนรายละเอียดการทำงานจะไม่ถูกเกี่ยวข้องหรือมีผลกระทบโดยถูกปิดบังไว้ จะเห็นว่าโครงสร้างข้อมูลซับซ้อนจะเป็นโครงสร้างข้อมูลนามธรรมที่ต้องมีส่วนการจัดเก็บข้อมูลและส่วนปฏิบัติการ
โครงสร้างข้อมูลกับภาษาเขียนโปรแกรม
ภาษาเขียนโปรแกรม (Programming Language) ช่วย ให้ผู้เขียนโปรแกรมสามารถกำหนดโครงสร้างข้อมูลที่มีความหมายให้กับตำแปร เนื่องจากตัวแปรเหล่านี้ต้องเก็บค่าตามลักษณะของโครงสร้างข้อมูลที่ได้กำหนด มาและส่วนของการปฏิบัติการที่ช่วยให้การทำงานกับโครงสร้างข้อมูลมีความถูก ต้อง ภาษาเขียนโปรแกรมหลายภาษาจะมีแนวทางที่แตกต่างกันในการกำหนดโครงสร้างข้อมูล มาให้ใช้ เช่น ภาษาซี(C) อนุญาตให้โครงสร้างข้อมูลตัวอักษรกับเลขจำนวนเต็มสามารถใช้ร่วมกันและคำนวณได้ ภาษาปาสคาล (Pascal) จะต้องประกาศตัวแปรอย่างชัดเจนว่ากำหนดโครงสร้างข้อมูลเป็นแบบใด ขณะที่ภาษาฟอร์แทรน(Fortran) เป็นการประกาศปิดบังไว้จึงไม่ต้องกำหนดโครงสร้างข้อมูลให้กับตัวแปร
บทที่ 2
โครงสร้างข้อมูลอาร์เรย์
จุดประสงค์เชิงพฤติกรรม (Behavioral Objectives)
หลังจากเรียนบทนี้แล้วนักศึกษาจะมีความสามารถดังนี้
1. ศึกษาโครงสร้างข้อมูลอาร์เรย์
2. แสดงตัวอย่างอาร์เรย์หนึ่งมิติ
3. แสดงตัวอย่างอาร์เรย์สองมิติ
4. แสดงตัวอย่างอาร์เรย์หลายมิติ
5. ยกตัวอย่างอาร์เรย์ในหน่วยความจำ
6. จัดบอร์ดเชิงปฏิบัติการ “โครงสร้างข้อมูลอาร์เรย์”
7. สนทนาเชิงปฏิบัติการ “อาร์เรย์ในหน่วยความจำ”
8. อธิบายคำศัพท์ได้ 10 คำ
บทที่ 2 โครงสร้างข้อมูลอาร์เรย์
ปกติ การเก็บข้อมูลที่มีเพียงค่าเดียวก็สามารถใช้โครงสร้างข้อมูลเบื้องต้น แต่เมื่อลักษณะของข้อมูลเริ่มซับซ้อนและมีจำนวนมากขึ้นจึงไม่เพียงพอที่จะ ใช้ข้อมูลโครงสร้างข้อมูลเบื้องต้นได้จึงต้องนำโครงการข้อมูลแบบอื่น ๆ มาใช้แทน โดยจะกล่าวถึงโครงสร้างข้อมูลอาร์เรย์ก่อน ซึ่งสามารถเก็บข้อมูลได้เป็นจำนวนมาก ๆ เป็นชุดของข้อมูลที่เกี่ยวข้องกัน
โครงสร้างข้อมูลอาร์เรย์
อาร์เรย์เป็นโครงสร้างข้อมูลแบบหนึ่งที่ผู้ใช้ต้องกำหนดคุณสมบัติขึ้นมาก่อน โดยที่อาร์เรย์ประกอบด้วยสมาชิกจำนวนหนึ่งที่เรียกต่อรวมกันตามลำดับที่ถูกมองเป็นตาราง สมาชิกทุกตัวจะมีชนิดข้อมูลที่เป็นแบบเดียวกัน ในการใช้อาร์เรย์เป็นการเข้าถึงแบบสุ่ม หรือโดยตรง เป็นการอ้างไปยังแต่ละสมาชิกที่ต้องการได้โดยตรง ซึ่งมีตัวชี้ใช้อ้างไปยังแต่ละสมาชิกเรียกว่าดัชนี หรือ Subscript และต้องเป็นเลขจำนวนเต็ม การกำหนดช่วงหรือจำนวนของสมาชิกจะใช้ขอบเขตล่าง ซึ่งมีค่าน้อยที่สุด และขอบเขตบน ซึ่งมีค่ามากที่สุดอาร์เรย์เป็นโครงสร้างข้อมูลที่คงที่ เปลี่ยนแปลงจำนวนสมาชิกไม่ได้ขณะทำงาน และเนื่องจากข้อมูลอาร์เรย์ถูกมองเป็นตารางในการใช้งาน จึงมีการกำหนดลักษณะของอาร์เรย์ออกเป็นมิติต่าง ๆ ได้ดังนี้
อาร์เรย์หนึ่งมิติ
อาร์เรย์หนึ่งมิติ (One-dimension Array) มีลักษณะที่ง่ายที่สุดเป็นตารางที่มีเพียงแถวเดียว บางครั้งก็เรียกว่าเว็กเตอร์ ดังในรูปที่ 2.1 เป็นอาร์เรย์หนึ่งมิติชื่อ Vec ที่ประกอบด้วยสมาชิก N ตัว
Vec(1)
|
Vec(2)
|
…
|
Vec(I)
|
…
|
Vec(N)
|
รูปที่ 2.1 ตัวอย่างเป็นอาร์เรย์หนึ่งมิติชื่อ Vec มีสมาชิก N ตัว
อาร์เรย์หนึ่งมิติจะมีดัชนีเพียงตัวเดียวใช้อ้างไปยังตำแหน่งของแต่ละสมาชิกในอาร์เรย์ซึ่งมีค่าเป็นลำดับ สมาชิกแต่ละตัวจะถูกแยกแยะตัวชื่ออาร์เรย์ตามด้วยดัชนีที่อยู่ในวงเล็บดังในรูป ดังนั้น เมื่อต้องการใช้อาร์เรย์ก็เพียงแต่กำหนดชื่อและใช้ดัชนีอ้างไปยังแต่ละสมาชิก การเขียนอัลกอริทึมจึงใช้โครงสร้างควบคุมการทำงานแบบวนลูปเพื่อใช้ควบคุมสมาชิกแต่ละตัว
การกำหนดอาร์เรย์หนึ่งมิติ
การกำหนดอาร์เรย์หนึ่งมิติจะมีรูปแบบที่กำหนดไว้เป็นดังนี้
V(L:U) = { V(I) }
สำหรับ I = L,L+1,…,U-1,U ซึ่งสมาชิกแต่ละตัว V(I) จะมีโครงสร้างข้อมูล T หมายความว่าอาร์เรย์ V มีสมาชิกที่มีโครงสร้างข้อมูล T และมีดัชนีมีค่าเริ่มจาก L ไปสิ้นสุดที่ U จะได้ช่วงดัชนีจาก L ไป U เท่ากับ U-L+1 ถ้าหากให้อาร์เรย์ V(1:N) จะได้ช่วงดัชนีเท่ากับ N ในการกำหนดค่าให้กับ L อาจเป็น 0 หรือเป็นค่าติดลบได้ เช่น V(-5:5) และมีช่วงดัชนีเท่ากับ 5-(-5)+1 = 11
ตัวอย่างการใช้อาร์เรย์หนึ่งมิติ
การนอาร์เรย์หนึ่งมิติมาใช้งานทำได้หลายหลายและมักนำไปใช้ร่วมกับโครงสร้างข้อมูลชนิดอื่น ๆ ดังตัวอย่างต่อไปนี้เป็นการบันทึกอุณหภูมิแต่ละชั่วโมงภายในหนึ่งวันหรือ 24 ชั่วโมง จะเห็นว่าสมาชิกถูกจัดลำดับตามช่วงระยะเวลาของวันสมาชิกเหล่านี้เป็นชนิดเดียวกัน คือ อุณหภูมิ ดังในตารางที่ 2.1 เป็นตัวอย่างโปรแกรม Temp1.c ที่ทำการบันทึกอุณหภูมิและแสดงผล
อาร์เรย์ที่สร้างขึ้นมาบันทึกอุณหภูมิมีชื่อว่า Temp โดยดัชนีจะมีค่าที่ขอบเขตล่างเท่ากับ 1 มีค่าที่ขอบเขตบนเท่ากับ 24 จะได้ว่า Temp(I) เป็นอุณหภูมิในช่วงโมงที่ I โดย 1? I ? 24 และการประกาศตัวแปร Temp ดังนี้
int Temp [24];
เนื่องจากต้องมีดัชนีใช้กับอาร์เรย์จึงประกาศป็นตัวแปร I ดังนี้
Int i;
การทำงานกับสมาชิกในอาร์เรย์จะใช้การวนลูปเพื่อเก็บค่า ดังนี้
rand ( time(NULL) );
for ( i = 0; i < 24; i++ )
Temp[i] = rand( ) %20+20;
เป็นการกำหนดค่าให้แต่ละสมาชิกโดยการสุ่มค่าให้ หลังจากนั้นทำการแสดงผลบนหน้าจอ ดังนี้
for ( i = 0; i < 24; i++ )
printf ( “%d”, Temp [i] );
การสร้างอาร์เรย์มาใช้งานจะมีโครงสร้างข้อมูลที่มาเกี่ยวข้อง 2 ชนิด เพื่อกำหนดให้สมาชิกในอาร์เรย์และกำหนดให้กับดัชนี นอกจากนี้การใช้ดัชนีอ้างไปยังสมาชิกเพียงบางตัวในอาร์เรย์อาจไม่จำเป็นต้องใช้การวนลูปมาช่วย
อาร์เรย์สองมิติ
อาร์เรย์สองมิติ (Tow-dimension Array) เป็นอาร์เรย์ที่สมาชิกมีโครงสร้างข้อมูลอาร์เรย์ ลักษณะเป็นตารางที่มีทั้งแถว และคอลัมน์ หรือเรียกว่าแมตทริก ดังในรูปที่ 2.1 เป็นอาร์เรย์สองมิติชื่อ Matrix ที่ประกอบด้วยสมาชิกใยแถว M ตัว แต่ละสมาชิกจะมีสมาชิกในคอลัมน์ N ตัว ก็จะได้เป็นตารางขนาด M ต่อ N
อาร์เรย์สองมิติจะใช้ดัชนีสองตัวเพื่ออ้างไปยังตำแหน่งของแต่ละสมาชิกแยกกัน โดยดัชนีตัวแรกใช้กับสมาชิกในแถว ส่วนตัวที่สองใช้กับสมาชิกในคอลัมน์ ดังนั้นสมาชิกอาร์เรย์ Matrix(I,J) จึงอยู่ในตำแหน่งแถวที่ I ตำแหน่งคอลัมน์ที่ J อาร์เรย์ Matrix จะเรียกว่าอาร์เรย์มิติ M ต่อ N แต่ละแถวมีสมาชิกเท่ากับ N แต่ละคอลัมน์มีสมาชิกเท่ากับ M จะได้สมาชิกทั้งหมดเท่ากับ M*N
การเขียนอัลกอริทึมเพื่อใช้อาร์เรย์สองมิติจะนำโครงสร้างควบคุมการทำงานแบบวนลูปมาใช้ 2 ลูป โดยส่วนใหญ่จะให้ลูปแรกอยู่ด้านนอกใช้ควบคุมสมาชิกในแถว ส่วนลูปที่สองซ้อนอยู่ภายในลูปแรกใช้ควบคุมสมาชิกในคอลัมน์
การกำหนดอาร์เรย์สองมิติ
การกำหนดอาร์เรย์สองมิติจะมีรูปแบบคล้ายกับอาร์เรย์หนึ่งมิติ ซึ่งการกำหนดจะเป็นดังนี้
M(L1:U1,L2:U2) = { M(I,J) }
สำหรับ L1 ? I ? U1 และ L2 ? I ? U2 ซึ่งสมาชิกแต่ละตัว M(I,J) จะมีโครงสร้างข้อมูล T
อาร์เรย์ M มีสมาชิกที่มีโครงสร้างข้อมูล T มีสมาชิกในแถวเท่ากับ U2 – L2 + 1 และมีสมาชิกในคอลัมน์เท่ากับ U1 – L1 + 1 ดังนั้นสมาชิกทั้งหมดจะเท่ากับ (U2 – L2 +1)*(U1 – L1 +1)
ตัวอย่างการใช้อาร์เรย์สองมิติ
ตัวอย่างที่จะกล่าวถึงเป็นการบันทึกอุณหภูมิแต่ละชั่วโมงภายในหนึ่งวันเช่นเดียวกับตัวอย่างอาร์เรย์หนึ่งมิติ แต่ต้องการจะเก็บอุณหภูมิทุกวันในหนึ่งสัปดาห์ จะเห็นว่าสมาชิกจะถูกจัดลำดับตามช่วงระยะเวลาชั่วโมงของวันและตามช่วงแต่ละวันในหนึ่งสัปดาห์ สำหรับตัวอย่างโปรแกรม คือ Temp2.C ดังในตารางที่ 2.2
อาร์เรย์ที่สร้างขึ้นมาชื่อ Temp มีดัชนีตัวแรกมีค่าที่ขอบเขตล่างเท่ากับ 1 มีค่าที่ขอบเขตบนเท่ากับ 7 ส่วนดัชนีตัวที่สองมีค่าที่ขอบเขตล่างเท่ากับ 1 มีค่าที่ขอบเขตบนเท่ากับ 24 จะได้ว่า Temp(I,J) เป็นอุณหภูมิในชั่วโมงที่ J ของวันที่ I โดย 1 ? I ? 7, 1 ? J ? 24 และการประกาศตัวแปร Temp ดังนี้
int Temp[4] [7] [24];
ดัชนีที่นำมาใช้มีตัวแปร i ใช้กับแถวละตัวแปร j ใช้กับคอลัมน์ ดังนี้
int i,j;
การทำงานกับสมาชิกในอาร์เรย์จะใช้การวนลูป 2 ลูปเพื่อเก็บค่า ดังนี้
srand ( time(NULL) );
for ( i = 0; i < 7; i++ )
for( j = 0; j < 24; j++ )
Temp[i] [j]= rand( ) %20+20;
กำหนดค่าให้สมาชิกโดยการสุ่มค่าให้ จากนั้นแสดงผลบนหน้าจอ ดังนี้
for ( i = 0; i < 7; i++ ){
printf ( "%d", Temp [i] [j] );
printf( "\n" );
}
การสร้างอาร์เรย์สองมอตอมาใช้งานนิยมใช้กับการวนลูปที่ซ้อนกัน 2 ลูป ดังนั้นสิ่งที่ควรพิจารณา คือ การใช้ลูปควบคุมสมาชิกในแถวกับคอลัมน์ควรเป็นอย่างไร จากตัวอย่างการเก็บอุณหภูมิจะเห็นว่าเวลาแต่ละชั่วโมงเป็นส่วนย่อยในแต่ละวัน แต่ละวันเป็นส่วนย่อยของสัปดาห์ การสร้างอาร์เรย์จึงใช้ส่วนหลักกำหนดเป็นแถวคือวัน ส่วนย่อยกำหนดเป็นคอลัมน์คือชั่วโมง เมื่อเขียนโปรแกรมก็จะใช้ลูปข้างนอกเป็นแถว ส่วนลูปข้างในเป็นคอลัมน์ ในกรณีที่เห็นว่าส่วนของแถวและคอลัมน์มีความสำคัญเท่ากัน อาจมีการเปลี่ยนสลับตำแหน่ง โดยการสลับดัชนีระหว่างของแถวและคอลัมน์จากอาร์เรย์ M ต่อ N ไปเป็นอาร์เรย์ N ต่อ M
อาร์เรย์หลายมิติ
การสร้างอาร์เรย์อาจเป็น สามมิติ สี่มิติ หรือมากกว่านั้นเรียกว่าอาร์เรย์หลายมิติหรือ N- มิติ ดัชนีและช่วงจำนวนสมาชิกก็จะเพิ่มมากขึ้นตามจำนวนมิติ อาร์เรย์ N-มิติจะใช้ค่าดัชนี N ตัวอ้างไปยังตำแหน่งสมาชิกแต่ละตัว การกำหนดอาร์เรย์ N-มิติจะเป็นดังนี้
M (L1:U1,L2:U2, …,Ln :Un)
แต่ละสมาชิกของอาร์เรย์จะถูกอ้างถึงโดยกำหนดเป็น M(I1,I2,…,In) ซึ่งแต่ละดัชนีที่
Ik ? Ik ? Uk สำหรับ k = 1,2,…,N จำนวนสมาชิกทั้งในอาร์เรย์ M เท่ากับ
(U1 – L1 +1) * (U2 – L2 +1) * … * (Un – Ln +1)
ตัวอย่างการใช้อาร์เรย์หลายมิติ
ตัวอย่างที่จะกล่าวถึงจะใช้อาร์เรย์สามมิติเพื่อบันทึกอุณหภูมิแต่ละชั่วโมงภายในแต่ละวันของสัปดาห์ และแต่ละสัปดาห์ภายในหนึ่งเดือน ดังนั้น สมาชิกของอาร์เรย์จะถูกจัดลำดับตามชั่วระยะเวลาชั่วโมงของวันและตามช่วงแต่ละวันในหนึ่งสัปดาห์ ช่วงแต่ละสัปดาห์ในหนึ่งเดือนได้เป็นตัวอย่างโปรแกรม คือ Temp3.c ดังในตารางที่ 2.3
อาร์เรย์ Temp มีดัชนีตัวแรกอยู่ในช่วง 1 ถึง 4 ตัวที่สองอยู่ในช่วง 1 ถึง 7 และตัวที่สามอยู่ในช่วง 1 ถึง 24 ซึ่งเป็นจำนวนสัปดาห์ วัน และชั่วโมงตามลำดับ จะได้ว่า Temp(I,J,K) เป็นอุณหภูมิในชั่วโมงที่ K ของวันที่ J ในสัปดาห์ที่ I การประกาศตัวแปร Temp ได้เป็นดังนี้
int Temp [7] [24];
เนื่องจากดัชนีหลายตัวอาจสับสนได้ง่าย จึงตั้งชื่อที่มีความหมายให้เข้าใจง่ายดังนี้
int week,day,hour;
และเป็นอาร์เรย์สามมิติการทำงานกับสมาชิกจึงต้องใช้การวนลูป 3 ลูปเพื่อเก็บค่าดังนี้
srand (time(NULL) );
for(week=0;week<4;week++)
for(day=0;day<7; day++)
for (hour=0;hour<24;hour++)
Temp[week] [day] [hour] = rand( ) %20+20;
หลังจากกำหนดค่าให้แต่ละสมาชิกจะแสดงผลบนหน้าจอดังนี้
for (week =0;week<4;week++){
printf ("Temperator of week %d \n", week+1);
for (day = 0; day<7; day++){
printf("Day %d \n", day+1);
for (hour =0; hour <24;hour++)
printf("%d",Temp[week] [day] [hour] );
printf("\n");
}
ตัวอย่างการเก็บอุณหภูมินี้อาจสร้างอาร์เรย์สี่มิติได้โดยเพิ่มการเก็บข้อมูลในช่วงระยะเวลาหนึ่งปี การสร้างอาร์เรย์หลายมิติเริ่มมีความซับซ้อนมากขึ้นและทำความเข้าใจยากจึงนำมาใช้งานน้อย จะมีที่ใช้คือ อาร์เรย์สามมิติดังในตัวอย่างซึ่งมีลักษณะเป็นกล่อง หรือลูกบาศก์ ดังแสดงในรูป 2.3 ที่ยังทำความเข้าใจได้ เป็นอาร์เรย์สามมิติชื่อ Triangle โดยมิติแรกมีช่วงระยะเท่ากับ 2 มิติที่สองมีช่วงระยะเท่ากับ 3 และมิติที่สามมีช่วงระยะเท่ากับ 5 จะมีสมาชิกทั้งหมดเท่ากับ 30 (M*N*P)
รูปที่ 2.3 ตัวอย่างการใช้อาร์เรย์สามมิติชื่อ Triangle มีสมาชิก 30 ตัว (M*N*P)
อาร์เรย์ในหน่วยความจำ
เช่นเดียวกับโครงสร้างข้อมูลอื่น ๆ ที่ต้องมีแนวทางในการเก็บลงในหน่วยความจำ ซึ่งอาร์เรย์มีได้หลายแนวทาง แบบแผนที่ต้องนำมาพิจารณาประกอบด้วย 4 ลักษณะพื้นฐาน คือ
1. การเข้าถึงเรียกใช้สมาชิกต้องมีความเรียบง่าย
2. ง่ายต่อการเข้าไปหาแต่ละสมาชิกที่มีหลายเส้นทาง
3. ประสิทธิภาพของการจัดเก็บที่ง่ายต่อการเข้าถึงแต่ละสมาชิก
4. ง่ายต่อการเพิ่มขนาดอาร์เรย์ให้มากขึ้น
การเก็บอาร์เรย์หนึ่งมิติในหน่วยความจำ
เมื่อพิจารณาพื้นที่ในหน่วยความจำที่จะเก็บอาร์เรย์หนึ่งมิติ เช่น อาร์เรย์ Vec ในรูปที่ 2.1 ซึ่งมีดัชนีที่ขอบเขตล่างเท่ากับ 1 ส่วนขอบเขตบนเท่ากับ N วิธีที่จะเก็บอาร์เรย์หนึ่งมิติในหน่วยความจำก็คือ ลำดับของสมาชิกในทางกายภาพ เรียงเป็นแบบเดียวกับลำดับของสมาชิกในทางตรรกะ ดังนั้น พื้นที่จัดเก็บสมาชิก Vec(I+1) จะอยู่ต่อเนื่องจากพื้นที่ จัดเก็บสมาชิก Vec(I) สำหรับ
I = 1,…,N-1 ในการคำนวณหาแอดเดรสเริ่มต้นของสมาชิก Vec(I) จำเป็นต้องทราบในเรื่องต่อไปนี้
1. ตำแหน่งแอดเดรสเริ่มต้นของพื้นที่หน่วยความจำที่จะเก็บอาร์เรย์ เรียกว่าตำแหน่งเริ่มต้น (Base Location)
2. ขนาดพื้นที่เก็บแต่ละสมาชิกของอาร์เรย์ กำหนดให้มีขนาด S ไบต์
การหาตำแหน่งแอดเดรสของสมาชิกอาร์เรย์ Vec ตัวที่ I จะได้ ดังนี้
B + (I – 1)*S
หรือกรณีที่ใช้ขอบเขตล่าง L เป็นดังนี้
B + (I – L)*S
เช่น มีอาร์เรย์ Vec(4:10) และต้องการหาตำแหน่งแอดเดรสของสมาชิก Ves(6) โดยตำแหน่งเริ่มต้นอยู่ที่แอดเดรส 2500 และแต่ละสมาชิกมีขนาด 80 ไบต์ ก็จะได้ตำแหน่งแอดเดรสอยู่ที่ 250 + (6 – 4) * 80 = 2660
การเก็บอาร์เรย์หลายมิติในหน่วยความจำ
เนื่องจากหน่วยความจำของเครื่องคอมพิวเตอร์มีลักษณะเป็นเชิงเส้น ดังนั้น อาร์เรย์หลายมิติ ตั้งแต่สองมิติขึ้นไป เมื่อนำไปจัดเก็บลงในหน่วยความจำจะต้องมีลักษณะแบบเชิงเส้นเช่นกัน
ลำดับแถวสำคัญ (Row-Major Order) ทางเลือกหนึ่งที่นำมาใช้คือเก็บสมาชิกทุกตัวของแถวแรกก่อน จากนั้นเก็บแถวที่สอง และสามไปเรื่อย ๆ ดังในรูปที่ 2.4 คือ อาร์เรย์ Mem(1:4,1:6) ซึ่งมีลักษณะรูปแบบตารางในทางตรรกะ
แบบแผนการจัดเก็บแบบลำดับแถวสำคัญนำมาใช้กับอาร์เรย์ในภาษาเขียนโปรแกรมหลายภาษา เช่น ภาษาโคบอล ภาษาปาสคาล และภาษาซี ถ้าต้องการทราบแอดเดรสเริ่มต้นของแต่ละสมาชิกในอาร์เรย์สองมิติจะมีวิธีการคำนวณ เช่นหาแอดเดรสเริ่มต้นของสมาชิก Mem(I,J) ในอาร์เรย์ Mem(L1:U1,L2:U2) จะได้ดังนี้
B + (I – L1) * (U2 – L2 + 1) *S + (J – L2) *S
สมมุติต้องการทราบแอดเดรสสมาชิก Mem(2,5) โดยตำแหน่งเริ่มต้นอาร์เรย์คือแอดเดรส 1000 และแต่ละสมาชิกในอาร์เรย์มีขนาด 8 ไบต์ ก็จะได้ 1000+(2-1)*(6-1+1)*8+(5-1)*8 = 1080
ลำดับคอลัมน์สำคัญ (Column – Major Order) เป็นอีกทางเลือกหนึ่งที่เก็บสมาชิกอาร์เรย์ในแนวเชิงเส้นโดยเก็บสมาชิกทุกตัวของคอลัมน์แรกก่อน จากนั้นเก็บคอลัมน์ที่สองและสามไปเรื่อย ๆ อาร์เรย์ Mem ในรูปที่ 2.4 เมื่อเก็บไว้ในหน่วยความจำแบบเชิงเส้นได้
แบบแผนการจัดเก็บแบบลำดับคอลัมน์สำคัญมีการใช้ภาษาเขียนโปรแกรม เช่น
ภาษาฟอร์แทรน ถ้าต้องการทราบแอดเดรสเริ่มต้นของแต่ละสมาชิกในอาร์เรย์สองมอตอจะมีวิธี การคำนวณหาของสมาชิก Men(I,J) จะได้ดังนี้
B + (J – L2) * (U1 – L1 + 1) *S + (I – L1) *S
ถ้าต้องการทราบแอดเดรสสมาชิก Men(2,5) แบบลำดับคอลัมน์ก็จะได้ 1000+(5-1)*(4-1+1)*8+(2-1)*8 = 1136
