สวัสดีและยินดีต้อนรับ. ในการบรรยายนี้ ฉันจะสาธิตวิธีแก้ปัญหาสำหรับความท้าทายครั้งก่อนของเรา
ฉันจะพูดถึงวิธีที่เราสามารถย้อนกลับอักขระในสตริงโดยใช้ฟังก์ชันความยาว
str และยังผ่านการเรียงลำดับสตริงโดยใช้ str
เปรียบเทียบ และ str คัดลอก เช่นเดียวกับการใช้อัลกอริทึมแบบฟอง
มาสร้างบล็อคโค้ดกัน
และฉันจะสร้างโปรแกรมเดียวที่ฉันคิดสำหรับสิ่งนี้ ฉันพูดถึงความท้าทายที่คุณสร้างสองโปรแกรม
แต่เพื่อความง่ายและการสาธิต ฉันจะสร้างอันเดียว
สร้างโปรเจ็กต์
ฉันจะตั้งชื่อมันว่าฟังก์ชันสตริงหรือรูปแบบอื่น
เรียกมันว่าตัวอย่างฟังก์ชันสตริงทั่วไป
เริ่มจากสิ่งที่ตรงกันข้ามกันก่อน ย้อนกลับสามารถทำงานของมันเองหรือเราสามารถใส่ไว้ในหลักได้
ผมจะเอาไปใส่ในหลัก
สิ่งแรกที่ฉันต้องการทำคือฉันกำลังจะสร้าง -- อย่างแรกที่ฉันอยากทำคือ
ฉันต้องการรวมไฟล์ส่วนหัวที่ถูกต้อง เพื่อที่ฉันจะได้ใช้ฟังก์ชันสตริงเหล่านี้
ซึ่งเป็นสตริงรวมของฉัน ชม.
นี่คือที่ที่มีฟังก์ชันสตริงที่ดีทั้งหมด
ตอนนี้ฉันกำลังจะสร้างอาร์เรย์อักขระ กำลังจะทำไซส์ 100 ค่ะ
มันเป็นเพียงกฎเกณฑ์เท่านั้น
ไม่สามารถเก็บสิ่งของที่เกิน 100 ได้
ฉันจะสร้างตัวแปรท้องถิ่นสองสามตัวที่จะช่วยฉันในการแยกวิเคราะห์
และสิ่งที่ฉันต้องการทำคือฉันต้องการแสดงผลบางอย่างให้ผู้ใช้เห็นก่อน
ฉันจะบอกว่าการป้อนสองบรรทัด พิมพ์อักขระแต่ละตัว
อักขระแต่ละตัวของสตริง
และลำดับย้อนกลับ
ซึ่งจะบอกผู้ใช้ว่าเกิดอะไรขึ้น แล้วพิมพ์ออกมาเพื่อให้ชัดเจนยิ่งขึ้น
เพียงพิมพ์ออกมาแบบนั้น เพื่อให้อ่านง่ายขึ้น
ฉันจะบอกว่าใส่สตริง เดี๋ยวจะไปอ่านในเวบ
แล้วฉันจะเก็บสตริง
ผมจะเรียกว่า
scanf, present s และผมบอกว่า str
และฉันไม่ต้องส่งเครื่องหมายแอมเพอร์แซนด์เพื่ออ่าน
แล้วผมจะได้ความยาวของสตริง ฉันจะใส่สิ่งนั้นในตัวแปรท้องถิ่น l ของฉัน
ดังนั้นฉันจึงสามารถเรียก str link โดยเพียงแค่พูดว่า str length ที่ส่งผ่านในสตริง
และมันคืนค่าจำนวนอักขระในสตริงนั้น ง่ายมาก
แล้วฉันจะพิมพ์อะไรบางอย่างเพื่อบอกพวกเขาว่า อักขระในลำดับที่กลับกัน
ดังนั้นอักขระของสตริงย้อนกลับ
r แบ็กสแลช n
จากนั้นฉันจะเขียนลูปเล็กๆ น้อยๆ ที่ผ่านอาร์เรย์ของฉัน
และตามความยาว แล้วย้อนกลับ
ผมจะบอกว่าผมเท่ากับ l
ผมจะย้อนกลับไปในอาร์เรย์สตริงจริง
ฉันจะเริ่มต้นในตอนท้ายและไปข้างหน้า
และบอกว่าผมมากกว่าหรือเท่ากับ
0 และฉันลบลบ และคุณสังเกตเห็นว่าฉันไม่ต้องดูอักขระการสิ้นสุดที่เป็นโมฆะเมื่อฉันทำเช่นนี้
จากนั้นฉันจะพิมพ์ตัวอักษรแต่ละตัวออกมาเมื่อเจอมัน
หากต้องการพิมพ์อักขระและเห็นคุณทำเปอร์เซ็นต์ c
และทำอย่างนั้นแล้วพูดว่า str sub-I
และนั่นคือโดยพื้นฐานแล้ว
แล้วผมจะพิมพ์ขึ้นบรรทัดใหม่
และที่จริงฉันจะพิมพ์หลายอย่างเพื่อจบมัน ขีดคั่นหลายอัน
ลองดูว่าได้ผลหรือไม่ ง่ายมาก อันนี้จริงอย่างที่ควรจะเป็น
เพื่อให้ได้ความยาวไม่ควรยาก
และฉันลืมการป้อนบรรทัด มาแก้ไขกันเถอะ
ในที่นี้มันบอกว่าพิมพ์อักขระแต่ละตัวของสตริงย้อนกลับหรือป้อนสตริง
ตอนนี้ scanf มันจะอ่านอย่างเดียว ดังนั้นหากฉันเข้าสู่ เจสัน สเปซ เฟเดน
Scanf กำลังจะอ่านถึง Jason และพื้นที่เท่านั้น
คุณต้องการใช้ฟังก์ชันอื่นเช่น f get s หากคุณต้องการอ่านข้อมูลทั้งหมด
นี่คือสิ่งที่จะทำ มันก็แค่ย้อนกลับที่ Jason พิมพ์
nosaj ซึ่งมันทำ อักขระของสตริงย้อนกลับคือ nosaj
มันค่อนข้างง่าย ไม่ใช่ฟังก์ชั่นหรือการนำไปใช้ที่ซับซ้อนมาก
คราวนี้มาลองเรียงสตริงกัน
ตอนนี้ฉันกำลังจะทำอะไรบางอย่าง และฉันจะทำมันในหลักที่ฉันเดาตอนนี้
ฉันควรจะใส่สิ่งเหล่านี้ในฟังก์ชันจริง แต่เราไม่ได้สาธิตฟังก์ชันในการบรรยายนี้
เรากำลังสาธิตสตริง
เรามาสร้างตัวแปรโลคัลเพิ่มอีกสองสามตัวที่เราต้องการ
โดยพื้นฐานแล้วเราจะสร้างชื่อ
และในกรณีนี้ ฉันจะสร้างอาร์เรย์ของสตริง
เราจะสร้างอาร์เรย์ของสตริง และเราจะใช้ f ได้รับ s
ฉันจะสร้างอาร์เรย์ของสตริง นี่จึงดูเหมือนอาร์เรย์สองมิติ
สิ่งที่เรากำลังทำอยู่นี้คือ เรากำลังสร้างสตริงขนาด 50 จำนวน 25 สตริง
จากนั้นฉันจะสร้างอีกอันจาก 25 อัน ซึ่งจะประกอบด้วยแต่ละสตริง
แล้วผมจะบวกตัวแปรอีกสองตัว
ผมจะบวก n กับ j
และหลังจากที่เราทำย้อนกลับแล้ว ผมจะพิมพ์ออกมา
อีกข้อความหนึ่งที่บอกว่าเรากำลังทำอะไรอยู่จะเรียงลำดับสตริงของอาร์เรย์โดยใช้การเรียงลำดับแบบฟอง
ฉันจะไม่อธิบายการเรียงลำดับฟองให้คุณ เพราะอีกครั้ง นั่นเป็นเพียงอัลกอริธึมที่ไม่เกี่ยวข้องกับสิ่งที่เรากำลังทำอยู่
จริงๆแล้วมันเป็นเพียงวิธีการจัดเรียง
มันเป็นหนึ่งในประเภทที่ง่ายที่สุดจริง ๆ เพราะคุณเพียงแค่สลับเป็นหลัก
แต่สิ่งที่เราต้องทำคือก่อนอื่น เราต้องการหาจำนวนสตริงที่จะป้อน เราจะบอกว่า printf input
number ของ strings
แล้วเราจะเรียกว่า scanf
สามารถใช้ Scanf ได้ที่นี่ เนื่องจากเป็นเพียงตัวเลข
เราจะบอกว่าเปอร์เซ็นต์ d และเราจะเก็บมันไว้ในตัวแปรท้องถิ่น n
อีกครั้ง ฉันรู้ว่าฉันไม่ได้ใช้ชื่อที่ดีที่นี่
แต่ฉันกำลังสาธิตบางอย่าง เนื่องจากเป็น it's เราจึงต้องผ่านเครื่องหมายแอมเพอร์แซนด์
จากนั้นฉันจะขอให้พวกเขาป้อนสตริง
ที่นี่ฉันจะบอกว่าอินพุตสตริง 1 2 หรือ
3 ตามด้วยฟีดบรรทัด
นี่จะเป็นเพียงสิ่งที่พวกเขาต้องป้อน
สายหนึ่ง สายสอง หรือสายสาม
จากนั้นฉันจะมีลูปที่ผ่านและรับอินพุต
ตรงนี้ ผมจะบอกว่าสำหรับผม เท่ากับ 0, ผมน้อยกว่าเท่ากับ
n สำหรับจำนวนสตริงที่พวกเขาต้องการป้อน และผม
บวก บวก หรือ บวก บวก I
ที่นี่ฉันจะอ่านสตริงจริง ๆ และฉันจะใช้วิธีอ่านที่ต่างออกไป - ฉันกำลังคิดว่าจะใช้
f get s เพื่อให้คุณสามารถป้อนสตริงที่มีช่องว่างได้
แต่ฉันไม่คิดว่าเราต้องการ
เราทำการสแกน f
และเราจะอ่านเป็น scanf ในอาร์เรย์ชื่อของเรา
จำไว้ว่า เรามีชื่อ และนี่คือสตริงของสตริงที่มีอักขระ
25 ตัว
50 ตัวอักษร 25 คำ
จำนวนคำสูงสุดที่คุณป้อนได้คือ 25 คำ
เราจะเก็บสิ่งนี้ไว้ในอาร์เรย์ชื่อของเรา
เราก็จะบอกว่า scanf
เราจะอ่านเป็นสตริง และเราจะใส่มันในชื่อย่อย
I
ดังนั้นเราจึงเก็บอาร์เรย์ของเราไว้ เราสามารถเก็บได้ถึง 25 เท่านั้น
ตอนนี้เราวนรอบเสร็จแล้ว และตอนนี้ เราก็เขียนการเรียงลำดับฟองได้
ดังนั้นการเรียงลำดับแบบฟองสบู่ของเรา ฉันจะไม่อธิบายให้คุณฟัง ฉันจะบอกคุณว่ามันเป็นอัลกอริธึมที่ค่อนข้างเรียบง่ายที่มีลูปภายใน
คุณมี for loop ที่ทะลุผ่าน, I เท่ากับ 1 ตลอดสตริงทั้งหมด
จากนั้นในวงในของคุณ คุณเปลี่ยนจากศูนย์เป็นสตริงทั้งหมดลบหนึ่ง
และคุณเปรียบเทียบสตริงแรกนั้นกับสตริงอื่นๆ ทั้งหมด
และคุณทำฟองมันลงไป แต่สิ่งที่สำคัญที่นี่คือฟังก์ชัน
str Compare
ขอผมลองใส่การเยื้องนี้ให้ถูกต้องในฟังก์ชัน
str copy นี่เป็นสิ่งที่สำคัญจริงๆ
คุณจะสังเกตเห็นว่าฉันไม่มีวงเล็บปิดท้ายสำหรับทั้งสี่เพราะมีข้อความเดียว
แม้ว่าจะมีบางอย่างใน if body นี่เป็นเพียงคำสั่งเดียวเท่านั้น
ดังนั้นเราจะเริ่มจากการเปรียบเทียบแต่ละคำกับคำอื่นๆ เป็นหลัก หลังจากที่เราเปรียบเทียบหนึ่งคำก่อนหน้านี้แล้ว
ดังนั้นเราจึงบอกว่าถ้า str เปรียบเทียบชื่อย่อย
j และชื่อย่อย j ย่อยหนึ่ง ดังนั้น str เปรียบเทียบ
ใช้สองอาร์กิวเมนต์ อาร์เรย์อักขระสองตัว
ตัวชี้อักขระจริงๆ
และถ้าเท่ากัน มันจะคืนค่าศูนย์
หากพารามิเตอร์แรกน้อยกว่าพารามิเตอร์ที่สอง
พารามิเตอร์นั้นจะคืนค่าน้อยกว่าศูนย์
และถ้าพารามิเตอร์ตัวแรกมากกว่าพารามิเตอร์ตัวที่สอง
มันจะคืนค่ามากกว่าศูนย์ หนึ่ง
สิ่งที่กำลังพูดคือถ้าสตริงแรกมากกว่าสตริงที่สอง เราก็ต้องการสลับทุกอย่าง
และนั่นเป็นเหตุผลที่เรามีอุณหภูมินั้น
Temp กำลังจัดเก็บสตริงชั่วคราวชั่วคราว
ดังนั้นเราจึงใส่ชื่อชั่วคราว sub
j แล้วสลับชื่อ sub j ด้วยชื่อของ j บวกหนึ่ง
นั่นเป็นวิธีที่การเรียงลำดับฟองทำงาน อีกครั้ง สิ่งที่สำคัญที่นี่คือ str Compare และ str copy
และหากคุณปลอดภัย คุณอาจต้องการใช้ strn comparison
และเมื่อคุณทำ strn เปรียบเทียบ ที่จริงแล้ว strn เปรียบเทียบ คุณไม่สนใจเพราะนั่นเป็นเพียงถ้าคุณต้องการเปรียบเทียบคำนำหน้า
สำหรับ str copy คุณต้องการใช้ strn copy
และพารามิเตอร์ที่สามนั้นเป็นสิ่งสำคัญ
ดังนั้น strn copy คุณแค่ต้องการแน่ใจว่าคุณไม่ได้คัดลอกเกินขนาดของ
temp ลบหนึ่ง เพราะมิฉะนั้น คุณมีบัฟเฟอร์ล้น
ดังนั้นคุณจะทำสิ่งเหล่านี้ทั้งหมด คุณยังสามารถใช้
-- หากไม่ใช่บัฟเฟอร์อักขระ คุณอาจต้องการใช้ str length
หากเป็นพอยน์เตอร์ แต่ขนาดของจะทำงานได้ดีสำหรับสิ่งนี้
และอีกครั้ง การดำเนินการนี้จะขจัดบัฟเฟอร์เกิน
ดังนั้นจึงปลอดภัยกว่าเสมอที่จะใช้ strn copy และอีกอันหนึ่งเพราะเรามี
null terminator ที่ต้องต่อท้าย
ดังนั้นที่นี่จึงเป็นเพียงปลายทางต้นทางสำหรับการคัดลอก strn
เรากำลังคัดลอกชื่อ sub j ลงใน temp และเหมือนกับชื่อ
j บวกหนึ่ง และชื่อ sub j และสุดท้าย ใส่ชื่อย่อย
j บวกหนึ่ง และฉันต้องอัปเดตตัวแปรเหล่านี้จริงๆ
เพราะมันผิด เพราะมันจะต้องเป็นแหล่งที่มาเสมอ
ดังนั้นชื่อที่นี่ชื่อ sub j
แล้วตัวสุดท้ายจะเป็นชื่อของ
j บวกหนึ่ง j บวกหนึ่ง
นั่นคือ strn copy และ str เปรียบเทียบ ฟังก์ชันที่ใช้งานง่ายมาก
หลังจากที่เราจัดเรียงพวกมันแล้ว เราก็ต้องการพิมพ์ออกมา
ดังนั้นเราจึงต้องการบอกว่าสตริงปรากฏขึ้นหลังจากการเรียงลำดับ
ใส่ลงในบรรทัดฟีดแล้ววนซ้ำเพื่อพิมพ์สตริงทั้งหมดในอาร์เรย์ของเรา
เราก็บอกว่า 4 I เท่ากับ 0
I น้อยกว่าหรือเท่ากับ n เพราะ n หมายถึงจำนวนสตริงที่เราจัดเรียงและป้อน
จากนั้นเราแค่ต้องการผ่านสตริงอาร์เรย์สตริงของเรา
ดังนั้นเราจึงต้องการบอกว่า printf
s line feed และ name sub I.
ดังนั้น name sub I คืออาร์เรย์ที่จัดเรียงแล้ว นั่นเป็นสาเหตุที่เรามีชื่อ
name sub I
แม้ว่าเราจะไม่มีอันที่สองเพราะนั่นหมายถึงขนาดของตัวละครแต่ละตัว
25 คำ 50 สูงสุด
ลองดูว่ามันใช้งานได้หรือไม่
สร้างมันขึ้นมา ได้รับข้อความสองสามข้อความเพราะฉันไม่รู้วิธีสะกดคำ
และถ้าเรารันสิ่งนี้ ก่อนอื่นเราจะเรียกใช้ฟังก์ชันย้อนกลับเพื่อให้คุณเห็นอีกครั้งเพราะเรารวมไว้ในโปรแกรมเดียวกัน
พูดว่า Fedin และ idf นั้นดี
ป้อนจำนวนสตริงที่เราต้องการจัดเรียง สมมุติว่าห้า
สมมุติว่า zzzz เพื่อให้ชัดเจน อะไรแบบนั้น
ฉันทำพลาดนิดหน่อย แต่ดูเหมือนว่ามันจะเรียบร้อย a b d f r z
ดังนั้นจึงใช้งานได้ ฉันมีข้อผิดพลาดหนึ่งข้อเนื่องจากเปอร์เซ็นต์สตริงอินพุต
d
ฉันป้อนจำนวนสตริงเป็น n แล้วบอกว่าน้อยกว่าเท่ากัน
ฉันควรจะบอกว่าน้อยกว่า
ลองเรียกใช้อีกครั้งเพื่อแสดงมัน แต่ฉันต้องสร้างมันขึ้นมา
อย่าลืมสร้างหลังจากที่คุณได้เปลี่ยนแปลงสิ่งต่างๆ
อีกครั้ง เราจะพูดอะไรก็ได้ที่นี่ แล้วตามด้วยตัวเลขสตริง
ลองทำสี่กัน
ดังนั้นพวกเขาจึงเรียงตามตัวอักษรและพูดว่า d e l z ดูดี
ดังนั้นคุณสามารถปรับปรุงโค้ดนี้ได้อย่างแน่นอน โดยคุณสามารถใส่ทุกอย่างไว้ในฟังก์ชัน
ทำให้เป็นแบบโมดูลาร์มากขึ้น แต่สิ่งที่ฉันพยายามทำให้สำเร็จในงานนี้ก็คือ
คุณใช้ str เปรียบเทียบอย่างไร คุณใช้ strn copy อย่างไร และคุณสามารถใช้ความยาว
str ได้อย่างไร
คุณควรเล่นกับแมว str, strn cat และนั่นคือฟังก์ชันทั่วไปอื่นๆ
คุณอาจต้องการเล่นกับ strstr, strchar สำหรับการค้นหา สิ่งเหล่านี้ดีจริงๆ
หรือ is, upper is, lower สำหรับตรวจสอบอักขระ หรือฟังก์ชันการแปลง
atoi nad atof
ขอขอบคุณ. ฉันหวังว่านี่จะเป็นประโยชน์