Bucket SortBucket sort is mainly us

Bucket Sort
Bucket sort is mainly useful when input is uniformly distributed over a range. For example, consider the following problem.
Sort a large set of floating point numbers which are in range from 0.0 to 1.0 and are uniformly distributed across the range. How do we sort the numbers efficiently?

A simple way is to apply a comparison based sorting algorithm. The lower bound for Comparison based sorting algorithm (Merge Sort, Heap Sort, Quick-Sort .. etc) is Omega(nLogn), i.e., they cannot do better than nLogn.
Can we sort the array in linear time? Counting sort can not be applied here as we use keys as index in counting sort. Here keys are floating point numbers.
The idea is to use bucket sort. Following is bucket algorithm.

bucketSort(arr[], n)
1) Create n empty buckets (Or lists).
2) Do following for every array element arr[i].
.......a) Insert arr[i] into bucket[n*array[i]]
3) Sort individual buckets using insertion sort.
4) Concatenate all sorted buckets.
Following diagram (taken from CLRS book) demonstrates working of bucket sort.

BucketSort

Time Complexity: If we assume that insertion in a bucket takes O(1) time then steps 1 and 2 of the above algorithm clearly take O(n) time. The O(1) is easily possible if we use a linked list to represent a bucket (In the following code, C++ vector is used for simplicity). Step 4 also takes O(n) time as there will be n items in all buckets.
The main step to analyze is step 3. This step also takes O(n) time on average if all numbers are uniformly distributed (please refer CLRS book for more details)

Following is C++ implementation of the above algorithm.

// C++ program to sort an array using bucket sort
#include
#include
#include
using namespace std;

// Function to sort arr[] of size n using bucket sort
void bucketSort(float arr[], int n)
{
// 1) Create n empty buckets
vector b[n];

// 2) Put array elements in different buckets
for (int i=0; i

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

กลุ่มจัดเรียงจัดเรียงกลุ่มมีประโยชน์ส่วนใหญ่เมื่อป้อนข้อมูลที่มีกระจายสม่ำเสมอเมื่อเทียบเคียงช่วง ตัวอย่าง พิจารณาปัญหาต่อไปนี้ เรียงชุดใหญ่ลอยเลขจุดที่อยู่ในช่วงตั้งแต่ 0.0 ถึง 1.0 และกระจายสม่ำเสมอเมื่อเทียบเคียงระหว่างช่วง วิธีทำเราเรียงลำดับหมายเลขได้อย่างมีประสิทธิภาพหรือไม่วิธีง่าย ๆ คือการ ใช้การเปรียบเทียบที่ใช้เรียงอัลกอริทึม ขอบต่ำสุดสำหรับการเปรียบเทียบโดยใช้อัลกอริทึมการเรียงลำดับ (ผสานจัดเรียง จัดเรียง การกองด่วนเรียง... ฯลฯ) เป็น Omega(nLogn) เช่น ทำดีกว่า nLognเราสามารถเรียงลำดับแถวในเวลาเชิงเส้นหรือไม่ ไม่สามารถใช้การเรียงลำดับนับที่เราใช้คีย์เป็นดัชนีในการเรียงลำดับแบบนับได้ นี่คีย์จะลอยตัวเลขจุด ความคิดที่จะใช้เรียงลำดับกลุ่ม ต่อไปนี้เป็นกลุ่มอัลกอริทึมbucketSort (ตารางเข้า[] n)สร้างว่าง n 1) กลุ่ม (หรือรายการ)2) ทำต่อไปนี้สำหรับแต่ละตารางเข้าองค์ประกอบแถวลำดับ [i]...การ) แทรกตารางเข้า [i] เป็นกลุ่ม [n * เรย์ [i]]3) เรียงลำดับแต่ละกลุ่มใช้เรียงลำดับแบบแทรก4) นำกลุ่มเรียงลำดับทั้งหมดไดอะแกรมต่อไปนี้ (นำมาจากหนังสือ CLRS) แสดงให้เห็นถึงการทำงานของการเรียงลำดับกลุ่มBucketSortความซับซ้อนเวลา: ถ้าเราสมมติว่า แทรกในกลุ่มเป็นเวลา O(1) แล้วขั้นตอนที่ 1 และ 2 ของอัลกอริทึมข้างชัดเจนใช้ O(n) เวลา O(1) เป็นไปได้ง่ายถ้าเราใช้รายการเชื่อมโยงถึงกลุ่ม (ในรหัสต่อไปนี้ เวกเตอร์ c ++ใช้ราย) ขั้นตอนที่ 4 ใช้เวลา O(n) ยังกับจะมี n รายการในกลุ่มทั้งหมดขั้นตอนหลักในการวิเคราะห์เป็นขั้นตอนที่ 3 ขั้นตอนนี้ยังใช้ O(n) เวลาเฉลี่ยถ้าตัวเลขทั้งหมดจะกระจายสม่ำเสมอเมื่อเทียบเคียง (กรุณาจอง CLRS สำหรับรายละเอียดเพิ่มเติม)ต่อไปนี้จะใช้ c ++ของอัลกอริทึมข้างบนโปรแกรม c ++เรียงเป็นแถวที่ใช้เรียงลำดับกลุ่ม#include #include #include ใช้ namespace มาตรฐาน ฟังก์ชันการเรียงลำดับตารางเข้า]ของ n ขนาดที่ใช้เรียงลำดับกลุ่มยกเลิก bucketSort (ลอยตารางเข้า[] int n){ 1) สร้างถังเปล่า n เวกเตอร์ [n]; b 2) ใส่ลำดับในกลุ่มแตกต่างกัน สำหรับ (int ฉัน = 0 ฉัน { int สอง = n * ตารางเข้า [i]; ดัชนีในกลุ่ม b[bi].push_back(arr[i]) } 3) เรียงลำดับแต่ละกลุ่ม สำหรับ (int ฉัน = 0 ฉัน sort(b[i].begin(), b[i].end()) 4) นำกลุ่มทั้งหมดในตารางเข้า] ดัชนี int = 0 สำหรับ (int ฉัน = 0 ฉัน < n; i ++) สำหรับ (int j = 0 เจ < b[i].size(); j ++) ตารางเข้า [ดัชนี ++] = b [i] [j];} / * โปรแกรมโปรแกรมควบคุมการทดสอบข้างต้นประชุม * /int main(){ ลอยตารางเข้า[] = {0.897, 0.565, 0.656, 0.1234, 0.665, 0.3434 }; int n = sizeof(arr)/sizeof(arr[0]) bucketSort (ตารางเข้า n); cout << "Sorted เรย์เป็น
" สำหรับ (int ฉัน = 0 ฉัน cout << ตารางเข้า [i] << ""; กลับ 0}ผลผลิต:จะเรียงลำดับแถว0.1234 0.3434 0.565 0.656 0.665 0.897อ้างอิง:แนะนำอัลกอริทึม 3 รุ่น โดยคลิฟฟอร์ดสไตน์ Thomas H. Cormen ชาร์ลส์ E. Leiserson, L. โรนัลด์ Rivesthttp://en.wikipedia.org/wiki/Bucket_sortกรุณาเขียนข้อคิดเห็นถ้าคุณหาอะไรไม่ถูกต้อง หรือคุณต้องการแบ่งปันข้อมูลเพิ่มเติมเกี่ยวกับหัวข้อที่กล่าวถึงข้างต้น

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

ถังเรียง
การจัดเรียงถังเป็นประโยชน์ส่วนใหญ่เมื่อป้อนข้อมูลมีการกระจายอย่างสม่ำเสมอในช่วง ตัวอย่างเช่นพิจารณาปัญหาต่อไปนี้.
เรียงชุดใหญ่ของตัวเลขลอยจุดซึ่งอยู่ในช่วง 0.0-1.0 และมีการกระจายอย่างสม่ำเสมอในช่วง เราไม่เรียงลำดับการแสดงตัวเลขได้อย่างมีประสิทธิภาพวิธีง่ายๆคือการใช้อัลกอริทึมการเรียงลำดับการเปรียบเทียบตาม ผูกไว้ที่ต่ำกว่าสำหรับการเปรียบเทียบขั้นตอนวิธีการเรียงลำดับตาม (ผสานเรียงกองเรียง, Quick-เรียง .. ฯลฯ ) คือ โอเมก้า (nlogn) นั่นคือพวกเขาไม่สามารถทำดีกว่า nlogn. เราสามารถจัดเรียงอาร์เรย์ในเส้นเวลา? จัดเรียงนับไม่สามารถนำมาใช้ที่นี่ในขณะที่เราใช้ปุ่มเป็นดัชนีในการนับการจัดเรียง นี่คือคีย์จะลอยหมายเลขจุด. มีแนวคิดที่จะใช้ประเภทถัง ต่อไปนี้เป็นอัลกอริทึมถัง. bucketSort (ARR [], n) 1) การสร้างถังที่ว่างเปล่า n (หรือรายการ). 2) ทำต่อไปนี้สำหรับทุกองค์ประกอบ ARR อาร์เรย์ [i]. ....... ) ใส่ ARR [i ] ลงในถัง [n อาร์เรย์ * [i]] 3) ถังแต่ละประเภทโดยใช้การจัดเรียงแทรก. 4) Concatenate ถังเรียงลำดับทั้งหมด. แผนภาพต่อไปนี้ (เอามาจากหนังสือ CLRS) แสดงให้เห็นถึงการทำงานของการจัดเรียงถัง. BucketSort เวลาซับซ้อน: ถ้าเราคิดว่าการแทรก ในถังใช้เวลา O (1) เวลาแล้วขั้นตอนที่ 1 และ 2 ของอัลกอริทึมดังกล่าวข้างต้นอย่างชัดเจนใช้เวลา O (n) เวลา (1) เป็นไปได้อย่างง่ายดายถ้าเราจะใช้รายการที่เชื่อมโยงให้เป็นตัวแทนของถัง (ในรหัสต่อไปนี้ C ++ เวกเตอร์ที่ใช้สำหรับความเรียบง่าย) ขั้นตอนที่ 4 ยังใช้เวลา O (n) เวลาที่จะมี n รายการในถังทั้งหมด. ขั้นตอนหลักในการวิเคราะห์เป็นขั้นตอนที่ 3 ขั้นตอนนี้ยังใช้เวลา O (n) เวลาโดยเฉลี่ยถ้าตัวเลขทั้งหมดจะถูกกระจาย (โปรดดูหนังสือ CLRS สำหรับรายละเอียดเพิ่มเติม) ดังต่อไปนี้คือ C ++ การดำเนินการตามขั้นตอนวิธีการดังกล่าวข้างต้น. // C ++ โปรแกรมในการจัดเรียงอาร์เรย์ใช้ถังจัดเรียง#include






















#include
#include
โดยใช้มาตรฐาน namespace; // ฟังก์ชั่นในการจัดเรียง ARR [] ขนาด n ใช้ถังจัดเรียงเป็นโมฆะ bucketSort (float ARR [], int n) { // 1) การสร้าง n ถังเปล่าเวกเตอร์





ข [N]; // 2) องค์ประกอบมากมายใส่ในถังที่แตกต่างกันสำหรับ (int i = 0; ฉัน


{
int สอง = n * ARR [i]; // ดัชนีในถัง
ข [สอง] .push_back (ARR [i]);
} // 3) ถังแต่ละประเภทfor (int i = 0; ฉัน


การจัดเรียง (ข [i] .begin (ก) ข [i] .end ()); // 4) Concatenate ถังทั้งหมดเป็น ARR [] ดัชนี int = 0; for (int i = 0; i <n; i ++) สำหรับ (int J = 0; J <b [i] ขนาดประมาณ (); J ++) ARR [ดัชนี ++] b = [ผม] [เจ]; } / * โปรแกรมไดร์เวอร์ในการทดสอบข้างต้น funtion * / int main () { ลอย ARR [] = {0.897, 0.565, 0.656, 0.1234, 0.665, 0.3434}; int n = sizeof (ARR) / sizeof (ARR [0]); bucketSort (ARR, n); ศาล << "อาร์เรย์เรียงคือ n "; for (int i = 0; ฉัน
















<< ศาล ARR [i] << "";
return 0;
}
Output: อาร์เรย์เรียงเป็น0.1234 0.3434 0.565 0.656 0.665 0.897 อ้างอิง: รู้เบื้องต้นเกี่ยวกับขั้นตอนวิธี 3rd Edition โดย Clifford สไตน์, โทมัสเอช Cormen, Charles E. Leiserson, โรนัลด์ L . Rivest http://en.wikipedia.org/wiki/Bucket_sort กรุณาเขียนความคิดเห็นถ้าคุณพบสิ่งที่ไม่ถูกต้องหรือคุณต้องการที่จะแบ่งปันข้อมูลเพิ่มเติมเกี่ยวกับหัวข้อที่กล่าวข้างต้น

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

ถังถังเรียงเรียง
เป็นประโยชน์ส่วนใหญ่เมื่อเข้าจุดกระจายช่วง ตัวอย่างเช่นพิจารณาปัญหาดังต่อไปนี้
เรียงชุดใหญ่ของตัวเลขจุดลอยตัวซึ่งอยู่ในช่วง 0.0 ถึง 1.0 และเป็นจุดกระจายทั่วบริเวณ เราจะเรียงตัวเลขได้อย่างมีประสิทธิภาพ ?

วิธีง่ายๆคือ ใช้เปรียบเทียบตามขั้นตอนวิธีการเรียงลำดับล่างไว้ สำหรับการเปรียบเทียบตามขั้นตอนวิธีการเรียงลำดับ ( ผสานเรียงกองเรียง . . . เรียงเร็ว ฯลฯ ) เป็น โอเมก้า ( nlogn ) คือพวกเขาไม่สามารถทำอะไรได้ดีกว่า nlogn .
เราสามารถเรียงลำดับอาร์เรย์ในเวลาเชิงเส้น ? นับเรียงไม่สามารถใช้ที่นี่เราใช้คีย์เป็นดัชนีในการนับการจัดเรียง ที่นี่คีย์ตัวเลขจุดลอยตัว
ความคิดที่จะใช้เป็นถัง ต่อไปนี้เป็นวิธีถัง bucketsort ( อ๋า

[ ]
n )1 ) สร้าง N ถังเปล่า ( หรือรายการ )
2 ) ต่อไปนี้ทุกองค์ประกอบอาร์เรย์ออก [ i ] .
. . . . . . . ) ใส่ในถังออก [ I ] [ n * เรย์ [ I ] ]
3 ) ถังแต่ละเรียงโดยใช้การจัดเรียงใส่ .
4
) concatenate ทั้งหมดเรียงตามถัง แผนภาพ ( นำมาจากหนังสือ clrs ) แสดงให้เห็นถึงการทำงานของเรียงถัง .



เวลา bucketsort ความซับซ้อน :ถ้าเราสมมติว่าแทรกในถังจะใช้เวลา O ( 1 ) แล้วเวลาขั้นตอนที่ 1 และ 2 ของขั้นตอนวิธีดังกล่าวได้อย่างชัดเจนใช้เวลา O ( n ) เวลา O ( 1 ) เป็นไปได้โดยง่าย ถ้าเราใช้รายการเชื่อมโยงเพื่อแสดงถัง ( ในรหัสต่อไปนี้ C เวกเตอร์ใช้ความเรียบง่าย ) ขั้นตอนที่ 4 ก็จะใช้เวลา O ( n ) เวลาจะมี N รายการในถัง
ขั้นตอนหลักเพื่อวิเคราะห์เป็นขั้นตอนที่ 3ขั้นตอนนี้ยังใช้เวลา O ( n ) เวลาเฉลี่ยถ้าตัวเลขทั้งหมดมีการกระจายอย่างสม่ำเสมอ ( โปรดดูรายละเอียดเพิ่มเติมในหนังสือ clrs )

ต่อไปนี้ C ใช้ขั้นตอนวิธีข้างต้น

/ / C โปรแกรมเรียง array ใช้ถังเรียง
#รวม < iostream >
< >
##รวมถึงขั้นตอนวิธี เวกเตอร์ฟรี > > รวม <
ใช้ namespace std ;

/ / ฟังก์ชั่นการจัดเรียงออก [ N ] ขนาดใช้ถังเรียง
bucketsort เป็นโมฆะ ( ลอยออก [ ] , INT N )
{
/ / /
1 ) สร้างที่ว่างเปล่าถังเวกเตอร์ < ลอย > B [ n ] ;

/ / 2 ) วางองค์ประกอบอาร์เรย์ในแต่ละถัง
( int i = 0 ; i < n ; I )
{
INT บี = * อา [ ผม ] ; / / ดัชนีในถัง
b [ บี ] push_back ( อ๋า [ i ] ) ;
}

/ / 3 ) การจัดเรียงแต่ละถัง
( int i = 0 ; i < n ; I )
เรียง ( B [ ฉัน ] begin() B [ ฉัน ] end() ) ;

/ / 4 ) concatenate ทั้งหมดถังเป็นอา [ ]

ดัชนี int = 0 ;( int = 0 ; i < n ; I )
( Int J = 0 ; j < b [ i ] . size() ; J )
อ๋า [ ดัชนี ] = b [ I ] [ j ] ;
}

/ * ไดรเวอร์โปรแกรมทดสอบข้างต้น funtion * / int main()

{
ลอยออก [ ] = { 0.897 0.565 , 0.656 , 0.1234 0.665 0.3434 , , , } ;
1 N = ขนาด ( ARR ) / ขนาด ( อ๋า [ 0 ] ) ;
bucketsort ( ARR , N )

< < " เรียงเป็น เคาท์ เรย์ n " ;
( int ผม = 0 ; i < n ; I )
[ i ] อ๋า เคาท์ < < < < " " ;
0 กลับ ; } :



ออกเรียงแถวเป็น
01234 0.3434 0.565 0.656 0.665 0.897 อ้างอิง :

แนะนำขั้นตอนวิธี 3 รุ่นโดย Clifford Stein , Thomas H . cormen ชาร์ลส์อี. แอล. ไลเซอร์สัน โรนัลด์ ริเวสต์
http : / / en . wikipedia . org / wiki / bucket_sort

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