Cách thanh lịch nhất để sắp xếp bong bóng trong C# là gì?

Question

Điều này có thể được làm sạch không?

using System; 
class AscendingBubbleSort 
{  
    public static void Main() 
    { 
     int i = 0,j = 0,t = 0; 
     int []c=new int[20]; 
     for(i=0;i<20;i++) 
     { 
      Console.WriteLine("Enter Value p[{0}]:", i); 
      c[i]=int.Parse(Console.ReadLine()); 
     } 
     // Sorting: Bubble Sort 
     for(i=0;i<20;i++) 
     { 
      for(j=i+1;j<20;j++) 
      { 
       if(c[i]>c[j]) 
       { 
        Console.WriteLine("c[{0}]={1}, c[{2}]={3}", i, c[i], j, c[j]); 
        t=c[i]; 
        c[i]=c[j]; 
        c[j]=t; 
       } 
      } 
     } 
     Console.WriteLine("bubble sorted array:"); 
     // sorted array output 
     for(i=0;i<20;i++) 
     { 
      Console.WriteLine ("c[{0}]={1}", i, c[i]); 
     } 
    } 
} 

Answer 1

gì bạn đã dán không có một bubble sort. Đó là một loại "bạo lực" sắp xếp nhưng nó không phải là loại bong bóng. Dưới đây là ví dụ về loại bong bóng chung. Nó sử dụng một trình so sánh tùy ý, nhưng cho phép bạn bỏ qua nó trong trường hợp đó trình so sánh mặc định được sử dụng cho loại có liên quan. Nó sẽ sắp xếp bất kỳ việc thực hiện (không đọc) nào của IList<T>, bao gồm các mảng. Đọc liên kết trên (tới Wikipedia) để biết thêm về ý tưởng về cách sắp xếp bong bóng có nghĩa là hoạt động. Lưu ý cách trên mỗi vòng lặp mà chúng ta trải qua từ đầu đến cuối, nhưng chỉ so sánh từng mục với hàng xóm của nó. Nó vẫn là một thuật toán sắp xếp O (n), nhưng trong nhiều trường hợp, nó sẽ nhanh hơn phiên bản bạn đã cung cấp.

public void BubbleSort<T>(IList<T> list) 
{ 
    BubbleSort<T>(list, Comparer<T>.Default); 
} 

public void BubbleSort<T>(IList<T> list, IComparer<T> comparer) 
{ 
    bool stillGoing = true; 
    while (stillGoing) 
    { 
     stillGoing = false; 
     for (int i = 0; i < list.Count-1; i++) 
     { 
      T x = list[i]; 
      T y = list[i + 1]; 
      if (comparer.Compare(x, y) > 0) 
      { 
       list[i] = y; 
       list[i + 1] = x; 
       stillGoing = true; 
      } 
     } 
    } 
} 

Answer 2

Cá nhân tôi thích này:

string foo [] = new string[] {"abc", "def", "aaa", "feaf", "afea" }; 
Array.Sort(foo); 

Nhưng đó chỉ là tôi. Sắp xếp là một vấn đề được giải quyết, tại sao lại phát minh ra bánh xe?

Answer 3

Tôi nghĩ thuật toán của bạn là ok, nhưng tôi sẽ đặt chức năng sắp xếp theo một lớp và phương thức riêng biệt.

Answer 4

Cách thanh lịch nhất để sắp xếp trong C# là

Array.Sort(object[]) 

Điều đó sẽ làm việc ở khắp mọi nơi ngoại trừ trong vấn đề bài tập về nhà mà giáo viên yêu cầu bạn thực hiện các thuật toán bong bóng sắp xếp không thanh lịch. ;-)

Answer 5

• Tôi sẽ sử dụng hoán đổi để trao đổi hai mục. (chi tiết về làm thế nào để viết phương pháp hoán đổi trái như bài tập về nhà!)

• Bạn nên suy nghĩ về trường hợp khi các mặt hàng đã có trong trật tự

• Bạn nên đọc lên trên Sắp xếp chèn cho dấu hơn :-)

• Thay sau đó đọc dữ liệu thử nghiệm từ bàn phím, xem bạn có thể học cách sử dụng nUnit

Answer 6

Hầu hết mọi người sẽ không bận tâm khi tạo một kiểu bong bóng thanh lịch. Trong chung, tuy nhiên, tôi thấy rằng làm điều này:

for (int i = 0; i < items.Length; i++) { 
    Item item = items[i]; 
    // do something with item 
} 

vừa thanh lịch hơn và nhiều hơn nữa duy trì hơn làm điều này:

Item item; 
int i; 
for (i = 0; i < items.Length; i++) { 
    item = items[i]; 
    // do something with item 
} 

Nói cách khác, khai báo các biến của bạn trong áp dụng nhỏ nhất phạm vi. Nếu không, bạn có thể thấy mình đang làm điều gì đó với i hoặc item tại một số điểm khác trong mã và sau đó sử dụng lại chúng ở nơi bạn không nên ở.

Answer 7

Nhìn chung, không có gì sai với việc triển khai sắp xếp bong bóng của bạn.Nếu tôi được làm một xét mã thực, tôi muốn thực hiện các thay đổi sau:

Chọn tên biến mô tả nhiều hơn

Tại sao mảng của bạn chỉ cần gọi c?

Giảm thiểu phạm vi biến

Tất cả các biến của bạn được khai báo ở phía trên cùng của hàm. Trừ khi đây là một yêu cầu bài tập về nhà hoặc một tiêu chuẩn mã hóa, nó thành ngữ hơn để khai báo các biến "đóng" đến vị trí chúng được sử dụng, tốt nhất là chúng có phạm vi nhỏ nhất có thể.

Vì vậy, hãy loại bỏ dòng đầu tiên đọc int i = 0,j = 0,t = 0;. Khai báo vòng lặp quầy inline:

for(int i = 0; i < 20; i++) 

Và khai báo biến temp của bạn tại nơi sử dụng của nó:

   Console.WriteLine("c[{0}]={1}, c[{2}]={3}", i, c[i], j, c[j]); 
       int t=c[i]; 
       c[i]=c[j]; 
       c[j]=t; 

Loại bỏ giới hạn mảng mã hóa cứng.

này:

for(i=0;i<20;i++) 

trở thành này:

for(i = 0; i < c.Length; i++) 

Answer 8

Tôi tin rằng có sự cải thiện trong answer bởi Jon Skeet đề xuất. Sau mỗi vòng lặp, số lần lặp lại sẽ loại trừ mục cuối cùng được xử lý trong lần lặp trước đó. Vì vậy, đây là các mã:

public void BubbleSortImproved<T>(IList<T> list) 
{ 
    BubbleSortImproved<T>(list, Comparer<T>.Default); 
} 

public void BubbleSortImproved<T>(IList<T> list, IComparer<T> comparer) 
{ 
    bool stillGoing = true; 
    int k = 0; 
    while (stillGoing) 
    { 
     stillGoing = false; 
     //reduce the iterations number after each loop 
     for (int i = 0; i < list.Count - 1 - k; i++) 
     { 
      T x = list[i]; 
      T y = list[i + 1]; 
      if (comparer.Compare(x, y) > 0) 
      { 
       list[i] = y; 
       list[i + 1] = x; 
       stillGoing = true; 
      } 
     } 
     k++; 
    } 
} 

Answer 9

int[] array = {4,5,7,1,8};   

int n1, n2; 
bool stillgoing = true; 

while (stillgoing) 
{ 
    stillgoing = false; 
    for (int i = 0; i < (array.Length-1); i++) 
    {     
     if (array[i] > array[i + 1]) 
     { 
      n1 = array[i + 1]; 
      n2 = array[i]; 

      array[i] = n1; 
      array[i + 1] = n2; 
      stillgoing = true; 
     } 
    } 
} 
for (int i = 0; i < array.Length; i++) 
{ 
    Console.WriteLine(array[i]); 
} 

Took một số ý tưởng từ Jon Skeet ...

Answer 10

public int[] BubbleSortInAesc(int[] input) 
    { 
     for (int i = input.Length; i > 0; i--) 
     { 
      for (int j = 0; j < i-1; j++) 
      { 
       if (input[j] > input[j + 1]) 
       { 
        //Swap the numbers 
        input[j] = input[j + 1]+input[j]; 
        input[j + 1] = input[j] - input[j + 1]; 
        input[j] = input[j] - input[j + 1]; 
       } 
      } 
     } 
     return input; 
    }