(อาจารย์) วันสอบมีใคร ไม่ว่างไหม สอบทีหลังคนเดียวใช่ไหมคะ ถ้าไม่ว่างก็สอบทีหลัง สอบคนเดียวค่ะ สอบทีหลังนะ คราวนี้ เดี๋ยวมาเรียนต่ออีก 1 เรื่องนะคะ เป็นเรื่องสุดท้าย ก่อนที่เราจะสอบ ก็คือ เรื่องคิวนะคะ เรื่องคิว คราวที่แล้ว เราพูดถึง Stack ใช่ไหมคะ ยังจำได้ไหม คุณสมบัติของ Stack นะคะ คุณสมบัติของ Stack คือ เข้าก่อนออกตอนไหนเอ่ย เข้าก่อนออกทีหลังนะคะ คุณสมบัติของ Stack ก็คือ เข้าก่อนนะคะ แล้วก็ออก ทีหลัง คราวนี้ เราจะเห็นว่า คุณสมบัติของ Stack ก็คือ เข้าก่อนออกทีหลัง นะคะ Stack เขามีทางเข้าทางออกกี่ทาง มีแค่ 1 ทางถูกไหมคะ การเข้าออกนะคะ ของโครงสร้างข้อมูลแบบ Stack จะ มีทางเข้าทางออกนี่ เพียงแค่ 1 ทางเท่านั้นนะคะ เวลาเราเพิ่มข้อมูลใส่เข้าไป ข้อมูลจะอยู่ด้านบนหรือด้านล่าง ด้านบนถูกไหมคะ ถ้าเราเพิ่มข้อมูลใหม่เข้าไป ข้อมูลก็จะอยู่ด้านบน นะคะ บนสุดของ Stack แล้วเวลาเราเอาออก เอาข้อมูลด้านบนหรือด้านล่างออก ด้านบน ถูกไหมคะ เวลาเราเอาข้อมูลออก ก็คือ เอาข้อมูล ที่อยู่ด้านบนสุดออกนะคะ รูปแบบ ของการจัดเก็บข้อมูลแบบ Stack ที่เราเรียนไป นะคะ เราเก็บในรูปแบบ ที่เรียกว่า List ใช่ไหมคะ เราเก็บข้อมูล ในรูปแบบที่เป็น List ก็คือ เก็บข้อมูล เรียงต่อกันไป จะเป็นแนวตั้งแบบนี้หรือจะเป็นแนวนอน แบบนี้ เหมือนกันไหม เหมือนกันถูกไหมคะ แค่จับเอียงเฉย ๆ นะคะ แต่ รูปแบบจะเหมือนกัน ก็คือ เราจะเก็บข้อมูลเป็นช่อง ๆ นะคะ ถ้าเป็นแนวนอนแบบนี้นะคะ ตัวแรกนี่ ก็คือ ตัวที่เก็บก่อนถูกไหมคะ ด้านซ้ายก็เรียงลำดับไปเรื่อย ๆ นะคะ การเก็บข้อมูลแบบ List เราจะมี Index นะคะ เป็นตัวกำกับ หมายเลขช่อง ต้องการเอาข้อมูลออก ช่องสุดท้ายก็ต้องรู้ว่า Index ตัวสุดท้ายคืออะไร แล้วก็ดึงข้อมูลออกมานะคะ หมายเลข Index ที่ชี้ใน List จะ เริ่มต้นที่เลขอะไรเอ่ย Index เราจะเริ่มต้นที่ 0 ถูกไหมคะ หมายเลข Index ก็คือหมายเลขของ แต่ละช่องนี่จะเริ่มที่ 0, 1, 2 ไล่ไปเรื่อย ๆ นะคะ ต้องการเข้าถึงข้อมูล ที่ Index ตัวสุดท้ายก็คือ เป็น Index หมายเลข 4 นะคะ เป็นแนวตั้ง เหมือนกัน ก็จะเก็บข้อมูลโดยมี หมายเลข Index เป็นตัวชี้นะคะ เป็นตัวกำกับในแต่ละช่อง อันนี้คือ stack แล้วเรามีการจัดเก็บข้อมูล ที่เป็นแบบ List นะคะ อันนี้คือ 1 รูปแบบ ของ Stack สำหรับวันนี้นะคะ เราจะเรียนอีก 1 โครงสร้างก็คือ คิว คราวนี้ก่อนอื่น Stack จะมีคำสั่งที่เอาข้อมูลเข้ากับเอาข้อมูลออก ถูกไหมคะ คำสั่งของการเอาข้อมูลเข้า ลงไปใน Stack ใช้คำสั่ง ใช้คำสั่งอะไรเอ่ย ใช้คำสั่งตัวไหน ถ้าเอาข้อมูลเข้า มีเอาข้อมูลเข้ากับนำข้อมูลออก สมมุติว่าใน Stack นะคะ เดี๋ยวครูย้อนกลับไปนิดนึง ใน Stack ถ้าเราต้องการเอาข้อมูลเข้าจะใช้ คำสั่ง Push หรือ Pop ใช้อะไรคะ Push ถ้าเอาข้อมูลออกใช้คำสั่ง Pop ถูกไหมคะ ถ้าคำสั่ง Push กับ คำสั่ง Pop Push ต้องบอกด้วยว่า จะ Push ข้อมูลอะไร ใช่ไหมคะ ก็ใส่หมายเลขข้างในหรือ Data อะไรก็ได้ที่เราต้องการนะคะ Pop ก็คือเอาข้อมูลออกมา ก็จะส่งค่าออกมาว่า แล้วข้อมูลอะไรที่เราดึง ออกจาก Stack นะคะ จะมี Push กับ Pop ถ้าพูดถึง Stack ถ้าเข้าคือ Push ถ้าออกคือ Pop นะคะ คราวนี้มาดู เรื่องคิว ทุกคนรู้จักคำว่า "คิว" ไหมคะ เคยได้ยินไหม เคยได้ยินคิวไหมคะ ในชีวิตประจำวัน เวลาทาน ไปต่อข้าว ไปซื้อข้าวที่โรงอาหารต้องเข้าคิวไหม เข้า ใช่ไหมคะ ก่อนจะขึ้นรถบัสกลับบ้าน ต้องต่อคิวไหม ต่อถูกไหมคะ หรือเราจะซื้อของอะไรก็ตามนะคะ ต้องมีการเข้าคิว ก็คือต่อคิว ไปแบงก์ต้องมีคิวไหม มี ถูกไหมคะ เราต้องไปกดขอบัตรคิวนะคะ จะได้ลำดับที่เท่าไร คิวนะคะ ในโครงสร้างข้อมูลกับ คิวในชีวิตประจำวันเหมือนกันเลยนะคะ ใครมาก่อน ได้ก่อนหรือได้ทีหลัง ได้ก่อนถูกไหมคะ "คิว" คือ คนมาก่อน ก็ต้องได้ก่อน คนมาทีหลังได้ทีหลัง ถูกไหมคะ เพราะฉะนั้น Concept ของคิว ก็คือ มาก่อนได้ก่อน เข้าก่อน เข้าก่อนออกก่อน ถูกไหมคะ เข้าก่อนออกก่อนนะคะ คิว เข้าก่อนออกกก่อน แต่ถ้าเข้าก่อนออกทีหลัง นั้นคือ Stack ใช่ไหมคะ คือ รูปแบบของโครงสร้างนะคะ มันจะมี 2 แบบ คือ คิวกับ Stack จะไปด้วยกัน เพราะฉะนั้นเมื่อเราบอกว่า คิวคือเข้าก่อนออกก่อนนะคะ มันก็เลยต้องมี ทางเข้ากับทางออกคนละทางใช่ไหม เข้าทางหนึ่ง ออกทางหนึ่ง เข้าข้างหลัง ออกข้างหน้าถูกไหมคะ คิว คือ เราเข้าด้านหลัง เราต่อคิวด้านหลัง แต่เวลา เอาออกใช่ไหมคะ ก็ต้องออกด้านหน้านะคะ คิวจะมีทางเข้าทางออกคนละทาง ก็คือจะมีอยู่ 2 ทางนะคะ ข้อมูลที่ นำเข้าไปเก็บก่อน จะถูกเอาไป ใช้งานก่อน ข้อมูลที่เข้าไปทีหลังนะคะ ก็จะถูกนำออกมา ใช้งานทีหลัง อันนี้คือ Concept ของคิวนะคะ ที่เราเข้าใจ รูบแบบโครงสร้าง ของคิวนะคะ เราสามารถจัดเก็บได้แบบไหน เก็บได้เหมือนแบบ Stack เลยนะคะ จะเก็บโดยการใช้ List ก็ได้ เก็บโดยการใช้ Linked List ก็ได้นะคะ รูปแบบแบบนี้ ก็คือ Linked List ใช่ไหมคะ รูปแบบด้านซ้ายที่เป็นแนวตั้งนะคะ เราเก็บแบบ List เหมือน Stack เมื่อกี้ที่เราพูดถึง เพราะฉะนั้นแล้วนะคะ Concept ของคิวหรือ Stack เราจะเก็บข้อมูลที่เป็น List หรือเป็น Linked List ได้เหมือนกัน นะคะ ตอน Stack เราใช้ List แล้วนะคะ พอมาคิว เดี๋ยวเราจะลองเก็บ ข้อมูลแบบนี้ นะคะ เราจะเก็บข้อมูลที่เป็นแบบ Linked List แบบนี้ ตัวนี้นะคะ Linked List เหมือนกับรถไฟ นึกออกใช่ไหมคะ Linked List จะเทียบได้กับรถไฟ รถไฟจะเป็นโบกี้ Linked List ก็เหมือนกัน จะเก็บข้อมูลนี่เป็น Node แล้วแต่ละ Node ก็เชื่อม ด้วยกันนะคะ แต่ละ Node จะเก็บข้อมูล ที่เราต้องการเหมือนกับในรถไฟ 1 โบกี้ ก็จะมีคนนั่งใช่ไหมคะ คนก็คือข้อมูลนั่นล่ะ ต้น List รู้ได้อย่างไรว่า ต้น Linked List คืออะไรนะคะ รถไฟรู้ได้อย่างไรว่า คือ ด้านหน้าหรือด้านหลัง มีอะไรเอ่ย ทำให้เราสังเกต มีหัวจักรถูกไหม นะคะ หัวจักรจะเป็นตัวบอกว่า นี่คือด้านหน้าของรถไฟ ใน Linked List เช่นเดียวกันนะคะ จะรู้ได้อย่างไรว่า ด้านหน้าของ Linked List คืออะไร มีอะไรชี้อยู่ มีลูกศร มีตัวชี้ที่ชื่อว่า Head ใช่ไหมคะ มีลูกศรที่ชื่อว่า Head ชี้อยู่ คือตัวนี้นะคะ เพราะฉะนั้น A, B, C, D Node แรกของ Linked List ตัวนี้คืออะไร คือ A ใช่ไหมคะ แล้ว Node สุดท้ายคืออะไรเอ่ย D Dog ใช่ไหมคะ Node สุดท้ายก็คือตัวนี้ คือ D Dog นะคะ ในคิวนะคะ เราจะรู้ได้อย่างไรว่าเป็น Node สุดท้าย คือ มีตัวชี้ที่ชื่อว่า Tail T-a-i-l นะคะ Tail ตัวนี้จะเป็นตัวชี้ที่บอกว่า Node นี้ คือ Node สุดท้าย ของ Linked List ตัวนี้นะคะ Head ชี้ที่ต้น List Tail ชี้ที่ท้าย List นะคะ ทบทวนอีกแบบหนึ่ง ใน 1 Node นะคะ ตัวนี้เราจะ มีชื่อเรียกว่าอะไรคะ Node ใช่ไหม 1 รูป 1 บล็อคตัวนี้คือ Node นะคะ 1 Node แบ่งออกเป็นกี่ช่อง 2 ช่องใช่ไหมคะ ช่องแรกเอาไว้ ทำอะไร ช่องนี้เอาไว้ทำอะไร ช่องด้านซ้ายเอาไว้เก็บอะไร เก็บข้อมูลถูกไหมคะ ช่องด้านซ้ายเราไว้ใช้เก็บ ข้อมูล ใช่ไหมคะ เราใช้เก็บข้อมูล แล้วช่องทางขวาไว้ทำอะไร ช่องทางขวาไว้ทำอะไรคะ ใน Node แต่ละ Node เอาไว้ใช้ เหมือนรถไฟถูกไหมคะ เหมือนรถไฟ เวลา เราจะเชื่อมแต่ละ Node ต้องเชื่อมกันไหม แต่ละโบกี้ต้องเชื่อมไหม เชื่อม ไม่อย่างนั้นมันจะเป็นรถไฟ ได้อย่างไรใช่ไหมคะ มันก็ต้องเชื่อมกัน เพราะฉะนั้น ช่องด้านขวาตัวนี้จะเป็นช่อง ที่เอาไว้ใช้เชื่อม Node ถูกไหมคะ ช่องตรงนี้ที่อยู่ด้านขวา จะเอาไว้ใช้เชื่อมไปยัง Node ถัดไปนะคะ มีชื่อเรียกไหม ช่องที่เก็บข้อมูล เราจะเรียกช่องนี้ว่าอะไร จำได้ไหม Data ใช่ไหมคะ จำได้ไหม ช่องที่เก็บข้อมูล จะมีชื่อเรียกว่า Data แล้วช่อง ที่ใช้เชื่อมไปยัง Node อื่น จะมีชื่อว่า ชื่อว่าอะไรเอ่ย ชื่อว่า Next ถูกไหม นะคะ 1 Node จะประกอบไปด้วย 2 ส่วน ส่วนที่เก็บข้อมูลเรียกว่า "Data" และส่วนที่ใช้เก็บตัว เชื่อมที่จะเชื่อมไปยัง Node ถัดไป มีชื่อว่า "Next" นะคะ คุ้นไหมน่ะ เริ่มคุ้นไหม มีชื่อว่า Next ใช่ไหมคะ จะมี Data กับมี Next นะคะ คราวนี้ คราวนี้สมมุติว่า ครูมีคิวนะคะ ตัวนี้คือ คิว ครูมีคิวนะคะ มีกี่ Node 3 Node นะคะ Node แรก ข้อมูลคืออะไร 10 Node สุดท้ายคือ 30 รู้ได้อย่างไร เพราะว่ามี Head กับ Tail เป็นตัวบอก ถูกไหมคะ อันนี้คือ Node แรก อันนี้คือ Node สุดท้ายนะคะ แล้วรู้ว่า Node แรก รู้ได้อย่างไร ก็มี Head ชี้อยู่ตรงนี้นี่ไงนะคะ รู้ได้อย่างไรว่าคือ Node สุดท้าย ก็มี Tail ชี้อยู่ นะคะ เราเลยรู้ว่า ได้ไหม คราวนี้นะคะ มาดูว่า Linked List ตัวนี้นะคะ มี Head ชี้ที่ Node แรก มี Tail ชี้ที่ Node สุดท้าย นะคะ แต่ละ Node มีการเชื่อมโยงกัน จะเห็นว่า เรามี เส้นเชื่อมนะคะ เส้นเชื่อมระหว่าง 20 กับ 30 ถ้าเราจำ การทำงานของ Linked List ได้นะคะ ส่วนที่เก็บข้อมูล จะมีชื่อว่า Data นะคะ ส่วน ที่ใช้เชื่อมจะมีชื่อเรียกว่า Next Next นะคะ Next เป็นตัวบอกว่า ชี้ไปที่ไหน Data จะบอกว่า Node นี้เก็บข้อมูล อะไรนะคะ ครูถามว่า Head.Data จะมีค่าเท่ากับเท่าไร Head คือตัวไหน ตัวนี้ .Data ก็คือข้อมูลใช่ไหมคะ เพราะฉะนั้น Node นี้เก็บข้อมูลเท่าไร 10 ถูกไหมคะ เพราะฉะนั้น Head.Data จะ มีค่าเท่ากับ 10 มีใครสงสัยไหม ว่า 10 มาจากไหน ได้ใช่ไหมคะ ถ้าอย่างนั้นครูถามต่อ Tail.Data จะมีค่าเท่ากับ Tail.Data จะมีค่า เท่ากับ 30 นะคะ โอ.เค. ถ้าคำสั่งเป็น .Data ให้หาข้อมูลข้างใน Node นั้นมาใส่นะคะ คำตอบจะต้องเป็นค่าข้อมูล คราวนี้มาดูนะคะ Head.Next.Data แสดงว่า ต้องตอบ เป็นค่าข้อมูลนะคะ ถ้าลงท้ายด้วย .Data แสดงว่า เราอยากรู้ ว่า ข้อมูลคืออะไร Head ตัวนี้ถูกไหมคะ เราดูทีละตัวนะ Head นะคะ เห็นไหม Head เราก็มาดูที่ Head Head ชี้อยู่ที่ไหน อ๋อ ชี้อยู่ที่ 10 นะคะ Head.Next ดูทีละตัวนะคะ Head.Next Head.next คือตัวนี้ มันชี้ไปที่ไหน ชี้ไปที่ Node ถัดไป คือตอนนี้มันชี้อยู่ที่ Node ถัดไป แล้ว Node นี้ เขาถามว่า .Data เพราะฉะนั้นตอบ ตอบเท่าไรคะ 20 นะคะ Head คือตัวนี้ .Next Next แล้วอย่างไร Next แล้วมันชี้มาที่นี่ใช่ไหมคะ เพราะฉะนั้นตัวชี้อยู่ที่นี่ .Next แล้ว .Data เพราะฉะนั้นคำตอบคือ 20 นะคะ ถัดมา Tail.Next Tail.Next ตัวแรก คือตัวชี้ใช่ไหมคะ Tail ชี้อยู่ที่ไหน ชี้อยู่ Node สุดท้ายนะคะ Tail.Next มันชี้อยู่ที่ไหน มันไปชี้ที่ไหนไหม Tail.Next ตัวนี้ มันเชื่อมไปที่ Node ไหนไหมคะ ไม่เชื่อม เพราะฉะนั้น มันคือ Node สุดท้ายแล้วใช่ไหมคะ เพราะฉะนั้นคำว่า .Next ของมัน ก็คือค่า None คือไม่ได้เชื่อมไปที่ไหนนะคะ คือไม่ได้เชื่อมไปที่ไหน ก็คือ ตอบว่า None ถูกไหมมันคือ Node สุดท้าย นะคะ มันไม่ได้เชื่อมไปที่ไหน คราวนี้ ครูถามอีก 1 ข้อ มาตัวนี้ Head.Next .Next แล้วก็ .Data ตอบเท่ากับ เท่ากับ 30 ถูกไหมคะ เราก็ต้องค่อย ๆ ไล่ Head ถูกไหมคะ Head ล่ะ .Next ชี้มาที่นี่ แล้ว .Next อีกครั้งหนึ่ง แล้ว Next ตัวนี้ ไปไหน มาที่นี่ แล้ว .Data ก็เลยต้องตอบว่า 30 นะคะ เริ่มไล่ถูกไหม ทีนี่ลองดูก่อนนะ เรามาทบทวนตัว Linked List ก่อนนะคะ พอเราทำในคิว เราจะทำได้ คราวนี้ ครูมี Linked List ให้นะคะ คือตัวเดิมเลยเมื่อกี้ 10, 20 แล้วก็ 30 มี Head กับ Tail ชี้ให้เรียบร้อยนะคะ ครูบอกว่า ครูต้องการเพิ่ม Node ใหม่เข้าไปที่ท้าย List ครูต้องการเพิ่ม Node ใหม่ คือ Node 5 ถูกไหมคะ Node ข้อมูล 5 ตัวนี้ ไปไว้ที่ท้าย List เพราะฉะนั้น 5 จะต้องต่อ 30 หรืออยู่หน้า 10 ท้าย List เพราะฉะนั้น 5 ต้องมาต่ออยู่ที่ 30 ถูกไหมคะ 5 จะต้องมาต่ออยู่ที่ 30 และ 5 จะเป็น Node สุดท้ายใช่ไหม พอเอา 5 มาต่อหลัง 30 5 กลายเป็น Node สุดท้ายใช่ไหม ใช่นะคะ 5 กลายเป็น Node สุดท้าย คราวนี้ ปัญหาคือ ครูจะเชื่อม 5 มาอยู่หลัง 30 ได้อย่างไร อันดับแรกทำอย่างไรคะ เราก็ลองวาดเส้นถูกไหม 5 มันต้องเชื่อมมาที่เท่าไร เอ้าพูดผิด 30 ต้องเชื่อมมาที่ 5 ถูกไหมคะ 30 ต้องเชื่อม มาที่ 5 ครูวาดเส้นเชื่อมล่ะ ครูจะเขียนคำสั่งได้อย่างไร เส้นนี้ที่เชื่อม มาใหม่นี่ที่ครูลากใหม่ จะต้องใช้คำสั่งอะไรดี คราวนี้มาดูว่า จะใช้คำสั่งอะไร Node สุดท้าย ตัวนี้มีอะไรชี้อยู่ มีอะไรคะ มี Tail ชี้อยู่ใช่ไหมคะ เราต้องการเชื่อมไปยัง Node ถัดไป เราต้องใช้ส่วนไหนเป็นตัวเชื่อม Data หรือ Next Next ถูกไหมคะ ก็เป็น Tail. Next ให้ชี้ไปที่ไหน เมื่อเราจุดตรงนี้ได้แล้ว Tail.Next ให้ชี้ไปที่ไหน ชี้ไปที่ 5 5 นี่มีอะไรชี้อยู่ มี P ชี้อยู่ เพราะฉะนั้น ก็กำหนดให้ Tail.Next ชี้ไปที่ P ชี้อยู่ คราวนี้นะคะ ยังไม่จบ ถูกไหม ยังไม่จบนะคะ Tail เราจะชี้ที่ไหน หน้าที่ของ Tail คือชี้ที่ ท้ายสุด ตอนนี้อะไรคือท้ายสุด 5 เพราะฉะนั้นต้องย้าย Tail ถูกไหม มาที่ 5 จะย้าย Tail ได้อย่างไร ให้ Tail ชี้ที่ P ชี้อยู่ใช่ไหมคะ ให้ Tail ชี้ที่ P ชี้อยู่ P ชี้อยู่ที่ไหน ก็เอา Tail นั่นล่ะ มาชี้นะคะ เราก็จะได้แล้วว่า Node สุดท้ายของ Linked List นี้ คือ Node ข้อมูล 5 นะคะ รู้ได้อย่างไร นี่ไง Tail ชี้อยู่ จด ๆ ไว้หน่อยนะคะ มีกระดาษไหม เอากระดาษขึ้นมาจด สไลด์นะ ครู ใส่ไว้ที่ Classroom นะคะ สามารถทบทวนได้ โดยการเปิด Classroom นะคะ ในรายวิชานี้ ครูอัปไฟล์ขึ้นให้หมดล่ะ คราวนี้ต่อ แล้วถ้าครูต้องการ ลบบ้าง เมื่อกี้ครูเพิ่มไปด้านหลังใช่ไหมคะ ครูต้องการลบข้างหน้าบ้าง ก็คือ ลบข้อมูล 10 ลบ 10 นี้ออกมานะคะ เอา 10 นี้ออกไป เมื่อเราลบ 10 ออกไปแล้ว Node แรกของ Linked List นี้คือ 20 ถูกไหมคะ เมื่อลบ 10 ออกไปแล้วนี่ Node แรกคือ 20 เพราะฉะนั้น เราจะทำอย่างไร เราก็แค่ย้าย Head นี่มาชี้ ที่ Node ถัดไป ถูกไหมคะ เมื่อ Head ชี้อยู่ ที่ไหน Node นั้นคือ Node แรก เราจะย้าย Head มาที่ Node ถัดไปได้อย่างไร ใช้คำสั่ง อะไรดี ให้ Head เลื่อนไปยัง Node ถัดไป ใช้คำสั่งอะไรคะ Head = ให้ Head นี่ไปชี้อยู่ที่ 20 นั่นล่ะ จะไปได้อย่างไรเอ่ย จะไป 20 ก็คือ เดี๋ยวนะ ไปได้อย่างไร ให้ Head ถูกไหมคะ ไปชี้ที่ Head.Next ชี้อยู่ Head.Next ชี้อยู่ที่ไหน 20 ใช่ไหมคะ Head.Next ชี้อยู่ที่ 20 เพราะฉะนั้น Head = Head.Next Head จะเขยิบมาชี้ ที่ Node 20 Head = Head.Next หมายความว่า ให้เอา Head นี่ ไปชี้อยู่ที่ Head.Next ชี้อยู่ เหมือนกัน Tail = P นะคะ ให้ Tail นี่ ไปชี้อยู่ที่ P ชี้อยู่ ตรงนี้เมื่อ Head เลื่อนมาอยู่ที่ Node 20 มันก็จะถูกลบไปโดยปริยายนะคะ โดยอัตโนมัติ โอ.เค. มีกระดาษไหมเอ่ย ใครไม่มีกระดาษมาหยิบนะ บางทีมันต้องจดนะคะ แล้วก็เย็บไว้ด้วยนะคะ ทุกคนได้กระดาษไปแล้ว นะคะ ครูมี Linked List มาให้นะคะ 4 Node ด้วยกัน ครูมี Linked List 4 Node นะคะ ที่เชื่อมกันไป Node ที่ 1 มี 1 Node ที่ 2 ก็คือ มีค่า 2 Node ที่ 3 มีค่า 3 Node ที่ 4 มีค่า 4 นะคะ ครูกำหนด Head กับ Tail ไว้ให้ ต้น List อยู่ตรงไหน ท้าย List อยู่ที่ไหน นะคะ ลองทำแบบฝึกหัดให้ครูหน่อย ข้อที่ 1 ครูต้องการเพิ่ม Node ใหม่เข้าไป ที่ท้าย List นะคะ เพิ่ม Node ใหม่เข้าไปที่ท้าย List โดยที่ Node ใหม่มีตัวชี้ คือ คิวชี้อยู่ ทำอย่างไร วาดรูปถูกไหมคะ แล้วก็ เอา 5 นี่ไปต่อด้านหลัง แล้วเขียนคำสั่งของเส้นที่เราเชื่อม ระหว่าง Node ข้อมูล 4 กับ Node ข้อมูล 5 ใช้คำสั่งอะไรในการเชื่อม เชื่อมเสร็จ Tail ต้องอยู่ที่ไหนนะคะ อันนี้คือข้อที่ 1 ข้อที่ 2 นะคะ ลบข้อมูลต้น List ลบข้อมูลต้น List ลบอย่างไร ก็เลื่อน Head ไปยัง Node ถัดไปเท่านั้นเอง ก็วาดรูปใช่ไหมคะ เราลบต้น List ออก แล้ว Head จะไปชี้อยู่ที่ไหน เลื่อน Head ด้วยคำสั่งอะไร 2 ข้อค่ะ ลองทำในกระดาษ ให้วาดรูป ก่อนนะคะ แล้วก็เขียนคำสั่ง ลอกโจทย์ไว้ก่อนนะคะ ลอกโจทย์รูปบนสุด ข้อ 1 ครูให้ใช้คำสั่งอะไร ข้อ 1 ลอกโจทย์ก่อนนะคะ เสร็จแล้ว เราก็ ค่อยวาดรูปการเชื่อม แล้วก็เขียนคำสั่ง คราวนี้ พอลอกโจทย์เสร็จใช่ไหมคะ วาดรูปนี้เสร็จแล้ว มาทำข้อที่ 1 ลอกโจทย์ไว้ก่อน เพิ่ม Node ใหม่ที่ท้าย List ก็คือ ลอกโจทย์ไปก่อน แล้วก็มี Node ใหม่ ใช่ไหมคะ พอลอกโจทย์ เสร็จแล้ว เราก็มาวาดใช่ไหมคะ Node ให้มันเชื่อมต่อกัน เราก็เชื่อม Node เห็นไหมคะ เราก็เชื่อม Node ให้มันต่อกัน คราวนี้ เราก็ต้องเขียนคำสั่ง ถูกไหมคะ การเชื่อมตรงนี้จะเขียนคำสั่งว่าอะไร คำสั่งแรกเขียนว่าอะไร แล้วก็คำสั่งที่ 2 คำสั่งแรกเป็นอะไรคะ เส้นเชื่อม คำสั่งที่ 2 ก็คือเลื่อน Tail ถ้าใครเสร็จ ข้อที่ 1 เสร็จแล้วนะคะ มาดูข้อที่ 2 ข้อที่ 2 ครูให้ลบข้อมูลที่ต้น List เราก็วาดรูปนะคะ ผลลัพธ์ที่ได้ เป็นอย่างไร เป็นรูปนี้ Head มันมาได้อย่างไร Head มันขยับมาที่ 2 ได้อย่างไร ต้องเขียนคำสั่งของการเลื่อน Head ไปยัง Node ถัดไป ข้อ 1 นะคะ จะต้องมีอยู่ 2 คำสั่ง คำสั่งที่ 1 ก็คือ เส้นเชื่อมใช่ไหมคะ คำสั่งที่ 2 ก็ต้องเลื่อน Tail นะคะ เพราะเราต้องข้างหลังน่ะ Node สุดท้าย มันคงไม่ใช่ Node เดิมแล้ว ก็ต้องเลื่อน Tail ไปที่ไหน ในการเขียนคำสั่งนะคะ ต้องดูด้วยว่า จะ ทำคำสั่งไหนก่อน คำสั่งไหนหลังนะคะ ถ้าเขียนสลับ ความหมายก็จะเปลี่ยนทันที นะคะ เราต้องเชื่อมก่อน เราต้องเชื่อมก่อนนะคะ แล้วค่อยเลื่อน Tail เราต้องวาดเส้นนี้ก่อนนะคะ ต้องวาดเส้นที่เชื่อมก่อน เชื่อมได้แล้ว ค่อยขยับ Tail นะคะ มาดูพร้อมกัน ข้อ 1 ถูกไหมคะ ครูบอกว่า ให้เพิ่ม Node ใหม่ไปที่ท้าย Linked List เพิ่ม Node ใหม่ไปที่ท้าย Linked List ครูให้เขียนคำสั่งใช่ไหมคะ ครูให้เขียนคำสั่ง เราจะเชื่อมระหว่าง Node 4 กับ Node 5 ได้อย่างไร ข้อแรก ก็คือ ต้องเชื่อม Node 4 กับ 5 ใช่ไหม จะใช้คำสั่งอะไร เรารู้ว่า นี่เราจะเชื่อม Node 4 กับ Node 5 เราจะสั่งให้คอมพิวเตอร์นี่เชื่อมได้อย่างไร นะคะ เราก็ลองทำก่อน ก็คือ เราก็ลากเส้นอย่างนี้ใช่ไหม เส้นนี้ คือ เส้นใหม่ที่เรา จะต้องเชื่อมระหว่าง 2 Node นี้นะคะ เราจะเขียนคำสั่งเพื่อสร้างเส้นเชื่อม เส้นนี้ เราจะเขียน คำสั่งเพื่อสร้างเส้นเชื่อมเส้นนี้นะคะ เราจะใช้คำสั่ง อะไร Node นี้ มันออกมาจาก Node นี้ Node นี้มีอะไรชี้อยู่ มี Tail ใช่ไหมคะ นี่จะอ้างถึง Node นี้ ต้องหาตัวชี้ให้ได้ Node นี้มี Tail ชี้อยู่ถูกไหมคะ เส้นเชื่อมที่เราสร้างออกไป ออกจากส่วนที่ชื่อว่า Next นะคะ เพราะฉะนั้นก็เป็น Tail.Next แล้วให้เชื่อมไปที่ไหน เชื่อมไปที่ q คือเชื่อมไปที่ 5 นี่ แล้ว 5 อะไรชี้อยู่ q ชี้อยู่ถูกไหมคะ พอพูดถึง Next ต้องหาตัวชี้ ว่า จะชี้ไปที่ไหน พูดถึง Data ดูข้อมูลข้างใน Node ว่า มันคือ อะไรนะคะ เสร็จแล้ว คำสั่งที่ 2 เมื่อเรา สร้างเส้นเชื่อมนี้แล้ว Node สุดท้ายคืออะไรคะ คือ 5 ใช่ไหม เราจะเลื่อน Tail มาที่ 5 ได้อย่างไร ก็คือ Tail = q ก็คือเอา Tail นี่ ไปชี้ที่ q ชี้อยู่ 1 ข้อ จบ ถูกไหมคะ นี่คือ การเพิ่ม Node ใหม่ Tail ชี้ที่ q เพราะฉะนั้น Tail จะชี้อยู่ที่นี่ ที่ 5 นะคะ และ q ก็ชี้ อยู่ที่นี้เช่นกัน เห็นไหมคะ ครูไม่เขียนข้างหน้านะ ครูยกส่วนปลายมาเลย Tail จะชี้อยู่ที่ q ชี้อยู่ คือชี้ที่เดียวกันนะคะ คือชี้ที่ Node 5 จดเอาไว้ดูนะคะ จดเอาไว้ดู เร็ว มีใครสงสัย ไหมคะ อะไรชี้ไปไหน พยายามทำความเข้าใจ นะคะ เวลาเราเชื่อม Node นี่ เราก็ต้องรู้ ว่า เส้นเชื่อม จุดแรกที่เราจะเชื่อมไปยัง Node ถัดไปนี่ Node นั้นนี่ มีอะไรชี้อยู่ แล้ว เราลากออกไปนี่ เราลากออกจากส่วน ที่ชื่อว่า Next ใช่ไหมคะ มันก็เลยกลายเป็น Tail.Next แล้วชี้ที่ไหน ก็ชี้ไปที่นี่ แล้วที่นี่อะไรชี้อยู่ q มันก็เลยเป็น Tail.Next = q ครูเขียนภาษาไทยไว้ให้ นะคะ Tail.Next = q ก็คือ ให้ตัวชี้ Tail ในส่วน Next ชี้ไปที่ q ชี้อยู่นะคะ จะชี้หรือเชื่อมตรงนี้ก็ได้ เชื่อมไปที่ q ชี้อยู่ ส่วน คำสั่งที่ 2 Tail = q ก็คือให้ Tail น่ะ ชี้ไปที่ q ชี้อยู่ อันแรกเสร็จหรือยัง ครูเปลี่ยนได้ไหม เสร็จหรือยังคะ เสร็จแล้วค่ะ คราวนี้ มาดูข้อที่ 2 โจทย์บอกว่าให้ลบข้อมูล Node แรก ของ Linked List ลบ Node แรกใช่ไหมคะ ก็ คือ ลบอันแรกนี่ ลบข้อมูลตัวนี้ ลบ 1 ลบแล้วจะเป็นแบบไหน เป็นแบบนี้นะคะ หลังจากลบ หลังจากลบ Node แรกแล้ว เราจะได้ผลลัพธ์ ก็คือ ตามนี้ ใช่ไหมคะ แล้วเราจะ ลบ Node แรกออกไปได้อย่างไร ก็บอกเขาว่า ก็เลื่อน Head ไปยัง Node ถัดไป Head ชี้อยู่ที่ไหน อันนั้นคือ Node แรก เพราะฉะนั้นเราจะลบ Node 1 นะคะ Head จะต้องไปชี้อยู่ที่ 2 ก็คือคำสั่ง ก็คือเลื่อน Head ไปยัง Node ถัดไป ใช้คำสั่งว่า Head = Head.Next หมายความว่าอะไร ให้ Head นะคะ ให้ Head ไปชี้ที่ Head .Next ชี้อยู่ Head.Next ชี้อยู่ที่ 2 เพราะฉะนั้นเอา Head ไปชี้ที่นี่ Head = Head.Next ก็คือ ให้ Head นี่ ไปชี้ที่ Head.Next ชี้อยู่ ซึ่งก็คือ Node ถัดไปนะคะ จดเอาไว้ดูนะคะ จดนะคะ เดี๋ยวท้ายชั่วโมง ครูจะเช็กว่า ใครจด 2 ข้อ หรือทำ 2 ข้อนี้หรือเปล่า เดี๋ยวครูจะติ๊กคะแนนนะคะ ลอกใส่กระดาษไว้ดูนะคะ เดี๋ยวก่อนเลิกนะ ครูจะดูนะคะ ว่า ใครจดบ้าง ให้จดก่อนนะคะ จะเข้าใจหรือยังไม่เข้าใจ ไม่เป็นไร จดเอาไว้ดู พอเราจดนะคะ แล้วเรา ก็ต้องทบทวน ค่อย ๆ ดูนะคะ ว่า เขาเขียนคำสั่งอย่างไร เขาเชื่อมเส้นอย่างไร ต้องกลับ ไปทบทวนนะคะ ไม่เข้าใจ ต้องถามเพื่อน จะมีเพื่อนส่วนหนึ่งพอเข้าใจอยู่นะคะ เขียนคำสั่งได้ ต้องไปถามนะคะ ต้องถาม ที่จด ๆ ใส่กระดาษนะคะ ต้องเก็บเอาไว้ด้วย จดใส่ไหนนะคะ เก็บเอาไว้ เวลาสอบนะคะ ครูจะให้เปิดเอกสาร และตรวจเอกสาร ด้วยนะ ว่าเอาอะไรบ้างมา ถ้าที่จด ๆ ในห้อง ไม่ถือมานี่ ไม่ได้นะคะ จะเช็กว่า เอกสารครบไหม มีครบหรือเปล่านะคะ ไปเช็กกับเพื่อนนะคะ เพื่อนมีอะไร เราต้องมี เสร็จไหมคะ เสร็จหรือยัง เสร็จหมดแล้วนะ คือเดี๋ยวครู จะวาง... วางเอกสารไว้บนโต๊ะให้นะคะ สามารถมาเอาบนโต๊ะหน้าห้องได้นะคะ โอ.เค. ถ้าไม่จด ไม่ทันนะคะ มาถ่ายรูปที่หน้าห้องนะคะ ท้ายชั่วโมง ทำไมเรา ต้องเรียน Linked List เมื่อกี้นะคะ ทำไมเราต้องทบทวน Linked List เพราะเราจะใช้โครงสร้างของ Linked List นะคะ มาใช้ ในการดำเนินการกับคิว คราวนี้ แล้วเราใช้คิวทำอะไรบ้าง ยกตัวอย่าง เช่นนะคะ การที่เราส่ง เอกสารไป Print ที่เครื่อง Print นะคะ อย่างเช่น ด้านหลังเรามีเครื่องพรินต์แค่เครื่องเดียว ถูกไหมคะ ถ้า เราสามารถ Print ได้จากทุก ๆ เครื่อง ส่งไปที่ เครื่องพิมพ์เครื่องนั้นะคะ ใครที่ ส่งไปก่อนถูกไหมคะ มันก็จะมีการเข้าคิว เรียงลำดับมาเรื่อย ๆ คนที่ส่งไปก่อนก็จะพรินต์ ออกก่อนใช่ไหมคะ คนที่ส่งไปทีหลัง ก็ต้องรอนะคะ เหมือนเรา Login น่ะ เพื่อจองตั๋วอะไรสักอย่างหนึ่งนะคะ ใครเข้าก่อนก็จะได้จองก่อนนะคะ คนเข้าทีหลังก็อาจจะ ตั๋วเต็ม แบบนี้ก็จะไม่ได้จองนะคะ อันนี้คือ การประยุกต์ใช้คิว แล้ว การดำเนินการกับคิวนะคะ เราใช้คำสั่ง อะไรบ้าง หรือทำอย่างไร ในคิวนะคะ ก็จะเหมือน กับใน Stack เลย เราต้องคิดคู่กันนะคะ คิว เวลาเราเพิ่มข้อมูลลงไปในคิว จะใช้คำสั่ง "Enqueue" นะคะ ตัวนี้จะ อ่านว่า เอน... เอน-คิว ก็คือ การเพิ่มข้อมูลลงไปในคิว ส่วนการลบคิวหรือการดึงข้อมูล ออกจากคิว จะใช้คำสั่ง "Dequeue" นะคะ เพราะฉะนั้น ในคิว ถ้าเอาเข้าก็คือ Enqueue เอาออกคือ Dequeue นะคะ เข้าคือ Enqueue ออกคือ Dequeue เราต้องมีการเช็ก ตรวจสอบสถานะว่า คิวตอนนี้ เรามีข้อมูลอยู่หรือเปล่า ก็คือมี Node อยู่ไหม ถ้า คิวของเราไม่มี Node อะไรอยู่เลย จะ เรียกคิวนั้นว่า เป็นคิวว่างนะคะ "คิวว่าง" คือ ไม่มีข้อมูลอยู่ในคิวเลย เราจะเรียกว่า Empty นะคะ Empty Empty ก็คือ "ว่าง" ใช่ไหม ภาษาอังกฤษ ถ้าเราอยากรู้ว่า ข้อมูลตัวแรกสุดที่อยู่ในคิวคือข้อมูลอะไร ข้อมูลแรกสุด คือ ข้อมูลที่จะถูกเอาออก เป็นตัวแรกนะคะ เราจะใช้ คำสั่ง "Peek" เราจะเรียกคำสั่งนั้นว่า "Peek" นะคะ คราวนี้ เรามาดูทีละตัวนะคะ การเพิ่มข้อมูลลงไปในคิว หรือที่เรียกว่า Enqueue การเพิ่มข้อมูลใหม่ การเพิ่มข้อมูลใหม่ เราจะเอาไป ต่อท้ายสุดถูกไหมคะ ตามโครงสร้างของ Linked List ที่เราเรียนมา เพิ่มข้อมูลใหม่ เอาไปต่อท้ายใน Linked List นะคะ ถ้าเป็นคิวถูกไหม เพิ่มข้อมูลใหม่ เอาไปต่อท้ายนะคะ ต่อด้านหลัง คราวนี้ ครู ให้เวลาอ่านตรงขั้นตอนการเพิ่มข้อมูลใหม่ อ่านของใครของมันสิคะ 4-5 บรรทัด ตรงนี้ ตรงนี้นะคะ ตรงขั้นตอนตรงนี้ อ่าน ต่างคนต่างอ่านเร็ว อ่านก่อนนะคะ อ่าน แล้วดูรูปประกอบ อ่านแล้วดูรูปประกอบ ด้วยนะคะ ครูให้เวลานาทีหนึ่ง ทุกคนรู้จัก Head รู้จัก Tail แล้วนะคะ อ่านหรือยัง อ่านนะคะ 5 บรรทัด เสร็จหรือยังคะ เสร็จแล้วนะคะ ขั้นตอนของการเพิ่มข้อมูลใหม่ นะคะ เขาก็บอกว่า ขั้นแรกนี่ กำหนดให้ตัวชี้ Head ใช่ไหมคะ Head จะชี้อยู่ที่ต้น Node ก็คือ Node แรก และ Tail นี่ ชี้ที่ Node สุดท้ายนะคะ อันนี้คือกำหนดให้ Head ชี้อยู่ที่ Node แรก Tail ชี้ที่ Node สุดท้าย ในการเพิ่มข้อมูลใหม่ ต้อง มีการตรวจสอบก่อนว่า ใน Linked List ของเรานั้น มี Node อยู่เดิมหรือไม่นะคะ ถ้าไม่มี Node ใดอยู่เลย แสดงว่า เรากำลังจะสร้าง Node ใหม่ ของคิวนี้นะคะ แต่ถ้ามีข้อมูลเดิม อยู่ เราต้องเอาไปต่อข้างหลัง นะคะ ในการตรวจสอบว่า เป็น Node ใหม่ หรือเปล่า เราเช็กที่ Head ใช่ไหมคะ ถ้า Head มีค่าเป็น None แสดงว่าใน Linked List เรามี Node อยู่ไหม ครูถามว่า ถ้า Head เท่ากับ None แสดงว่า ใน Linked List ของเรา มี Node อยู่ไหม ไม่มีถูกไหม Head ไม่ได้ชี้ที่ไหนเลย Head ยังไม่รู้ อยู่ตรงไหนเลย เพราะฉะนั้นมี Node ไหม ไม่มีนะคะ เหมือนรถไฟอย่างนี้ ถ้าไม่มีหัวโบกี้จะรู้ไหมว่า อันไหนคืออันแรก ไม่รู้นะคะ ถ้า Head เท่ากับ None แสดงว่าเป็น Node ใหม่นี่ไงคะ แสดงว่าเป็น Node ใหม่ คือ เช็กจาก Head เท่ากับ None หรือเปล่า ถ้าเป็น Node ใหม่ เราก็ให้ Head และ Tail ชี้ที่ Node ใหม่เลย แต่ถ้าไม่ใช้ Node ใหม่ นะคะ แต่ถ้าไม่ใช่ Node ใหม่ ให้เอา Node ที่เราจะใส่เพิ่มน่ะ ไปต่อด้านท้าย ถ้า... พูดผิดค่ะ ถ้าไม่ใช่คิวว่าง ก็คือ ไม่มี Node ใด ๆ อยู่เลยนะคะ ถ้าไม่ใช่คิวว่าง ก็เอาไปต่อท้ายด้านหลัง ด้วยคำสั่งอะไร เมื่อกี้ทำไปแล้วน่ะ อันนี้คือ Linked List อันนี้คือ Node ใหม่ จะเชื่อมด้วยคำสั่งอะไรคะ Tail. . อะไร .Next เท่ากับอะไร จะเชื่อมตัวนี้มาที่นี่ ก็คือใช้ Tail.Next = New_Dataทำไมเท่ากับ New_Data ก็เพราะมันมีตัวชี้ชื่อนี้ใช่ไหม ถ้าอันนี้ ชื่ออะไรก็เปลี่ยนไปนะคะ โอ.เค. ไหม งงไหมคะ ไม่งง ถ้า ครูถามต่อ ถ้าเป็นกรณีแรกคือ เป็นคิวว่าง ไม่มี Node ใด ๆ เลย ถ้าครูมี Node ใหม่ ครูมีตัวชี้ก็คือตัว P มีค่าเป็น 10 ตอนนี้ Linked List ไม่มีข้อมูลใด ๆ เลย เราต้องให้ตัวชี้ ชี้อยู่ ที่ไหน ชี้ที่ Node ใหม่ คือ ชี้ที่นี่ใช่ไหมคะ แล้วให้อะไรชี้อยู่ที่นี่ด้วย Tail ใช่ไหมคะ จะใช้ คำสั่งอะไร Head = P ใช่ไหม Head = P หมายความว่า เอา Head ไป ชี้ที่ P ชี้อยู่ Tail ก็เช่นเดียวกัน ก็คือ Tail = P ถูกไหมคะ กรณี Linked List นั้น ไม่มีข้อมูลอยู่เลย เป็นคิวว่าง เวลาเราสร้างนะคะ หรือเชื่อม Node ใหม่เข้าไปใน Linked List เราก็ต้องกำหนดให้ Head และ Tail ชี้ที่ Node ใหม่ ด้วยคำสั่งนี้ จากที่เราพูดกันเมื่อกี้ นะคะ จากขั้นตอนตรงนี้ เราแปลง ให้เป็นคำสั่งได้ดังนี้ นะคะ ฟังก์ชันของ Enqueue เห็นไหมคะ อันดับแรก เราก็ต้อง มีการสร้าง Node ก่อน สร้าง Node ก็คือ สร้างสี่เหลี่ยมตัวนี้ถูกไหมคะ แล้วก็ใส่ข้อมูลเข้าไป แล้วก็มีตัวชี้ชื่ออะไร New_Dataถูกไหมคะ เรากำหนด ให้ตัวชี้คือ New_Dataสมมุติครูกำหนดให้ Data ตรงนี้ คือ 10 นะคะ นี่คำสั่งแรก ก็คือ สร้าง Node สี่เหลี่ยมตัวนี้ขึ้นมา เสร็จแล้วก่อนจะเชื่อมเข้าไปใน Linked List เช็กก่อนว่า มันมี Node เดิมอยู่หรือเปล่านะคะ เป็นคิวว่างไหม ก็คือ เช็กว่า Head Is None หรือเปล่า ถ้า Head Is None ก็คือเป็นคิวว่างนะคะ เราก็ให้ Head ชี้ที่ Node ใหม่ แล้วก็ ให้ Tail ชี้ที่ Node ใหม่เช่นกัน เราสามารถเขียนคำสั่งตรงนี้ได้อีกแบบ ก็คือ Tail = New_Dataหรือ Tail = Head ได้เหมือนกันนะคะ ถ้ากรณีเดิม ที่มันมี Node อยู่แล้ว เราก็เชื่อมถูกไหมคะ ตรงนี้ เราก็เชื่อมไปที่ Node สุดท้าย แล้วเราก็ เลื่อน Tail ไปยัง Node สุดท้ายนะคะ เลื่อน Tail ไปยัง Node สุดท้าย โอ.เค. นะคะ อันนี้คือ การเพิ่มข้อมูล ลงไปในคิว เอาออกบ้าง เอาออกหรือว่าลบข้อมูลออกจากคิว เวลาเอาออก เอาด้านหน้าออกนะคะ ลบด้านหน้าออก ดูขั้นตอน มี 3 ขั้นตอน อ่านก่อนค่ะ มีอยู่ 3 ขั้นตอน 3 ขั้นตอนนี้ อ่านให้ครูหน่อย ขั้นตอนของการดึง ข้อมูลออกจากคิวนะคะ เขาก็บอกว่า เราก็ดึงข้อมูลออกมาจาก Node แรกจะได้รู้ว่า ข้อมูล ที่ลบหรือข้อมูลที่ดึงออกมานั้นนี่ มันเป็นข้อมูลอะไรนะคะ เผื่อเราจะเอาไปใช้ต่อ หรือเอาไปทำอะไรต่อนะคะ เราดึงออกมา แล้ว เราก็เก็บเอาไว้ในตัวแปรที่เราสร้างขึ้นนะคะ พอเรารู้แล้วล่ะ ว่า ค่าที่จะเอาออกคือค่าอะไร เราก็เลื่อน Head ไปยัง Node ถัดไปนะคะ ขั้นที่ 2 เลื่อน Head ไปยัง Node ถัดไป พอเราเลื่อน Head ไปยัง Node ถัดไปนะคะ กรณี ที่ ถ้า Head ไม่ได้ชี้อยู่ที่ไหนเลย นั่นหมายความว่า Node ที่เราลบ คือ Node สุดท้าย ที่อยู่ในคิว Node ที่เราลบนะคะ ก็คือ Node สุดท้ายที่อยู่ในคิว เพราะฉะนั้น เมื่อเราลบ Node นั้นไปแล้ว Head จะต้องชี้อยู่ที่ None เมื่อ Head ชี้อยู่ที่ None แล้ว Tail ก็ต้องชี้อยู่ที่ None ด้วย เพราะไม่มี Node ใด ๆ เลย อยู่ในคิวนะคะ เวลาเราลบ เราลบอย่างไร เราใช้สั่ง ก็คือ Dequeue แล้วก็สร้างฟังก์ชันที่ชื่อว่า Dequeue นะคะ คำสั่งแรก ดึงข้อมูลออกมา และไอ้ที่ Head ชี้อยู่ ที่เรากำลังจะลบนั้นน่ะ เราเก็บค่าหน่อยว่า มันมีค่าอะไร Node ที่เรากำลังจะลบน่ะ มันเก็บค่าอะไรนะคะ เราก็เก็บข้อมูล แล้วเอามาใส่ในตัวแปรที่ชื่อว่า Data คือเอาขวา เอาผลลัพธ์จากขวามาใส่ ตัวแปรด้านซ้ายนะคะ จากนั้น ให้เลื่อน Head ไปยัง Node ถัดไป ก็คือ Head = Head.Next ตรวจสอบหน่อยว่า ตอนนี้ ไม่มีอะไรอยู่ใน Linked List เลย ก็คือ Head เป็น None หรือเปล่า ถ้า Head เป็น None แล้ว ก็ กำหนดให้ Tail มีค่าเป็น None ด้วย คราวนี้ ในการตรวจสอบว่า เป็นคิวว่างหรือเปล่านะคะ คำว่า "คิวว่าง" คืออะไร ไม่มีข้อมูลอะไรเลยอยู่ในคิว คิวว่าง ก็คือ ไม่มีข้อมูลอะไรเลยที่อยู่ในคิว นะคะ จะตรวจสอบได้อย่างไรว่า เป็นคิวว่างหรือเปล่า ก็เช็กว่า Head = None หรือเปล่า ถ้า Head = None แสดงว่าเป็นคิวว่าง ต่อนะคะ การตรวจสอบข้อมูล แรกสุดที่อยู่ในคิว ก็คือ ข้อมูลที่อยู่ต้นคิว นั่นล่ะ อยากรู้ว่า ข้อมูลแรกที่อยู่ในคิวคืออะไร เราก็เช็กแค่ว่า Head. Data ถูกไหมคะ Head.Data คืออะไร เหมือนที่ครูถามตอนแรก ช่วงต้น ๆ นะคะ Head.Data ก็คือ ข้อมูลแรกที่อยู่ในคิว คิว เวลาข้อมูลเข้ามาใหม่ จะอยู่ด้านหน้าหรืออยู่ด้านหลังคะ ด้านหน้าหรือด้านหลัง ด้านหลัง เวลาเอาข้อมูลออกจากคิว เอาออก ด้านหน้าหรือด้านหลัง ด้านหน้านะคะ ดูให้ดี ๆ อันไหน คือ ด้านหน้าด้านหลัง มีกระดาษ เพิ่มอยู่ใช่ไหมคะ ครูมีโจทย์อยู่ 3 ข้อ ทำเหมือนเดิมเลย ข้อแรก ครูมี Linked List มาให้นะคะ ครูกำหนด Head กับ Tail ให้ด้วย ข้อ 1 ครูบอกว่า เพิ่ม Node ใหม่ที่ ตัวชี้ Node 1 ชี้อยู่ เพิ่ม Node นี้ ข้อแรก เพิ่ม Node 1 ไปต่อด้านหลัง วาดรูปอย่างไร แล้วใช้คำสั่งอะไร ข้อ 2 เพิ่มไปแล้ว ลบออกบ้าง ลบข้างหน้า ใช่ไหมคะ ถัดมาข้อ 3 เพิ่มตัวชี้ Node 2 นี่ Node ที่มีตัวชี้ Node 2 นี่ ลงไปในคิว Linked List คำสั่งครูบอกหมดแล้วใช่ไหมคะ เหมือนในแบบฝึกหัดแรกที่ครูให้ทำ และเฉลยให้ด้วย เลียนแบบนะคะ เลียนแบบทำความ เข้าใจว่า ทำอย่างไรในแบบฝึกหัดที่ครูให้นี้ ดูจากเฉลยอันเก่า แล้วลองทำอันใหม่ ดูว่าจะทำได้ไหมนะคะ ครูเพิ่มข้อมูลใหม่ในคิว ก็ต้องไปเพิ่มด้านหลัง ครูลบข้อมูลออกจากคิว ก็ต้องลบข้างหน้า ครูไม่บอกว่าไปต่อท้ายอะไร ลบข้อมูลตัวไหนออก แต่ทุกคนต้องเข้าใจว่า คิวนี้ เวลา เราเพิ่ม เพิ่มด้านหลัง เวลาเราลบ ลบข้างหน้านะคะ ลงมือทำ 3 ข้อ โจทย์คราวที่แล้ว ใครยังลอกไม่เสร็จ มาถ่ายรูป เอาข้างหน้านะคะ แล้วเอาไปดู ทำลงกระดาษ ลงสมุด นะคะ คราวนี้นะคะ ดูนิดหนึ่ง ข้อ 3 นะคะ ข้อ 3 จะใช้รูปข้างบน หรือจะใช้รูปต่อจากข้อ 1 คำสั่งไม่แตกต่างกันเลยนะคะ เพราะเราเชื่อมต่อจาก Tail เพราะฉะนั้นถ้า Tail คุณจะชี้อยู่ที่ไหนก็ได้ ถูกไหมคะ จะใช้รูปข้างบนก็ได้ หรือจะใช้ต่อจากรูปข้อ 1 ก็ได้ เลือกเอา ใครเสร็จแล้ว เขียนชื่อ ส่งนะคะ ใครทำเสร็จแล้วนะคะ เอามาส่งครู รวมถึง แบบฝึกหัดก่อนหน้าที่ทำในห้องด้วยนะคะ ถือมาด้วย เวลาเขียนคำสั่งนะ Next Next สะกดให้ถูก N-E-X-T นะคะ ตัว N เดี๋ยวนะคะ เดี๋ยวครูจะเช็กชื่อ แล้วก็ปล่อย แล้วก็เอางานมาส่งหน้าห้องนะคะ [สิ้นสุดการถอดความ]