Q. Sorting seems like a toy problem

Q. Sorting seems like a toy problem. Aren’t many of the other things that we do with
computers much more interesting?
A. Perhaps, but many of those interesting things are made possible by fast sorting algorithms.
You will find many examples in Section 2.5 and throughout the rest of the
book. Sorting is worth studying now because the problem is easy to understand, and
you can appreciate the ingenuity behind the faster algorithms.
Q. Why so many sorting algorithms?
A. One reason is that the performance of many algorithms depends on the input values,
so different algorithms might be appropriate for different applications having different
kinds of input. For example, insertion sort is the method of choice for partially
sorted or tiny arrays. Other constraints, such as space and treatment of equal keys, also
come into play. We will revisit this question in Section 2.5.
Q. Why bother using the tiny helper methods less() and exch()?
A. They are basic abstract operations needed by any sort algorithm, and the code is
easier to understand in terms of these abstractions. Moreover, they make the code directly
portable to other settings. For example, much of the code in Algorithms 2.1
and 2.2 is legal code in several other programming languages. Even in Java, we can use
this code as the basis for sorting primitive types (which are not Comparable): simply
implement less() with the code v < w.
Q. When I run SortCompare, I get different values each time that I run it (and those
are different from the values in the book). Why?
A. For starters, you have a different computer from the one we used, not to mention
a different operating system, Java runtime, and so forth. All of these differences might
lead to slight differences in the machine code for the algorithms. Differences each time
that you run it on your computer might be due to other applications that you are running
or various other conditions. Running a very large number of trials should dampen
the effect. The lesson is that small differences in algorithm performance are difficult to
notice nowadays. That is a primary reason that we focus on large ones!

ผลลัพธ์ (ไทย) 1:

Q. เรียงลำดับเหมือนปัญหาของเล่น ไม่มากของสิ่งที่เราทำด้วยคอมพิวเตอร์ที่น่าสนใจมากบางที A. แต่ที่สิ่งที่น่าสนใจมากมายทำได้ โดยขั้นตอนวิธีการเรียงลำดับอย่างรวดเร็วคุณจะพบตัวอย่างมาก ในส่วน และ ตลอดช่วงเหลือของการหนังสือ เรียงลำดับเป็นน่าศึกษาขณะนี้เนื่องจากปัญหาง่ายต่อการเข้าใจ และคุณสามารถชื่นชมความคิดเบื้องหลังขั้นตอนวิธีที่รวดเร็วอัลกอริทึมการเรียงลำดับดังนั้นหลายคำถาม:ทำไมA. เหตุผลหนึ่งคือ ว่า ประสิทธิภาพการทำงานของอัลกอริทึมหลายขึ้นอยู่กับค่าที่ป้อนเข้าอัลกอริทึมที่แตกต่างอาจจะเหมาะสมสำหรับการใช้งานที่แตกต่างกันมีแตกต่างกันชนิดการป้อนข้อมูล ตัวอย่างเช่น เรียงลำดับแบบแทรกเป็นวิธีการเลือกบางส่วนอาร์เรย์ที่ถูกเรียงลำดับ หรือจิ๋ว ข้อจำกัดอื่น ๆ เช่นพื้นที่และรักษาของคีย์เท่ากัน ยังเข้ามาเล่น เราท่องคำถามในส่วนนี้คำถาม:ทำไมรำคาญเล็ก ๆ ช่วยวิธี less() และ exch() หรือไม่ก.จะมีดำเนินงานนามธรรมพื้นฐานที่จำเป็น โดยอัลกอริทึมการเรียงลำดับ และรหัสง่ายต่อการเข้าใจในแง่ของ abstractions เหล่านี้ นอกจากนี้ พวกเขาทำให้รหัสโดยตรงแบบพกพาการตั้งค่าอื่น ๆ เช่น มากของรหัสในอัลกอริทึมและ 2.2 เป็นกฎหมายในภาษาเขียนโปรแกรมอื่น Java เราสามารถใช้ในรหัสนี้เป็นพื้นฐานสำหรับการเรียงลำดับชนิดดั้งเดิม (ซึ่งจะไม่เทียบเท่า): เพียงแค่ใช้ less() กับ v รหัส < wQ. เมื่อฉันเรียกใช้ SortCompare ได้รับค่าที่แตกต่างทุกครั้งที่ฉันเรียกมัน (และผู้ได้แตกต่างจากค่าในหนังสือ) ทำไมA. สำหรับการเริ่ม คุณมีคอมพิวเตอร์ที่แตกต่างจากเราใช้ ไม่พูดถึงเป็นระบบปฏิบัติการ รันไทม์ Java และอื่น ๆ ทั้งหมดของความแตกต่างนี้อาจนำไปสู่ความแตกต่างเล็กน้อยในเครื่องรหัสสำหรับขั้นตอนวิธีการ ความแตกต่างกันให้คุณเรียกใช้บนคอมพิวเตอร์ของคุณอาจเนื่องจากโปรแกรมประยุกต์อื่น ๆ ที่คุณใช้หรือเงื่อนไขต่าง ๆ อื่น ๆ ทำการทดลองจำนวนมากควรรองรับผล บทเรียนมีความแตกต่างเล็ก ๆ ในประสิทธิภาพการทำงานของอัลกอริทึมใช้ยากสังเกตเห็นในปัจจุบัน นั่นคือเหตุผลหลักที่เราเน้นคนใหญ่

ผลลัพธ์ (ไทย) 2:

Q. คัดดูเหมือนว่าปัญหาของเล่น มีไม่มากของสิ่งอื่น ๆ ที่เราทำกับ
คอมพิวเตอร์น่าสนใจมากขึ้น?
A. บางที แต่หลายสิ่งที่น่าสนใจเหล่านี้จะทำไปโดยขั้นตอนวิธีการเรียงลำดับอย่างรวดเร็ว.
คุณจะพบตัวอย่างมากมายในมาตรา 2.5 และตลอดเวลาที่เหลือของ
หนังสือ การเรียงลำดับเป็นมูลค่าการศึกษาในขณะนี้เพราะปัญหาที่เกิดขึ้นเป็นเรื่องง่ายที่จะเข้าใจและ
คุณสามารถชื่นชมความฉลาดที่อยู่เบื้องหลังขั้นตอนวิธีการได้เร็วขึ้น.
Q. ทำไมขั้นตอนวิธีการเรียงลำดับมากมาย?
A. เหตุผลหนึ่งก็คือประสิทธิภาพการทำงานของหลายขั้นตอนวิธีขึ้นอยู่กับค่าการป้อนข้อมูล
เพื่อให้ขั้นตอนวิธีการที่แตกต่างกันอาจจะเหมาะสมสำหรับการใช้งานที่แตกต่างกันมีความแตกต่างกัน
ชนิดเข้า ยกตัวอย่างเช่นการจัดเรียงแทรกเป็นวิธีการของทางเลือกสำหรับบางส่วน
อาร์เรย์ที่เรียงลำดับหรือเล็ก ข้อ จำกัด อื่น ๆ เช่นพื้นที่และการรักษาของคีย์เท่ากันนอกจากนี้ยัง
เข้ามาเล่น เราจะทบทวนคำถามนี้ในมาตรา 2.5.
Q. รำคาญโดยใช้วิธีการช่วยเหลือเล็ก ๆ น้อย () และ Exch () ทำไม?
A. พวกเขามีการดำเนินงานที่เป็นนามธรรมพื้นฐานที่จำเป็นโดยขั้นตอนวิธีการเรียงลำดับใด ๆ และรหัสคือ
ง่ายต่อการเข้าใจในแง่ของแนวคิดเหล่านี้ นอกจากนี้พวกเขาทำให้โค้ดโดยตรง
แบบพกพาที่จะตั้งค่าอื่น ๆ ตัวอย่างมากของรหัสในอัลกอริทึม 2.1
และ 2.2 เป็นรหัสทางกฎหมายในหลายภาษาโปรแกรมอื่น ๆ แม้จะอยู่ใน Java เราสามารถใช้
รหัสนี้เป็นพื้นฐานสำหรับการจัดเรียงรูปแบบดั้งเดิม (ซึ่งจะไม่เทียบเท่า): เพียงแค่
ใช้น้อย () มีรหัส V <ว. วชิร
Q. เมื่อฉันเรียก SortCompare ฉันได้รับค่าที่แตกต่างกันในแต่ละครั้งที่ผมใช้มัน (และผู้ที่
มีความแตกต่างจากค่าในหนังสือ) ทำไม?
A. สำหรับ starters, คุณมีคอมพิวเตอร์ที่แตกต่างจากที่เราใช้ไม่ต้องพูดถึง
ระบบปฏิบัติการที่แตกต่างกัน Runtime Java และอื่น ๆ ทั้งหมดแตกต่างเหล่านี้อาจ
นำไปสู่ความแตกต่างเล็กน้อยในรหัสเครื่องสำหรับขั้นตอนวิธี ความแตกต่างในแต่ละครั้ง
ที่คุณเรียกใช้งานบนคอมพิวเตอร์ของคุณอาจจะเป็นเพราะการใช้งานอื่น ๆ ที่คุณกำลังทำงาน
หรือเงื่อนไขอื่น ๆ ทำงานเป็นจำนวนมากของการทดลองควรจะรองรับ
ผลกระทบ บทเรียนคือการที่แตกต่างเล็ก ๆ ในการทำงานขั้นตอนวิธีการยากที่จะ
สังเกตเห็นในปัจจุบัน นั่นคือเหตุผลหลักที่เรามุ่งเน้นไปที่คนที่มีขนาดใหญ่!

ผลลัพธ์ (ไทย) 3:

Q . การเรียงลำดับดูเหมือนว่าปัญหาของเล่น ไม่กี่ของสิ่งอื่น ๆที่เราทำคอมพิวเตอร์ที่น่าสนใจมากขึ้น ?. . บางที แต่หลายคนที่น่าสนใจจะทำให้เป็นไปได้โดยรวดเร็วขั้นตอนวิธีการเรียงลำดับ .คุณจะพบหลายตัวอย่างในส่วน 2.5 และตลอดส่วนที่เหลือของหนังสือ การเรียงลำดับคือ น่าศึกษา เพราะตอนนี้ปัญหาคือง่ายต่อการเข้าใจคุณสามารถชื่นชมความฉลาดหลังขั้นตอนวิธีที่เร็วขึ้นQ . ทำไมมากมายขั้นตอนวิธีการเรียงลำดับ ?1 . เหตุผลหนึ่งคือ ว่า ประสิทธิภาพของขั้นตอนวิธีหลายขึ้นอยู่กับการใส่ค่าดังนั้นขั้นตอนวิธีที่แตกต่างกันอาจจะเหมาะสมสำหรับการใช้งานที่แตกต่างกันมีแตกต่างกันประเภทของการป้อนข้อมูล ตัวอย่างเช่น การจัดเรียงเป็นวิธีการของทางเลือกสำหรับบางส่วนเรียง หรือ เล็ก ๆ อย่างต่อเนื่อง เงื่อนไขอื่นๆ เช่น พื้นที่และการรักษาของคีย์เท่ากัน นอกจากนี้เข้ามาเล่น เราจะทบทวนคำถามนี้ในส่วน 2.5Q : ทำไมต้องใช้ผู้ช่วยเล็ก ๆและวิธีการ less() exch() ?1 . มีพื้นฐานการใช้ขั้นตอนวิธีนามธรรมประเภทใดและรหัสคือง่ายต่อการเข้าใจในแง่นามธรรมเหล่านี้ นอกจากนี้ พวกเขาให้รหัสโดยตรงแบบพกพาเพื่อการตั้งค่าอื่น ๆ ตัวอย่างเช่น , มากของรหัสในขั้นตอนวิธี 2.12.2 เป็นกฎหมายรหัสในการเขียนโปรแกรมภาษาอื่น ๆหลาย แม้ใน Java , เราสามารถใช้รหัสนี้เป็นพื้นฐานสำหรับการเรียงลำดับชนิดดั้งเดิม ( ซึ่งเทียบไม่ได้ ) : เพียงแค่ใช้ less() กับรหัส V < WQ : เมื่อฉันวิ่ง sortcompare เข้าใจคุณค่าที่แตกต่างกันในแต่ละครั้ง ที่ผมใช้ มัน ( และนั้นแตกต่างจากค่าในหนังสือ ) ทำไม ?A . สำหรับ starters , คุณมีคอมพิวเตอร์ที่แตกต่างจากที่เราใช้ ไม่ต้องพูดถึงที่แตกต่างกันระบบปฏิบัติการ Java runtime , และอื่น ๆ ทั้งหมดของความแตกต่างเหล่านี้อาจนำไปสู่ความแตกต่างเล็กน้อยในรหัสเครื่องสำหรับอัลกอริธึม ความแตกต่างในแต่ละเวลาที่คุณทำในคอมพิวเตอร์ของคุณอาจจะเกิดจากโปรแกรมอื่น ๆที่คุณจะวิ่งหรืออื่น ๆเงื่อนไข ใช้ตัวเลขที่มีขนาดใหญ่มากของการทดลองให้ชุ่มผล เป็นบทเรียนว่า ความแตกต่างเล็ก ๆในประสิทธิภาพของอัลกอริทึมได้ยากสังเกตเห็นในปัจจุบัน นั่นคือเหตุผลหลักที่เราเน้นขนาดใหญ่ !