2013-02-08 37 views
18
int[] arr = {800,11,50,771,649,770,240, 9}; 

int temp = 0; 

for (int write = 0; write < arr.Length; write++) 
{ 
    for (int sort = 0; sort < arr.Length - 1; sort++) 
    { 
     if (arr[sort] > arr[sort + 1]) 
     { 
      temp = arr[sort + 1]; 
      arr[sort + 1] = arr[sort]; 
      arr[sort] = temp; 
     }  
    } 
    Console.Write("{0} ", arr[write]); 
} 

Tất cả những gì tôi đang cố làm là sắp xếp bong bóng đơn giản với mảng này. Tôi muốn tìm ra lý do tại sao việc phân loại lại hơi say. Trong ví dụ, ở đây là khi mảng là {800,11,50,771,649,770,240, 9}:Loại bong bóng đơn giản C#

Đây là những gì được hiển thị: 11, 50, 649, 9, 649, 770, 771, 800

Tôi nghĩ rằng tôi có thể bị mất một cái gì đó trong sự so sánh.

+0

Cậu vòng ngoài đi từ đầu đến cuối, nên cuối để bắt đầu! bạn cũng là vòng lặp bên trong nên được giới hạn trong giá trị của viết. – Polity

+0

@ Thành thật: Tôi không tin điều đó đúng. Như câu trả lời cho thấy, vòng lặp bên ngoài là chính xác như là. Bạn nói đúng về vòng lặp bên trong. –

+0

Tôi hy vọng đây chỉ là một bài tập trong việc học các thao tác mảng? Tôi không thể nghĩ ra bất kỳ ứng dụng nào mà Bubble Sort sẽ là chiến lược phân loại 'tối ưu'. Nếu nó chỉ là để trình diễn/tinh thần tập thể dục sau đó tốt, nhưng nếu bạn đang sử dụng này là một ứng dụng thực tế có lẽ bạn nên xem xét một số thuật toán 'sắp xếp' khác. – Th3Minstr3l

Trả lời

52

Không, thuật toán của bạn hoạt động nhưng hoạt động Write của bạn bị đặt không đúng chỗ trong vòng lặp ngoài.

int[] arr = { 800, 11, 50, 771, 649, 770, 240, 9 }; 

int temp = 0; 

for (int write = 0; write < arr.Length; write++) { 
    for (int sort = 0; sort < arr.Length - 1; sort++) { 
     if (arr[sort] > arr[sort + 1]) { 
      temp = arr[sort + 1]; 
      arr[sort + 1] = arr[sort]; 
      arr[sort] = temp; 
     } 
    } 
} 

for (int i = 0; i < arr.Length; i++) 
    Console.Write(arr[i] + " "); 

Console.ReadKey(); 
+3

Đối với bất cứ ai đề nghị Viết của tôi là thất lạc, cảm ơn bạn! Đó là những gì đã gây ra mọi thứ để có được hơi say lên. Bây giờ nó hoạt động –

0

Console.Write("{0} ", arr[write]); của bạn quá sớm. Bạn đang in các giá trị trong khi sắp xếp vẫn đang được tiến hành. Ví dụ: bạn đang in 9 làm chỉ mục 3 trong mảng, nhưng trên lần lặp lại tiếp theo của vòng lặp 9 đã chuyển sang chỉ mục 2 và 240 đã chuyển sang chỉ mục 3 ... nhưng bạn đã chuyển vòng ngoài chuyển tiếp để nó in 649 lần thứ hai và 240 không bao giờ được in.

+0

Điều này không thực sự đúng, anh ta in ra giá trị bằng văn bản cuối cùng. Điều này có nghĩa là sau khi sửa chữa, kết quả sẽ được in theo thứ tự gốc (mặc dù được sắp xếp). – Polity

+0

@Polity - 'Anh ấy in ra giá trị bằng văn bản cuối cùng.' - Tôi nghĩ bạn hiểu nhầm 'Bubble Sort'.Anh ấy rõ ràng xuất các giá trị cho giao diện điều khiển trước khi thuật toán kết thúc sắp xếp. Không có gì sai với logic sắp xếp thực tế ở trên với điều kiện anh ta chỉ muốn thực hiện một loại bong bóng. - http://en.wikipedia.org/wiki/Bubble_sort – McAden

9

một này làm việc cho tôi

public static int[] SortArray(int[] array) 
{ 
    int length = array.Length; 

    int temp = array[0]; 

    for (int i = 0; i < length; i++) 
    { 
     for (int j = i+1; j < length; j++) 
     { 
      if (array[i] > array[j]) 
      { 
       temp = array[i]; 

       array[i] = array[j]; 

       array[j] = temp; 
      } 
     } 
    } 

    return array;   
} 
+0

Đã gần như cùng một giải pháp: int [] unsorted = new int [] { 3,4,13,1,18,22,2,100,11 }; // bong bóng sắp xếp for (int i = 0; i

+0

Nó không phải là [Bubble sort] (https://en.wikipedia.org/wiki/Sorting_algorithm#Bubble_sort). Từ wikipedia: "Thuật toán bắt đầu từ đầu tập dữ liệu. Nó bắt đầu so sánh hai phần tử đầu tiên và nếu phần tử đầu tiên lớn hơn giá trị thứ hai, nó sẽ hoán đổi chúng. ** Nó tiếp tục thực hiện việc này cho mỗi cặp phần tử lân cận cuối cùng của tập dữ liệu. ** Sau đó nó bắt đầu lại với hai phần tử đầu tiên, lặp lại cho đến khi không có sự hoán đổi nào xảy ra trên lần cuối cùng. " – MiniMax

3

tôi thấy một người nào đó sử dụng ví dụ này như một phần của một bài kiểm tra hồ sơ xin việc. Phản hồi của tôi với anh ta là nó thiếu một sự thoát khỏi vòng ngoài khi mảng được sắp xếp chủ yếu.

xem xét những gì sẽ xảy ra trong trường hợp này:

int[] arr = {1,2,3,4,5,6,7,8}; 

đây là một cái gì đó có ý nghĩa hơn:

int[] arr = {1,2,3,4,5,6,7,8}; 

int temp = 0; 
int loopCount=0; 
bool doBreak=true; 

for (int write = 0; write < arr.Length; write++) 
{ 
    doBreak=true; 
    for (int sort = 0; sort < arr.Length - 1; sort++) 
    { 
     if (arr[sort] > arr[sort + 1]) 
     { 
      temp = arr[sort + 1]; 
      arr[sort + 1] = arr[sort]; 
      arr[sort] = temp; 
      doBreak=false; 
     } 
     loopCount++; 
    } 
    if(doBreak){ break; /*early escape*/ } 
} 

Console.WriteLine(loopCount); 
for (int i = 0; i < arr.Length; i++) Console.Write(arr[i] + " "); 
+3

Tôi đồng ý với phản hồi của bạn, nhưng đó không phải là loại bong bóng "truyền thống" với lối thoát từ vòng ngoài. –

4
int[] arr = { 800, 11, 50, 771, 649, 770, 240, 9 }; 

int temp = 0; 

for (int write = 0; write < arr.Length; write++) 
{ 
    for (int sort = 0; sort < arr.Length - 1 - write ; sort++) 
    { 
     if (arr[sort] > arr[sort + 1]) 
     { 
      temp = arr[sort + 1]; 
      arr[sort + 1] = arr[sort]; 
      arr[sort] = temp; 
     } 
    } 
} 

for (int i = 0; i < arr.Length; i++) Console.Write(arr[i] + " "); 

Console.ReadKey(); 
0
int[] array = new int[10] { 13, 2, 5, 8, 23, 90, 41, 4, 77, 61 }; 

for (int i = 10; i > 0; i--) 
{ 
    for (int j = 0; j < 9; j++) 
    { 
     if (array[j] > array[j + 1]) 
     { 
      int temp = array[j]; 
      array[j] = array[j + 1]; 
      array[j + 1] = temp; 
     } 
    } 
} 
0
static bool BubbleSort(ref List<int> myList, int number) 
    { 
     if (number == 1) 
      return true; 
     for (int i = 0; i < number; i++) 
     { 
      if ((i + 1 < number) && (myList[i] > myList[i + 1])) 
      { 
       int temp = myList[i]; 
       myList[i] = myList[i + 1]; 
       myList[i + 1] = temp; 
      } 
      else 
       continue; 
     } 
     return BubbleSort(ref myList, number - 1); 
    } 
+0

Có thể viết một lời giải thích ngắn là tốt. – Numbers

0

Chỉ cần một ví dụ khác nhưng với một KHI outter vòng lặp thay vì FOR:

public static void Bubble() 
    { 
     int[] data = { 5, 4, 3, 2, 1 }; 
     bool newLoopNeeded = false; 
     int temp; 
     int loop = 0; 

     while (!newLoopNeeded) 
     { 
      newLoopNeeded = true; 
      for (int i = 0; i < data.Length - 1; i++) 
      { 
       if (data[i + 1] < data[i]) 
       { 
        temp = data[i]; 
        data[i] = data[i + 1]; 
        data[i + 1] = temp; 
        newLoopNeeded = false; 
       } 
       loop++; 
      } 
     } 
    } 
+1

Ví dụ vòng lặp while này chậm hơn cả BubbleSort mặc định và các thuật toán BubbleSort thoát ở trên với dữ liệu chưa được phân loại ngẫu nhiên ... – ManIkWeet

-1
int[] arr = { 800, 11, 50, 771, 649, 770, 240, 9 }; 
for (int i = 0; i < arr.Length; i++) 
{ 
    for (int j = i; j < arr.Length ; j++) 
    { 
     if (arr[j] < arr[i]) 
     { 
      int temp = arr[i]; 
      arr[i] = arr[j]; 
      arr[j] = temp; 
     } 
    } 
} 
Console.ReadLine(); 
+1

điều này sai, mã ở trên bạn đã hiển thị là loại sắp xếp - không phân loại bong bóng .. trong bong bóng sắp xếp bạn di chuyển được so sánh các yếu tố lân cận .. hãy cập nhật nó. cho (int i = 0; i arr [j + i ]) { int temp = arr [j + 1]; arr [j + 1] = arr [j]; arr [j] = temp; } } } –

5
public static void BubbleSort(int[] a) 
    { 

     for (int i = 1; i <= a.Length - 1; ++i) 

      for (int j = 0; j < a.Length - i; ++j) 

       if (a[j] > a[j + 1]) 


        Swap(ref a[j], ref a[j + 1]); 

    } 

    public static void Swap(ref int x, ref int y) 
    { 
     int temp = x; 
     x = y; 
     y = temp; 
    } 
+5

Vui lòng không chỉ đăng mã. Giải thích những gì bạn đang cho chúng tôi thấy. – Andrew

+10

Mã rõ ràng và tự viết tài liệu không cần nhận xét. – birdus

-1
using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Threading.Tasks; 

namespace Practice { 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      Console.WriteLine("Enter the size"); 
      int n = Convert.ToInt32(Console.ReadLine()); 
      int[] mynum = new int[n]; 
      Console.WriteLine("Enter the Numbers"); 
      for (int p = 0; p < n;p++) 
      { 
       mynum[p] = Convert.ToInt32(Console.ReadLine()); 

      } 
      Console.WriteLine("The number are"); 
       foreach(int p in mynum) 
       { 
        Console.WriteLine(p); 
       } 
       for (int i = 0; i < n;i++) 
       { 
        for(int j=i+1;j<n;j++) 
        { 
         if(mynum[i]>mynum[j]) 
         { 
          int x = mynum[j]; 
          mynum[j] = mynum[i]; 
          mynum[i] = x; 
         } 
        } 
       } 
       Console.WriteLine("Sortrd data is-"); 
      foreach(int p in mynum) 
      { 
       Console.WriteLine(p); 
      } 
        Console.ReadLine(); 
     } 
    } } 
+1

Sai - bạn đang hiển thị lựa chọn sắp xếp ở đây. Bạn đang so sánh phần tử đầu tiên I = 0 với mọi phần tử của j = I + 1, đây là kiểu sắp xếp và không phải kiểu bong bóng .. trong kiểu bong bóng cho mỗi lần vượt qua phần tử đầu tiên j = được so sánh với j + 1 và nếu không theo thứ tự nó được hoán đổi, điều này sẽ được thực hiện cho mọi lần chuyền trên i. Vui lòng kiểm tra vòng lặp for của bạn và câu trả lời đầu tiên từ matten –

-1
public void BubbleSortNum() 
    { 
     int[] a = {10,5,30,25,40,20}; 
     int length = a.Length; 
     int temp = 0; 
     for (int i = 0; i <length; i++) 
     {    
      for(int j=i;j<length; j++) 
      { 
       if (a[i]>a[j]) 
       { 
        temp = a[j]; 
        a[j] = a[i]; 
        a[i] = temp; 
       }  
      } 
      Console.WriteLine(a[i]); 
     }  
    } 
Các vấn đề liên quan