Bong bóng sắp xếp bài tập về nhà

Trong lớp, chúng tôi đang thực hiện các thuật toán sắp xếp và mặc dù tôi hiểu chúng rất tốt khi nói về chúng và viết mã giả, tôi gặp vấn đề khi viết mã thực tế cho chúng.

Đây là nỗ lực của tôi trong Python:

mylist = [12, 5, 13, 8, 9, 65]

def bubble(badList):
    length = len(badList) - 1
    unsorted = True

    while unsorted:
        for element in range(0,length):
            unsorted = False
            if badList[element] > badList[element + 1]:
                hold = badList[element + 1]
                badList[element + 1] = badList[element]
                badList[element] = hold
                print badList
            else:
                unsorted = True

print bubble(mylist)

Bây giờ, điều này (theo như tôi có thể nói) sắp xếp chính xác, nhưng một khi nó hoàn thành, nó chỉ lặp lại vô thời hạn.

Làm thế nào mã này có thể được sửa chữa để chức năng kết thúc đúng và sắp xếp chính xác một danh sách bất kỳ kích thước (hợp lý)?

Tái bút: Tôi biết rằng tôi không thực sự có các bản in trong một chức năng và tôi nên trả lại, nhưng tôi vẫn chưa làm điều đó vì mã của tôi chưa thực sự hoạt động.

Để giải thích tại sao tập lệnh của bạn không hoạt động ngay bây giờ, tôi sẽ đổi tên biến unsortedthành sorted.

Lúc đầu, danh sách của bạn chưa được sắp xếp. Tất nhiên, chúng tôi đặt sortedra False.

Ngay khi chúng tôi bắt đầu whilevòng lặp, chúng tôi giả định rằng danh sách đã được sắp xếp. Ý tưởng là thế này: ngay khi chúng tôi tìm thấy hai yếu tố không theo đúng thứ tự, chúng tôi đặt sortedlại False. sortedsẽ True chỉ còn lại nếu không có yếu tố nào theo thứ tự sai .

sorted = False  # We haven't started sorting yet

while not sorted:
    sorted = True  # Assume the list is now sorted
    for element in range(0, length):
        if badList[element] > badList[element + 1]:
            sorted = False  # We found two elements in the wrong order
            hold = badList[element + 1]
            badList[element + 1] = badList[element]
            badList[element] = hold
    # We went through the whole list. At this point, if there were no elements
    # in the wrong order, sorted is still True. Otherwise, it's false, and the
    # while loop executes again.

Ngoài ra còn có một số vấn đề nhỏ sẽ giúp mã hiệu quả hơn hoặc dễ đọc hơn.

• Trong forvòng lặp, bạn sử dụng biến element. Về mặt kỹ thuật, elementkhông phải là một yếu tố; đó là một con số đại diện cho một chỉ mục danh sách. Ngoài ra, nó khá dài. Trong những trường hợp này, chỉ cần sử dụng một tên biến tạm thời, như icho "index".

  for i in range(0, length):

• Các rangelệnh cũng có thể chỉ mất một đối số (tên stop). Trong trường hợp đó, bạn nhận được một danh sách tất cả các số nguyên từ 0 đến đối số đó.

  for i in range(length):

• Các Python Style Guide khuyến cáo rằng các biến có tên trong chữ thường với dấu gạch dưới. Đây là một nitlog rất nhỏ cho một kịch bản nhỏ như thế này; sẽ tốt hơn nếu bạn quen với những gì mã Python thường giống nhất.

  def bubble(bad_list):

• Để hoán đổi các giá trị của hai biến, hãy viết chúng dưới dạng gán tuple. Phía bên tay phải được đánh giá là một tuple (giả sử (badList[i+1], badList[i])là (3, 5)) và sau đó được gán cho hai biến ở phía bên trái ( (badList[i], badList[i+1])).

  bad_list[i], bad_list[i+1] = bad_list[i+1], bad_list[i]

Đặt tất cả lại với nhau, và bạn nhận được điều này:

my_list = [12, 5, 13, 8, 9, 65]

def bubble(bad_list):
    length = len(bad_list) - 1
    sorted = False

    while not sorted:
        sorted = True
        for i in range(length):
            if bad_list[i] > bad_list[i+1]:
                sorted = False
                bad_list[i], bad_list[i+1] = bad_list[i+1], bad_list[i]

bubble(my_list)
print my_list

(Nhân tiện, tôi cũng xóa câu lệnh in của bạn.)

Mục tiêu của sắp xếp bong bóng là để di chuyển các vật nặng hơn ở dưới cùng trong mỗi vòng, trong khi di chuyển các vật nhẹ hơn lên. Trong vòng lặp bên trong, nơi bạn so sánh các yếu tố, bạn không phải lặp lại toàn bộ danh sách trong mỗi lượt . Các nặng nhất đã được đặt trước. Các hoán đổi biến là một kiểm tra thêm vì vậy chúng tôi có thể đánh dấu rằng danh sách này hiện đang được sắp xếp và tránh tiếp tục với các tính toán cần thiết.

def bubble(badList):
    length = len(badList)
    for i in range(0,length):
        swapped = False
        for element in range(0, length-i-1):
            if badList[element] > badList[element + 1]:
                hold = badList[element + 1]
                badList[element + 1] = badList[element]
                badList[element] = hold
                swapped = True
        if not swapped: break

    return badList

Phiên bản 1 của bạn, đã sửa:

def bubble(badList):
    length = len(badList) - 1
    unsorted = True
    while unsorted:
        unsorted = False
        for element in range(0,length):
            #unsorted = False
            if badList[element] > badList[element + 1]:
                 hold = badList[element + 1]
                 badList[element + 1] = badList[element]
                 badList[element] = hold
                 unsorted = True
                 #print badList
             #else:
                 #unsorted = True

     return badList

Đây là những gì xảy ra khi bạn sử dụng tên biến có nghĩa tiêu cực, bạn cần đảo ngược các giá trị của chúng. Sau đây sẽ dễ hiểu hơn:

sorted = False
while not sorted:
    ...

Mặt khác, logic của thuật toán là một chút tắt. Bạn cần kiểm tra xem hai phần tử được hoán đổi trong vòng lặp for. Đây là cách tôi sẽ viết nó:

def bubble(values):
    length = len(values) - 1
    sorted = False
    while not sorted:
        sorted = True
        for element in range(0,length):
            if values[element] > values[element + 1]:
                 hold = values[element + 1]
                 values[element + 1] = values[element]
                 values[element] = hold
                 sorted = False
    return values

Việc bạn sử dụng biến Unsort là sai; bạn muốn có một biến cho bạn biết nếu bạn đã hoán đổi hai yếu tố; nếu bạn đã làm điều đó, bạn có thể thoát khỏi vòng lặp của mình, nếu không, bạn cần phải lặp lại. Để khắc phục những gì bạn đã có ở đây, chỉ cần đặt "unsort = false" trong phần thân của trường hợp nếu bạn; loại bỏ trường hợp khác của bạn; và đặt "unsort = true trước forvòng lặp của bạn .

def bubble_sort(l):
    for passes_left in range(len(l)-1, 0, -1):
        for index in range(passes_left):
            if l[index] < l[index + 1]:
               l[index], l[index + 1] = l[index + 1], l[index]
    return l

# Một chức năng rất đơn giản, có thể được tối ưu hóa (rõ ràng) bằng cách giảm không gian vấn đề của mảng thứ 2. Nhưng cùng độ phức tạp O (n ^ 2).

def bubble(arr):
    l = len(arr)        
    for a in range(l):
        for b in range(l-1):
            if (arr[a] < arr[b]):
            arr[a], arr[b] = arr[b], arr[a]
    return arr 

Bạn đã có một vài lỗi trong đó. Đầu tiên là chiều dài và thứ hai là trong việc bạn sử dụng chưa được sắp xếp (như đã nêu của McWafflestix). Bạn cũng có thể muốn trả về danh sách nếu bạn sẽ in nó:

mylist = [12, 5, 13, 8, 9, 65]

def bubble(badList):
    length = len(badList) - 2
    unsorted = True

    while unsorted:
        for element in range(0,length):
            unsorted = False

            if badList[element] > badList[element + 1]:
                hold = badList[element + 1]
                badList[element + 1] = badList[element]
                badList[element] = hold
                print badList
                unsorted = True

    return badList

print bubble(mylist)

eta: Bạn nói đúng, ở trên là lỗi như địa ngục. Xấu của tôi không kiểm tra thông qua một số ví dụ.

def bubble2(badList):
    swapped = True
    length = len(badList) - 2

    while swapped:
        swapped = False
        for i in range(0, length):
            if badList[i] > badList[i + 1]:

                # swap
                hold = badList[i + 1]
                badList[i + 1] = badList[i]
                badList[i] = hold

                swapped = True

    return badList

Tôi là một người mới bắt đầu mới, bắt đầu đọc về Python ngày hôm qua. Lấy cảm hứng từ ví dụ của bạn, tôi đã tạo ra một cái gì đó có thể nhiều hơn trong phong cách 80 mối quan hệ, nhưng tuy nhiên nó vẫn hoạt động

lista1 = [12, 5, 13, 8, 9, 65]

i=0
while i < len(lista1)-1:
    if lista1[i] > lista1[i+1]:
        x = lista1[i]
        lista1[i] = lista1[i+1]
        lista1[i+1] = x
        i=0
        continue
    else:
        i+=1

print(lista1)

Vấn đề với thuật toán ban đầu là nếu bạn có số thấp hơn nữa trong danh sách, nó sẽ không đưa nó đến vị trí được sắp xếp chính xác. Chương trình cần quay lại từ đầu mỗi lần để đảm bảo rằng các con số sắp xếp hoàn toàn.

Tôi đã đơn giản hóa mã và bây giờ nó sẽ hoạt động cho bất kỳ danh sách số nào bất kể danh sách và ngay cả khi có các số lặp lại. Đây là mã

mylist = [9, 8, 5, 4, 12, 1, 7, 5, 2]
print mylist

def bubble(badList):
    length = len(badList) - 1
    element = 0
    while element < length:
        if badList[element] > badList[element + 1]:
            hold = badList[element + 1]
            badList[element + 1] = badList[element]
            badList[element] = hold
            element = 0
            print badList
        else:
            element = element + 1

print bubble(mylist)

def bubble_sort(l):
    exchanged = True
    iteration = 0
    n = len(l)

    while(exchanged):
        iteration += 1
        exchanged = False

        # Move the largest element to the end of the list
        for i in range(n-1):
            if l[i] > l[i+1]:
                exchanged = True
                l[i], l[i+1] = l[i+1], l[i]
        n -= 1   # Largest element already towards the end

    print 'Iterations: %s' %(iteration)
    return l

def bubbleSort(alist):
if len(alist) <= 1:
    return alist
for i in range(0,len(alist)):
   print "i is :%d",i
   for j in range(0,i):
      print "j is:%d",j
      print "alist[i] is :%d, alist[j] is :%d"%(alist[i],alist[j])
      if alist[i] > alist[j]:
         alist[i],alist[j] = alist[j],alist[i]
return alist

alist = [54,26,93,17,77,31,44,55,20, -23, -34,16,11,11,11]

in bubbleSort (alist)

def bubble_sort(a):
    t = 0
    sorted = False # sorted = False because we have not began to sort
    while not sorted:
    sorted = True # Assume sorted = True first, it will switch only there is any change
        for key in range(1,len(a)):
            if a[key-1] > a[key]:
                sorted = False
                t = a[key-1]; a[key-1] = a[key]; a[key] = t;
    print a

Một ví dụ đơn giản hơn:

a = len(alist)-1
while a > 0:
    for b in range(0,a):
        #compare with the adjacent element
        if alist[b]>=alist[b+1]:
            #swap both elements
            alist[b], alist[b+1] = alist[b+1], alist[b]
    a-=1

Điều này chỉ đơn giản là lấy các phần tử từ 0 đến a (về cơ bản, tất cả các phần tử chưa được sắp xếp trong vòng đó) và so sánh nó với phần tử liền kề của nó và thực hiện hoán đổi nếu nó lớn hơn phần tử lân cận. Vào cuối vòng, phần tử cuối cùng được sắp xếp và quá trình chạy lại mà không có nó, cho đến khi tất cả các phần tử đã được sắp xếp.

Không cần một điều kiện cho dù sortlà đúng hay không.

Lưu ý rằng thuật toán này sẽ xem xét vị trí của các số chỉ khi hoán đổi, vì vậy các số lặp lại sẽ không ảnh hưởng đến nó.

Tái bút Tôi biết đã rất lâu kể từ khi câu hỏi này được đăng, nhưng tôi chỉ muốn chia sẻ ý tưởng này.

arr = [5,4,3,1,6,8,10,9] # array not sorted

for i in range(len(arr)):
    for j in range(i, len(arr)):
        if(arr[i] > arr[j]):
            arr[i], arr[j] = arr[j], arr[i]

            print (arr)

def bubble_sort(li):
    l = len(li)
    tmp = None
    sorted_l = sorted(li)
    while (li != sorted_l):
        for ele in range(0,l-1):
            if li[ele] > li[ele+1]:
                tmp = li[ele+1]
                li[ele+1] = li [ele]
                li[ele] = tmp
    return li

def bubbleSort ( arr ):
    swapped = True 
    length = len ( arr )
    j = 0

    while swapped:
        swapped = False
        j += 1 
        for i in range ( length  - j ):
            if arr [ i ] > arr [ i + 1 ]:
                # swap
                tmp = arr [ i ]
                arr [ i ] = arr [ i + 1]
                arr [ i + 1 ] = tmp 

                swapped = True

if __name__ == '__main__':
    # test list
    a = [ 67, 45, 39, -1, -5, -44 ];

    print ( a )
    bubbleSort ( a )
    print ( a )

def bubblesort(array):
    for i in range(len(array)-1):
        for j in range(len(array)-1-i):
            if array[j] > array[j+1]:
                array[j], array[j+1] = array[j+1], array[j]
    return(array)

print(bubblesort([3,1,6,2,5,4]))

Tôi xem xét thêm giải pháp của mình bởi vì bao giờ giải pháp ở đây đang có

1. thời gian lớn hơn
2. độ phức tạp không gian lớn hơn
3. hoặc thực hiện quá nhiều thao tác

vậy thì nên

Vì vậy, đây là giải pháp của tôi:

def countInversions(arr):
    count = 0
    n = len(arr)
    for i in range(n):
        _count = count
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                count += 1
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
        if _count == count:
            break
    return count

Nếu bất cứ ai quan tâm đến việc thực hiện ngắn hơn bằng cách sử dụng một danh sách hiểu:

def bubble_sort(lst: list) -> None:
    [swap_items(lst, i, i+1) for left in range(len(lst)-1, 0, -1) for i in range(left) if lst[i] > lst[i+1]]


def swap_items(lst: list, pos1: int, pos2: int) -> None:
    lst[pos1], lst[pos2] = lst[pos2], lst[pos1]

Đây là một biến thể khác nhau của sắp xếp bong bóng không có forvòng lặp. Về cơ bản bạn đang xem xét lastIndexcủa arrayvà từ từ decrementingcho đến khi nó chỉ số đầu tiên của mảng.

Ý algorithmchí sẽ tiếp tục di chuyển qua mảng như thế này cho đến khi toàn bộ đường chuyền được thực hiện mà không swapsxảy ra.

Bong bóng là loại cơ bản là Quadratic Time: O(n²)khi nói đến hiệu suất.

class BubbleSort: 
  def __init__(self, arr):
    self.arr = arr;

  def bubbleSort(self):
    count = 0;
    lastIndex = len(self.arr) - 1;
    
    while(count < lastIndex):
      if(self.arr[count] > self.arr[count + 1]):
        self.swap(count)  
      count = count + 1;

      if(count == lastIndex):
        count = 0;
        lastIndex = lastIndex - 1;   

  def swap(self, count):
    temp = self.arr[count];
    self.arr[count] = self.arr[count + 1];
    self.arr[count + 1] = temp;
    
arr = [9, 1, 5, 3, 8, 2]
p1 = BubbleSort(arr)

print(p1.bubbleSort())

Câu trả lời được cung cấp bởi fury và Martin Côte đã khắc phục vấn đề của vòng lặp vô hạn, nhưng mã của tôi vẫn không hoạt động chính xác (đối với danh sách lớn hơn, nó sẽ không sắp xếp chính xác.). Cuối cùng tôi đã bỏ qua unsortedbiến và sử dụng một bộ đếm thay thế.

def bubble(badList):
    length = len(badList) - 1
    n = 0
    while n < len(badList):
        for element in range(0,length):
            if badList[element] > badList[element + 1]:
                hold = badList[element + 1]
                badList[element + 1] = badList[element]
                badList[element] = hold
                n = 0
            else:
                n += 1
    return badList

if __name__ == '__main__':
    mylist = [90, 10, 2, 76, 17, 66, 57, 23, 57, 99]
    print bubble(mylist)

Nếu bất cứ ai có thể cung cấp bất kỳ gợi ý nào về cách cải thiện mã của tôi trong các bình luận, nó sẽ được đánh giá cao.

Thử cái này

a = int(input("Enter Limit"))


val = []

for z in range(0,a):
    b = int(input("Enter Number in List"))
    val.append(b)


for y in range(0,len(val)):
   for x in range(0,len(val)-1):
       if val[x]>val[x+1]:
           t = val[x]
           val[x] = val[x+1]
           val[x+1] = t

print(val)

idk nếu điều này có thể giúp bạn sau 9 năm ... đó là một chương trình sắp xếp bong bóng đơn giản

    l=[1,6,3,7,5,9,8,2,4,10]

    for i in range(1,len(l)):
        for j in range (i+1,len(l)):
            if l[i]>l[j]:
                l[i],l[j]=l[j],l[i]

def merge_bubble(arr):
    k = len(arr)
    while k>2:
        for i in range(0,k-1):
            for j in range(0,k-1):
                if arr[j] > arr[j+1]:
                    arr[j],arr[j+1] = arr[j+1],arr[j]

        return arr
        break
    else:
        if arr[0] > arr[1]:
            arr[0],arr[1] = arr[1],arr[0]
        return arr 

def bubble_sort(l):
    for i in range(len(l) -1):
        for j in range(len(l)-i-1):
            if l[j] > l[j+1]:
                l[j],l[j+1] = l[j+1], l[j]
    return l

def bubble_sorted(arr:list):
    while True:
        for i in range(0,len(arr)-1):
            count = 0
            if arr[i] > arr[i+1]:
                count += 1
                arr[i], arr[i+1] = arr[i+1], arr[i]
        if count == 0:
            break
    return arr
arr = [30,20,80,40,50,10,60,70,90]
print(bubble_sorted(arr))
#[20, 30, 40, 50, 10, 60, 70, 80, 90]

def bubbleSort(a): def swap(x, y): temp = a[x] a[x] = a[y] a[y] = temp #outer loop for j in range(len(a)): #slicing to the center, inner loop, python style for i in range(j, len(a) - j):
#find the min index and swap if a[i] < a[j]: swap(j, i) #find the max index and swap if a[i] > a[len(a) - j - 1]: swap(len(a) - j - 1, i) return a