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

ภาพด้านบนสามารถมองเป็นมุมมองระดับบนสุดของบันไดที่คุณอยู่ที่ฐานของบันได แต่ละองค์ประกอบสามารถระบุได้โดยไม่ซ้ำกันโดยดัชนีของพวกเขาในอาร์เรย์ (ในลักษณะเดียวกับที่คุณสามารถระบุเพื่อนของคุณตามขั้นตอนที่พวกเขาอยู่ในตัวอย่างด้านบน)
อาร์เรย์มีขนาดคงที่เสมอหรือไม่ ?
ในภาษา C อาร์เรย์มีขนาดคงที่ซึ่งหมายความว่าเมื่อกำหนดขนาดแล้ว จะไม่สามารถเปลี่ยนแปลงได้ เช่น คุณไม่สามารถย่อขนาดหรือขยายได้ เหตุผลก็คือสำหรับการขยายหากเราเปลี่ยนขนาดเราไม่สามารถแน่ใจได้ (เป็นไปไม่ได้ทุกครั้ง) ว่าเราจะได้รับตำแหน่งหน่วยความจำถัดไปให้เราฟรี การลดขนาดจะไม่ทำงานเนื่องจากเมื่อประกาศอาร์เรย์จะได้รับการจัดสรรหน่วยความจำแบบสแตติกและคอมไพเลอร์เป็นคนเดียวที่สามารถทำลายได้
ประเภทของการทำดัชนีใน อาร์เรย์:
- 0 (การจัดทำดัชนีแบบอิงศูนย์): องค์ประกอบแรกของอาร์เรย์ถูกสร้างดัชนีโดยตัวห้อยเป็น 0
- 1 (การจัดทำดัชนีแบบใช้เดียว): องค์ประกอบแรกของอาร์เรย์ถูกสร้างดัชนีโดยตัวห้อยของ 1
- n (การจัดทำดัชนีแบบ N): สามารถเลือกดัชนีฐานของอาร์เรย์ได้อย่างอิสระ โดยปกติ ภาษาโปรแกรมที่อนุญาตให้สร้างดัชนีแบบ n จะอนุญาตให้มีค่าดัชนีเชิงลบ และชนิดข้อมูลสเกลาร์อื่นๆ เช่น การแจงนับ หรืออักขระอาจใช้เป็นดัชนีอาร์เรย์ได้

Array ถูกเตรียมใช้งานอย่างไร?
โดยค่าเริ่มต้น อาร์เรย์จะไม่ได้กำหนดค่าเริ่มต้น และไม่มีการตั้งค่าองค์ประกอบของอาร์เรย์เป็นค่าใดๆ อย่างไรก็ตาม สำหรับการทำงานที่เหมาะสมของอาร์เรย์ การเริ่มต้นอาร์เรย์จะมีความสำคัญ การเริ่มต้นอาร์เรย์สามารถทำได้ด้วยวิธีต่อไปนี้:
1. ไม่ผ่านค่าใด ๆ ภายในตัวเริ่มต้น:หนึ่งสามารถเริ่มต้นอาร์เรย์โดยการกำหนดขนาดของอาร์เรย์และไม่ผ่านค่าภายในตัวเริ่มต้น
ไวยากรณ์:
int arr[ 5 ] = { };
2. โดยการส่งผ่านค่าเฉพาะภายใน initializer: ผู้ใช้สามารถเริ่มต้นอาร์เรย์โดยการกำหนดขนาดของอาร์เรย์และส่งผ่านค่าเฉพาะภายใน initializer
ไวยากรณ์:
int arr [ 5 ] = { 1 , 2 , 3 , 4 , 5 };
หมายเหตุ: จำนวนองค์ประกอบภายใน “{ }” ต้องน้อยกว่าขนาดของอาร์เรย์
หากจำนวนองค์ประกอบภายใน “{ }” น้อยกว่าขนาดของอาร์เรย์ ตำแหน่งที่เหลือจะถือเป็น ‘ 0’.
ไวยากรณ์:
int arr[ 5 ] = { 1 , 2 , 3 } ;
3. โดยการส่งผ่านค่าเฉพาะภายใน initializer แต่ไม่ประกาศขนาด:สามารถเริ่มต้นอาร์เรย์โดยการส่งผ่านค่าเฉพาะภายใน initializer และไม่ได้ระบุขนาดโดยเฉพาะอย่างยิ่ง ขนาดจะถูกตีความโดยคอมไพเลอร์
ไวยากรณ์:
int arr[ ] = { 1 , 2 , 3 , 4 , 5 };
4. การเริ่มต้นสากล:หลังจากการปรับใช้การเริ่มต้นสากลใน C ++ เราสามารถหลีกเลี่ยงการใช้เครื่องหมายเท่ากับระหว่างการประกาศและการเริ่มต้น
ไวยากรณ์:
int arr[ ] { 1 , 2 , 3 , 4 , 5 };
หากต้องการทราบข้อมูลเพิ่มเติมเกี่ยวกับการเริ่มต้นอาร์เรย์คลิกที่นี่
การดำเนินการต่าง ๆ ในอาร์เรย์คืออะไร?
อาร์เรย์อนุญาตให้เข้าถึงองค์ประกอบโดยสุ่ม ทำให้เข้าถึงองค์ประกอบตามตำแหน่งได้เร็วขึ้น ดังนั้นการดำเนินการเช่นการค้นหา การแทรก และการเข้าถึงจึงมีประสิทธิภาพมาก องค์ประกอบอาร์เรย์สามารถเข้าถึงได้โดยใช้ลูป
1. การแทรกในอาร์เรย์:
เราพยายามแทรกค่าลงในตำแหน่งดัชนีอาร์เรย์เฉพาะ เนื่องจากอาร์เรย์ให้การเข้าถึงแบบสุ่ม ซึ่งสามารถทำได้ง่ายโดยใช้โอเปอเรเตอร์การกำหนด
รหัสหลอก:
// เพื่อแทรกค่า = 10 ที่ตำแหน่งดัชนี 2;
arr[ 2 ] = 10;
ความซับซ้อนของเวลา:
- O(1) เพื่อแทรกองค์ประกอบเดียว
- O(N) เพื่อแทรกองค์ประกอบอาร์เรย์ทั้งหมด [โดยที่ N คือขนาดของอาร์เรย์]
2. เข้าถึงองค์ประกอบใน Array:
การเข้าถึงองค์ประกอบอาร์เรย์มีความสำคัญอย่างยิ่งในการดำเนินการกับอาร์เรย์
รหัสหลอก:
// เพื่อเข้าถึงองค์ประกอบอาร์เรย์ที่ตำแหน่งดัชนี 2 เราก็สามารถเขียน
กลับ arr[ 2 ] ;
ความซับซ้อนของเวลา: O(1)
3. ค้นหาในอาร์เรย์:
เราพยายามค้นหาค่าเฉพาะในอาร์เรย์ เพื่อที่จะทำอย่างนั้นได้ เราจำเป็นต้องเข้าถึงองค์ประกอบอาร์เรย์ทั้งหมดและค้นหาค่าเฉพาะ
รหัสหลอก:
// ค้นหาค่า 2 ในอาร์เรย์;
วนรอบจาก i = 0 ถึง 5:
ตรวจสอบว่า arr[i] = 2:
คืนค่าจริงหรือไม่
ความซับซ้อนของเวลา: O(N) โดยที่ N คือขนาดของอาร์เรย์
- อาร์เรย์หนึ่งมิติ (อาร์เรย์ 1 มิติ)
- อาร์เรย์หลายมิติ
หากต้องการเรียนรู้เกี่ยวกับความแตกต่างระหว่างอาร์เรย์หนึ่งมิติและหลายมิติคลิกที่นี่
ข้อดีของการใช้อาร์เรย์:
- อาร์เรย์อนุญาตให้เข้าถึงองค์ประกอบโดยสุ่ม ทำให้เข้าถึงองค์ประกอบตามตำแหน่งได้เร็วขึ้น
- อาร์เรย์มี ตำแหน่ง แคช ที่ดีกว่า ซึ่งทำให้ประสิทธิภาพแตกต่างกันมาก
- อาร์เรย์แสดงรายการข้อมูลหลายประเภทเดียวกันโดยใช้ชื่อเดียว
ข้อเสียของการใช้อาร์เรย์:
คุณไม่สามารถเปลี่ยนขนาดได้ เช่น เมื่อคุณได้ประกาศอาร์เรย์แล้ว คุณจะไม่สามารถเปลี่ยนขนาดได้เนื่องจากการจัดสรรหน่วยความจำแบบคงที่ การแทรกและการลบในที่นี้ทำได้ยากเนื่องจากองค์ประกอบถูกจัดเก็บไว้ในตำแหน่งหน่วยความจำที่ต่อเนื่องกัน และการดำเนินการขยับก็มีค่าใช้จ่ายสูงเช่นกัน
ตอนนี้ถ้าใช้ตัวอย่างการใช้งานโครงสร้างข้อมูล Stack โดยใช้อาร์เรย์มีข้อบกพร่องบางอย่างที่เห็นได้ชัด
ลองใช้การ ดำเนินการ POPของสแต็ก อัลกอริทึมจะเป็นแบบนี้
- ตรวจสอบสแต็กอันเดอร์โฟลว์
- ลดระดับบนลง 1
สิ่งที่เรากำลังทำอยู่นี้คือ การที่ตัวชี้ไปยังองค์ประกอบบนสุดนั้นลดลง ซึ่งหมายความว่าเราแค่ถูกจำกัดมุมมองของเรา และจริงๆ แล้วองค์ประกอบนั้นยังคงอยู่ที่นั่นซึ่งกินพื้นที่หน่วยความจำ หากคุณมีอาร์เรย์ (เป็นสแต็ก) ของประเภทข้อมูลดั้งเดิมใดๆ ก็อาจใช้ได้ แต่ในกรณีของอาร์เรย์ของ Objects จะใช้หน่วยความจำมาก
แอปพลิเคชั่นบน Array
- Array เก็บองค์ประกอบข้อมูลของประเภทข้อมูลเดียวกัน
- อาร์เรย์จะใช้เมื่อทราบขนาดของชุดข้อมูล
- ใช้ในการแก้ปัญหาเมทริกซ์
- ใช้เป็นตารางค้นหาในคอมพิวเตอร์
- เร็กคอร์ดฐานข้อมูลยังใช้งานโดยอาร์เรย์
- ช่วยในการนำอัลกอริธึมการเรียงลำดับไปใช้
- ตัวแปรประเภทเดียวกันที่แตกต่างกันสามารถบันทึกได้ภายใต้ชื่อเดียว
- อาร์เรย์สามารถใช้สำหรับการตั้งเวลา CPU
- ใช้เพื่อปรับใช้โครงสร้างข้อมูลอื่นๆ เช่น Stacks, Queues, Heaps, Hash tables เป็นต้น
หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับข้อดี ข้อเสีย และการใช้งานอาร์เรย์คลิกที่นี่
คำถามที่พบบ่อย (FAQ) เกี่ยวกับ Array Data Structures
1. อาร์เรย์ในโครงสร้างข้อมูลมีตัวอย่างอย่างไร
อาร์เรย์คือชุดของรายการประเภทข้อมูลเดียวกันซึ่งจัดเก็บไว้ในตำแหน่งหน่วยความจำที่อยู่ติดกัน อดีต. int arr[5] = {1,2,3,4,5};
2. อาร์เรย์ 3 ประเภทมีอะไรบ้าง?
- อาร์เรย์ที่จัดทำดัชนี
- อาร์เรย์หลายมิติ
- แอสโซซิเอทีฟอาเรย์
3. โครงสร้างข้อมูลแบบใดเป็นอาร์เรย์
อาร์เรย์เป็นโครงสร้างข้อมูลเชิงเส้น
4. ความแตกต่างระหว่างอาร์เรย์และโครงสร้าง?
โครงสร้างสามารถมีตัวแปรประเภทต่างๆ ได้ แต่อาร์เรย์จะมีเฉพาะตัวแปรประเภทเดียวกันเท่านั้น
0 ความคิดเห็น