5. Traverse ทำหน้าที่ท่องหรือเยือนไปในลิสต์เพื่อเข้าถึงและประมวลผลนำเข้า ผลลัพธ์ที่ได้จะขึ้นอยู่กับการประมวลผล อย่างเช่น การรวมฟิลด์ในลิสต์ การเปลี่ยนแปลงค่าในโนด การคำนวณค่าเฉลี่ยของฟิลด์ เป็นต้น
6. Retrieve Node ทำหน้าที่หาตำแหน่งของข้อมูลที่อยู่ในลิสต์ ผลลัพธ์ที่ได้ก็คือ ตำแหน่งข้อมูลที่อยู่ในลิสต์ และเมื่อรู้ตำแหน่งก็ดึงค่าที่ได้มาแสดงในโปรแกรม
7. EmptyList ทำหน้าที่ทดสอบดูว่า ลิสต์ว่างหรือไม่ ผลลัพธ์ที่ได้คือ เป็นจริงและเป็นเท็จ กล่าวคือ จะเป็นจริงก็ต่อเมื่อลิสต์ว่าง และจะเป็นเท็จก็ต่อเมื่อลิสต์ไม่ว่าง
8. FullList ทำหน้าที่ในการทดสอบว่าลิสต์เต็มหรือไม่ ผลลัพธ์ที่ได้คือ เป็นจริงและเป็นเท็จ กล่าวคือ จะเป็นจริงก็ต่อเมื่อหน่วยความจำเต็ม และจะเป็เท็จก็ต่อเมื่อลิสต์นั้นสามารถมีโนดอื่น
9. List Count ทำหน้าที่นับจำนวนของข้อมูลที่อยู่ในลิสต์ ผลลัพธ์ที่ได้คือ จำนวนข้อมูลที่อยู่ในลิสต์นั้นๆ ซึ่งจะใช้ค่า count ที่อยู่ใน Head Node ออกมาแสดง
10. Destroy List ทำหน้าที่ในการลำลายลิสต์ หรือหยุดใช้ลิสต์นี้แล้ว
การสร้าง Linked List
*หมายเหตุ : ในการสร้าง Linked List สามารถเปลี่ยนรูปแบบได้ แต่ควรมีองค์ประกอบข้างต้น ให้ครบ
Linked List แบบซับซ้อน มี 2 แบบ คือ
1. Circular Linked List
จากภาพ จะมีการทำงานไปในทิศทางเดียวกันเท่านั้น คือ เป็นแบบวงกลม ซึ่งสังเกตได้จากลูกศรชี้การทำงานของ Linked List ซึ่งเป็นลิงค์ลิสที่สมาชิกหัวสุดท้าย ชี้ไปที่สมาชิกตัวแรกของลิงค์ลิสต์2. Double Linked List
จากภาพการทำงาน ข้อมูลจะมีตัวชี้ไปที่ข้อมูลก่อนหน้า หรือ backward pointer และตัวชี้ข้อมูลถัดไป หรือ forward pointer ซึ่งเป็นลิงค์ลิสต์ที่มีทิศทางการทำงานแบบ 2 ทิศทางStack
สแตก เป็นโครงสร้างข้อมูลแบบลิเนียร์ลิสต์ (linear list) ที่สามารถนำข้อมูลเข้าหรือออกได้ทางเดียว คือส่วนบนของสแตก หรือเรียกว่า ท๊อปของสแตก (Top of Stack) ซึ่งคุณสมบัติดังกล่าวเรียกว่า ไลโฟลิสต์ (LIFO list : Last-In-First-Out list) หรือ พุชดาวน์ลิสต์ (Pushdown List) คือ สมาชิกที่เข้าลิสต์ที่หลังสุดจะได้ออกจากลิสต์ก่อน หรือ เข้าหลังออกก่อน
การทำงานของสแตก มี 3 กระบวนการ ได้แก่
1. Push เป็นการนำข้อมูลใส่ลงไปในสแตก หรือการเพิ่มข้อมูลเข้าสแตก ก่อนที่จะมีการนำข้อมูลเข้าไปในสแตกจะต้องมีการตรวจสอบสแตกก่อน กล่าวคือ จะต้องมีการกำหนดตัวแปรชี้ตรงตำแหน่งยอดของสแตก ก่อนที่จะเพิ่มข้อมูลลงในสแตก และเพิ่มตำแหน่งให้ตัวแปรนั้นอีก 1 ตำแหน่ง เพราะหากมีการนำข้อมูลเข้าสู่สแตกที่เต็มก็จะทำให้เกิด "สแตกล้น" (overflow)
2. Pop เป็นการนำข้อมูลออกจากส่วนบนสุดของสแตก กรณีการนำข้อมูลออกจากสแตก จะต้องลดค่าตัวแปรชี้ตำแหน่งยอดของสแตกลงอีก 1 ตำแหน่งเช่นกัน ซึ่งหาก นำข้อมูลอกจากสแตกว่างเปล่าอาจจะเกิด "สแตกขาด" (underflow)
3. Stack Top เป็นการคัดลอกข้อมูลที่อยู่ส่วนบนสุดของสแตก แต่ไม่ได้นำข้อมูลนั้นออกจากสแตก เพราะเป็นการคัดลอกข้อมูลมาดูก่อน ยังไม่ได้เรียกใช้งานเลย
ตัวอย่างการทำงานแบบโครงสร้างข้อมูลแบบสแตกที่สามารถเห็นได้ในชีวิตประจำวันทั่วไป ได้แก่
- การวางจานซ้อนกันต้องวางจานลงบนกล่องเก็บจานจากล่างสุดที่ละใบจนเต็มกล่อง เมื่อเราจะหยิบจานไปใช้ เราก็ต้องหยิบใบบนสุด ซึ่งเป็นจานที่ถูกวางเก็บเป็นอันดับสุดท้ายออกได้เป็นใบแรก และสามารถหยิบออกที่ละใบจากบนสุดเสมอ
- ถาดอาหารในห้างสรรพสินค้า เมื่อลูกค้ามาใช้บริการอาหารในศูนย์อาหาร ลูกค้าจะหยิบถาดที่อยู่บนสุดของถาด ที่ยกมาเป็นชั้นสูง ๆ
- กระดาษทิชชู่แบบกล่อง ซึ่งเมื่อเราหยิบใช้กระดาษทิชชู่ เราจะต้องหยิบทิชชู่ที่อยู่บนสุดก่อนเสมอ
- การจำหน่ายตัวรถเมล์ ซึ่งพนักงานจะต้องฉีกจากใบนอกสุดของม้วนกระดาษ
- การหยิบกระดาษ A4 ที่บรรจุไว้ในกล่อง ซึ่งเราจะต้องหยิบจากใบที่อยู่ด้านบนสุดก่อนเสมอ
ส่วนอะเรย์ของสตริงที่ยาวเท่ากันจะมีลักษณะ ดังภาพด้านล่าง
การดำเนินการเกี่ยวกับสตริง จะใช้คำสั่ง #include ในการเรียกใช้ เช่น
ตัวอย่างเช่น int *ptr; คือ การประกาศว่าตัวแปร ptr เป็นตัวแปรพอยน์เตอร์ที่ใช้เก็บตำแหน่งเริ่มต้นที่จะใช้เก็บ integer
จากตัวอย่าง กำหนดให้
และใช้เป็น dereferencing operator ซึ่งจะใช้เมื่อต้องการนำค่า address ที่ตัวแปรนั้นชี้อยู่ออกมาแสดง