تستخدم طريقة الفرز السريع بشكل أساسي المصفوفات. sort () لتنفيذها.
تتمثل طريقة الفقاعة في استخدام صفائف اجتياز للمقارنة ، وتجاوز الحد الأدنى أو الحد الأقصى للقيم واحدة تلو الأخرى من خلال المقارنة المستمرة.
تتمثل طريقة فرز التحديد في استخدام البيانات الأولى للمصفوفة كأكبر أو أصغر قيمة ، ثم إخراج صفيف مرتبة من خلال حلقة مقارنة.
إدراج الفرز هو تحديد البيانات في صفيف وفرزها في النهاية عن طريق إدخالها باستمرار ومقارنتها.
نسخة الكود كما يلي:
حزمة com.firewolf.sort ؛
الطبقة العامة mysort {
/**
* param args
*/
الفراغ الثابت العام الرئيسي (سلسلة [] args) {
int Array [] = {45،32،54،12،43،65،11،3،43،6،33،90،44،1،178} ؛
mysort mysort = جديد mysort () ؛
mysort.insertsort (صفيف) ؛
system.out.print ("إدراج نتيجة الفرز:") ؛
mysort.printarray (صفيف) ؛
System.out.println () ؛
mysort.bubblesort (صفيف) ؛
System.out.print ("Bubble Sort Result:") ؛
mysort.printarray (صفيف) ؛
mysort.qsort (صفيف) ؛
System.out.println () ؛
System.out.print ("النتيجة السريعة للفرز:") ؛
mysort.printarray (صفيف) ؛
mysort.shellsort (صفيف) ؛
System.out.println () ؛
System.out.print ("Hill Sort Result:") ؛
mysort.printarray (صفيف) ؛
mysort.selectsort (صفيف) ؛
System.out.println () ؛
System.out.print ("SELECT SORT RESONT:") ؛
mysort.printarray (صفيف) ؛
}
/**
* أدخل مباشرة
* الفكرة الأساسية: في مجموعة الأرقام التي سيتم فرزها ، على افتراض أن الأرقام السابقة (N-1) [n> = 2] هي بالفعل في حالة جيدة ، تحتاج الآن إلى إدراج الرقم التاسع في الرقم المطلوب بالترتيب السابق هذا يجعل هذه الأرقام n أيضا بالترتيب. كرر هذه الدورة حتى يتم ترتيب الجميع بالترتيب
*/
public void esertsort (int [] array) {
int temp = 0 ؛
لـ (int i = 1 ؛ i <array.length ؛ i ++) {
int j = i-1 ؛
temp = صفيف [i] ؛
لـ (؛ j> = 0 && temp <array [j] ؛ j-) {
صفيف [j+1] = صفيف [j]
}
صفيف [j+1] = temp ؛
}
}
/**
* فرز الفقاعة
* الفكرة الأساسية: في مجموعة الأرقام المراد فرزها ، قارن وضبط الرقمين المجازين من أعلى إلى أسفل لجعل أعدادًا أكبر لتغرق ، ترتفع الأرقام الصغيرة. أي أنه عندما تتم مقارنة رقمين مجازين ووجد أن فرزهما يعكس متطلبات الفرز ، يتم تبادلهما.
*/
publics pubblesort (int [] صفيف) {
درجة حرارة
لـ (int i = 0 ؛ i <array.length ؛ i ++) {// عدد الرحلات
لـ (int j = 0 ؛ j <array.length-i-1 ؛ j ++) {// عدد المقارنات
if (Array [J]> Array [J+1]) {
Temp = Array [J] ؛
صفيف [j] = صفيف [j+1] ؛
صفيف [j+1] = temp ؛
}
}
}
}
/**
* نوع سريع
* الفكرة الأساسية: حدد عنصرًا قياسيًا ، وعادةً ما يكون العنصر الأول أو العنصر الأخير ، ومن خلال الفحص ، قم بتقسيم التسلسل المراد فرزه إلى جزأين. العنصر القياسي.
* param صفيف
*/
void public qsort (int array []) {
if (array.length> 1) {
_qsort (صفيف ، 0 ، array.length-1) ؛
}
}
/**
* فرز سريع لرحلة واحدة
* param صفيف
*/
private void _qsort (int [] array ، int low ، int high) {
إذا (منخفضة <) {
int middle = getMiddle (صفيف ، منخفض ، مرتفع) ؛
_qsort (صفيف ، منخفض ، منتصف 1) ؛
_qsort (صفيف ، متوسط+1 ، مرتفع) ؛
}
}
/**
* احصل على القيمة الوسيطة
*/
private int getMiddle (int [] array ، int low ، int high) {
int tmp = صفيف [منخفض] ؛
بينما (منخفضة <) {
بينما (منخفض <High && Array [High]> = TMP)
عالي--؛
صفيف [منخفض] = صفيف [مرتفع] ؛
بينما (منخفض <High && Array [Low] <= TMP)
منخفض ++ ؛
صفيف [مرتفع] = صفيف [منخفض] ؛
}
صفيف [منخفض] = TMP ؛
العودة منخفضة.
}
/**
* نوع الاختيار البسيط
* الفكرة الأساسية: من بين مجموعة الأرقام التي سيتم فرزها ، حدد أصغر رقم وتبادلها مع الرقم في الموضع الأول ؛ حتى تتم مقارنة العدد قبل الأخير بالرقم الأخير.
* param صفيف
*/
public void selectsort (int [] array) {
الموضع int = 0 ؛
لـ (int i = 0 ؛ i <array.length ؛ i ++) {
int j = i+1 ؛
الموقف = أنا ؛
int temp = array [i] ؛
لـ (؛ j <array.length ؛ j ++) {
if (Array [j] <temp) {
Temp = Array [J] ؛
الموقف = J ؛
}
}
صفيف [موضع] = صفيف [i] ؛
صفيف [i] = temp ؛
}
}
/**
* نوع التل (الحد الأدنى للفرز الإضافي)
* الفكرة الأساسية: تقسم الخوارزمية أولاً الرقم المراد فرزه إلى عدة مجموعات وفقًا لزيادة معينة D (N/2 ، N هي عدد الأرقام المراد فرزها) ، والمجموعات المسجلة في كل مجموعة تختلف عن D. لكل مجموعة يتم فرز جميع العناصر مباشرة ، ثم تم تجميعها بزيادة أصغر (D/2) ، ثم يتم فرزها مباشرة في كل مجموعة. عندما يتم تقليل الزيادة إلى 1 ، يتم الانتهاء من الفرز بعد إجراء نوع الإدراج المباشر.
* param صفيف
*/
public void shellsort (int [] array) {
Double D1 = Array.Length ؛
int temp = 0 ؛
بينما (صحيح) {
d1 = math.ceil (d1/2) ؛
int d = (int) d1 ؛
لـ (int x = 0 ؛ x <d ؛ x ++) {
لـ (int i = x+d ؛ i <array.length ؛ i+= d) {
int j = id ؛
temp = صفيف [i] ؛
لـ (؛ j> = 0 && temp <array [j] ؛ j- = d) {
صفيف [j+d] = صفيف [j] ؛
}
صفيف [j+d] = temp ؛
}
}
إذا (د == 1)
استراحة؛
}
}
/**
* طباعة جميع العناصر في الصفيف
*/
printarray printarray public (int []) {
لـ (int i = 0 ؛ i <array.length ؛ i ++) {
System.out.print (Array [i]+"") ؛
}
}
}
فيما يلي بعض الأمثلة على طرق الفرز المستخدمة بشكل منفصل
الفرز السريع باستخدام طريقة الفرز مع المصفوفات
نسخة الكود كما يلي:
استيراد java.util.arrays ؛
اختبار الطبقة العامة 2 {
الفراغ الثابت العام الرئيسي (سلسلة [] args) {
int [] a = {5،4،2،4،9،1} ؛
المصفوفات
لـ (int i: a) {
system.out.print (i) ؛
}
}
}
خوارزمية فرز الفقاعة
نسخة الكود كما يلي:
int static int [] bubblesort (int [] args) {// bubble sorting خوارزمية
لـ (int i = 0 ؛ i <args.length-1 ؛ i ++) {
لـ (int j = i+1 ؛ j <args.length ؛ j ++) {
if (args [i]> args [j]) {
int temp = args [i] ؛
args [i] = args [j] ؛
args [j] = temp ؛
}
}
}
إرجاع args.
}
حدد خوارزمية الفرز
نسخة الكود كما يلي:
int static int [] SelectSort (int [] args) {// حدد خوارزمية الفرز
لـ (int i = 0 ؛ i <args.length-1 ؛ i ++) {
int min = i ؛
لـ (int j = i+1 ؛ j <args.length ؛ j ++) {
if (args [min]> args [j]) {
min = j ؛
}
}
if (min! = i) {
int temp = args [i] ؛
args [i] = args [min] ؛
args [min] = temp ؛
}
}
إرجاع args.
}
أدخل خوارزمية الفرز
نسخة الكود كما يلي:
int static int [] insertsort (int [] args) {// إدراج خوارزمية الفرز
لـ (int i = 1 ؛ i <args.length ؛ i ++) {
لـ (int j = i ؛ j> 0 ؛ j-) {
if (args [j] <args [j-1]) {
int temp = args [J-1] ؛
args [j-1] = args [j] ؛
args [j] = temp ؛
} استراحة أخرى ؛
}
}
إرجاع args.
}
ما سبق هي أربع طرق فرز في جافا. الطرق المختلفة لها كفاءة مختلفة.
نوع الفقاعة: مقارنة O (N2) تبادل البيانات O (N2)
حدد النوع: مقارنة O (N2) تبادل البيانات O (n)
أدخل النوع: قارن O (n2) نسخ البيانات o (n)
في التطبيقات العملية ، يجب أن نحاول اختيار خوارزميات فعالة.