DTS07-11/08/2552

สรุปบทเรียนครั้งที่ 7

วันนี้อาจารย์ให้ส่งสมุดจดการบ้านและส่งงาน INFIX โดยมีการเช็คให้คะแนนในเวลาเรียน

ให้ไปอ่านเรื่องคิวเองเพราะนักศึกษาเสียงดัง

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

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

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

DTS06-04/08/2552

สรุปบทเรียนครั้งที่ 6

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

การทำงานของสแตกจะประกอบด้วยกระบวนการ 3 กรบวนการที่สำคัญ คือ
1.Push คือ การนำข้อมูลใส่ลงไปในสแตก เช่น สแตก s ต้องการใส่ข้อมูล i ในสแตกจะได้ push (s,i) คือใส่ข้อมูล i ลงไปที่topของสแตก s
2.Pop คือการนำข้อมูลออกจากส่วนบนสุดของสแตก เช่น ต้องกานำข้อมูลออกจากแสตก s ไปว้ที่ตัวแปร i จะได้ i = pop(s)
3.Stack Top เป็นการคัดลอกข้อมูลที่อยู่บนสุดของสแตก แต่ไม่ได้นำเอาข้อมูลนั้นออกจากสแตก

การแทนที่ข้อมูลของสแตกสามารถทำได้ 2 วิธี คือ
1.การแทนที่ข้อมูลของสแตกแบบลิงค์ลิสต์ จะประกอบไปด้วย 2 ส่วนคือ
1.1.Head Node จะประกอบด้วย 2 สาวนคือ Top Pointer และจำนวนสมาชิกในสแตก
1.2.Data Node จะประกอบด้วยข้อมูล(Data) และพอยเตอร์ที่ชี้ไปยังตัวถัดไป
2.การแทนที่ข้อมูลของสแตกแบบอะเรย์

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

ขั้นตอนการเก็บข้อมูลในสแตกเมื่อเรียกใช้โปรแกรมย่อย
1.เริ่มต้นทำงานใน Main
2.ขณะที่กำลังทำงานใน Sub1
3.กลับมาทำงานใน Main
4.ขณะที่กำลังทำงานใน Sub2
5.ขณะที่กำลังทำงานใน Sub3
6.ขณะที่กำลังทำงานใน Sub4

การบ้าน

#include <iostream.h>
void Centsyard (int);
int main () {

int cent;
cout<"Enter Centimas ( 0 to Stop ):";
cin>cent;

while (cent != 0){
cout<cent>" Cents is to ";
Centsyard (cent);

cout<"\nEnter Centimas ( 0 to Stop ):";
cin>cent;
}

cout<"~*~ -GOOD BYE- ~*~";
return 0;
}
void Centsyard (int cent){
int yard;

yard=(cent/90);
cent=(cent-(yard*90));

cout<yard<" Yard and "<cent<" Cents."<endl;
return ;
}

DTS05-28/07/2552

สรุปบทเรียนครั้งที่ 5
เรื่อง Linked List
ลิงค์ลิสต์ (Linked List) เป็นวิธีการเก็บข้อมูลอย่างต่อเนื่องของอิลิเมนต์ต่างๆ โดยมีพอยเตอร์เป็นตัวเชื่อมต่อ แต่ละอิลิเมนท์ เรียกว่าโนด (Node) ซึ่งในแต่ละโนดประกอบไปด้วย 2 ส่วน คือ
1. Data จะเก็บข้อมูลของอิลิเมนท์
2. Link Field ทำหน้าที่เก็บตำแหน่งของโนดต่อไปในลิสต์ในส่วนของ data จะเป็นรายการเดี่ยวหรือเรคคอร์ดก็ได้ ส่วนของ link เป็นส่วนที่เก็บตำแหน่งของโหนดถัดไป ถ้าในโหนดสุดท้ายจะเก็บค่า Null (ไม่มีค่าใดๆ ไม่มีการเชื่อมโยง) เป็นตัวบอกการสิ้นสุดโครงสร้างข้อมูลแบบลิงค์ลิสต์

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

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

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