การบ้านเรียงฟอง

ในชั้นเรียนเรากำลังทำอัลกอริทึมการเรียงลำดับและแม้ว่าฉันจะเข้าใจดีเมื่อพูดถึงพวกเขาและเขียนรหัสเทียม แต่ฉันก็มีปัญหาในการเขียนโค้ดจริงสำหรับพวกเขา

นี่คือความพยายามของฉันใน 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)

ตอนนี้สิ่งนี้ (เท่าที่ฉันบอกได้) เรียงลำดับอย่างถูกต้อง แต่เมื่อเสร็จสิ้นมันก็วนซ้ำไปเรื่อย ๆ

รหัสนี้จะแก้ไขได้อย่างไรเพื่อให้ฟังก์ชันเสร็จสิ้นอย่างถูกต้องและจัดเรียงรายการขนาดใด ๆ (ที่เหมาะสม) ได้อย่างถูกต้อง?

ป.ล. ฉันรู้ว่าฉันไม่ควรพิมพ์ในฟังก์ชันจริงๆและฉันควรจะได้รับคืน แต่ฉันยังไม่ได้ทำเช่นนั้นเนื่องจากรหัสของฉันยังใช้งานไม่ได้จริงๆ

เพื่ออธิบายว่าทำไมสคริปต์ของคุณทำงานไม่ถูกต้องตอนนี้ฉันจะเปลี่ยนชื่อตัวแปรที่จะunsortedsorted

ในตอนแรกรายการของคุณยังไม่ได้รับการจัดเรียง แน่นอนเราตั้งไปsortedFalse

ทันทีที่เราเริ่มwhileลูปเราจะถือว่ารายการถูกจัดเรียงเรียบร้อยแล้ว ความคิดอย่างนี้ทันทีที่เราได้พบกับสององค์ประกอบที่ไม่ได้อยู่ในลำดับที่ถูกต้องเราตั้งกลับไปsorted จะยังคงอยู่เฉพาะในกรณีที่มีองค์ประกอบในลำดับที่ผิดFalsesortedTrue

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.

นอกจากนี้ยังมีปัญหาเล็กน้อยเล็กน้อยที่จะช่วยให้โค้ดมีประสิทธิภาพหรืออ่านง่ายขึ้น

• ในห่วงคุณใช้ตัวแปรfor elementในทางเทคนิคelementไม่ใช่องค์ประกอบ เป็นตัวเลขที่แสดงดัชนีรายการ นอกจากนี้มันค่อนข้างยาว ในกรณีเหล่านี้ให้ใช้ชื่อตัวแปรชั่วคราวเช่นiสำหรับ "ดัชนี"

  for i in range(0, length):

• rangeคำสั่งนอกจากนี้ยังสามารถใช้เวลาเพียงหนึ่งอาร์กิวเมนต์ (ชื่อstop) ในกรณีนี้คุณจะได้รับรายการจำนวนเต็มทั้งหมดจาก 0 ถึงอาร์กิวเมนต์นั้น

  for i in range(length):

• คู่มือสไตล์หลามแนะนำว่าตัวแปรที่มีชื่ออยู่ในตัวพิมพ์เล็กด้วยขีด นี่เป็น nitpick เล็กน้อยสำหรับสคริปต์เล็ก ๆ เช่นนี้ มันเป็นมากกว่าที่จะทำให้คุณคุ้นเคยกับสิ่งที่โค้ด Python ส่วนใหญ่มักจะมีลักษณะ

  def bubble(bad_list):

• หากต้องการสลับค่าของตัวแปรสองตัวให้เขียนเป็นการกำหนดค่าทูเพิล ทางขวามือจะได้รับการประเมินเป็นทูเปิล (พูด(badList[i+1], badList[i])คือ(3, 5)) จากนั้นจะกำหนดให้กับตัวแปรสองตัวทางด้านซ้ายมือ ( (badList[i], badList[i+1]))

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

รวมทั้งหมดเข้าด้วยกันและคุณจะได้รับสิ่งนี้:

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

(ฉันลบคำสั่งพิมพ์ของคุณด้วย)

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

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

เวอร์ชัน 1 ของคุณได้รับการแก้ไข:

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

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

sorted = False
while not sorted:
    ...

ในทางกลับกันตรรกะของอัลกอริทึมนั้นผิดไปเล็กน้อย คุณต้องตรวจสอบว่ามีการสลับสององค์ประกอบระหว่างสำหรับลูปหรือไม่ นี่คือวิธีที่ฉันจะเขียน:

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

การใช้ตัวแปร Unsorted ของคุณไม่ถูกต้อง คุณต้องการมีตัวแปรที่บอกคุณว่าคุณได้สลับสององค์ประกอบหรือไม่ หากคุณทำเสร็จแล้วคุณสามารถออกจากลูปของคุณมิฉะนั้นคุณจะต้องวนซ้ำอีกครั้ง หากต้องการแก้ไขสิ่งที่คุณมีอยู่ที่นี่เพียงใส่ "unsorted = false" ในเนื้อหาของ if case ของคุณ ลบกรณีอื่นของคุณ และใส่ "unsorted = true ก่อนforลูปของคุณ

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

# ฟังก์ชั่นที่ง่ายมากสามารถปรับให้เหมาะสม (ชัด) โดยการลดพื้นที่ปัญหาของอาร์เรย์ที่ 2 แต่มีความซับซ้อน 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 

คุณมีข้อผิดพลาดสองสามข้อในนั้น อันแรกมีความยาวและอันที่สองอยู่ในการใช้งานแบบไม่เรียงลำดับ (ตามที่ระบุโดย McWafflestix) คุณอาจต้องการส่งคืนรายการหากคุณกำลังจะพิมพ์:

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: คุณพูดถูกข้างบนนี้เป็นรถที่เป็นนรก ฉันไม่ดีที่ไม่ได้ทดสอบผ่านตัวอย่างเพิ่มเติม

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

ฉันเป็นมือใหม่เพิ่งเริ่มอ่านเรื่อง Python เมื่อวานนี้ แรงบันดาลใจจากตัวอย่างของคุณฉันได้สร้างบางสิ่งที่อาจจะมากกว่านี้ในสไตล์ 80-ties แต่อย่างไรก็ตามมันก็ใช้ได้

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)

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

ฉันทำให้รหัสง่ายขึ้นและตอนนี้มันจะใช้งานได้กับรายการตัวเลขใด ๆ โดยไม่คำนึงถึงรายการและแม้ว่าจะมีตัวเลขที่ซ้ำกันก็ตาม นี่คือรหัส

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]

พิมพ์ 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

ตัวอย่างที่ง่ายกว่า:

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

สิ่งนี้จะนำองค์ประกอบจาก 0 ไปเป็น (โดยทั่วไปคือองค์ประกอบที่ไม่ได้เรียงลำดับทั้งหมดในรอบนั้น) และเปรียบเทียบกับองค์ประกอบที่อยู่ติดกันและทำการสลับหากมีค่ามากกว่าองค์ประกอบที่อยู่ติดกัน ในตอนท้ายของรอบองค์ประกอบสุดท้ายจะถูกจัดเรียงและกระบวนการจะทำงานอีกครั้งโดยไม่มีองค์ประกอบนั้นจนกว่าจะเรียงลำดับองค์ประกอบทั้งหมด

ไม่จำเป็นต้องมีเงื่อนไขว่าsortเป็นจริงหรือไม่

โปรดทราบว่าอัลกอริทึมนี้คำนึงถึงตำแหน่งของตัวเลขเมื่อทำการแลกเปลี่ยนเท่านั้นดังนั้นตัวเลขที่ซ้ำกันจะไม่ส่งผลต่อตัวเลขดังกล่าว

PS ฉันรู้ว่ามันนานมากแล้วที่คำถามนี้ถูกโพสต์ แต่ฉันแค่อยากจะแบ่งปันความคิดนี้

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]))

ฉันพิจารณาเพิ่มโซลูชันของฉันเพราะเคยมีทางออกที่นี่

1. เวลาที่มากขึ้น
2. ความซับซ้อนของพื้นที่มากขึ้น
3. หรือดำเนินการมากเกินไป

ก็ควรจะเป็น

ดังนั้นนี่คือทางออกของฉัน:

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

หากใครสนใจในการนำไปใช้งานที่สั้นกว่าโดยใช้การทำความเข้าใจรายการ:

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]

นี่คือรูปแบบต่างๆของการจัดเรียงฟองโดยไม่มีการforวนซ้ำ โดยทั่วไปคุณกำลังพิจารณาค่าlastIndexของarrayและช้าๆdecrementingจนกระทั่งดัชนีแรกของอาร์เรย์

algorithmจะยังคงเดินผ่านแถวเช่นนี้จนกว่าจะผ่านทั้งหมดจะทำโดยไม่ต้องใด ๆswapsที่เกิดขึ้น

ฟองสบู่มีการจัดเรียงโดยทั่วไปQuadratic Time: O(n²)เมื่อพูดถึงประสิทธิภาพ

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())

คำตอบที่ได้รับจาก the-fury และ Martin Cote ได้แก้ไขปัญหาของลูปที่ไม่มีที่สิ้นสุด แต่รหัสของฉันจะยังทำงานไม่ถูกต้อง (สำหรับรายการที่ใหญ่กว่าจะเรียงลำดับไม่ถูกต้อง) ฉันลงเอยด้วยการทิ้งunsortedตัวแปรและใช้ตัวนับแทน

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)

หากใครสามารถให้คำแนะนำเกี่ยวกับวิธีการปรับปรุงโค้ดของฉันในความคิดเห็นได้จะได้รับการชื่นชมมาก

ลองทำตามนี้

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 ถ้าสิ่งนี้อาจช่วยคุณได้หลังจาก 9 ปี ... มันเป็นโปรแกรมจัดเรียงฟองอย่างง่าย

    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