버블 정렬 숙제

수업에서 우리는 정렬 알고리즘을하고 있는데, 그것들에 대해 이야기하고 의사 코드를 작성할 때 잘 알고 있지만 실제 코드를 작성하는 데 문제가 있습니다.

이것은 파이썬에서 시도한 것입니다.

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)

이제, (내가 알 수있는 한) 올바르게 정렬되지만 일단 완료되면 무한정 반복됩니다.

이 코드를 어떻게 수정하여 함수가 올바르게 완료되고 (합리적인) 크기 목록을 올바르게 정렬합니까?

추신 : 나는 함수에서 실제로 인쇄를해서는 안되며 리턴을해야한다는 것을 알고 있지만 코드가 실제로 작동하지 않기 때문에 아직 그렇게하지 않았습니다.

스크립트가 현재 작동하지 않는 이유를 설명하기 위해, 나는 변수의 이름을 바꿀 수 있습니다 unsorted로 sorted.

처음에는 목록이 아직 정렬되지 않았습니다. 물론로 설정 sorted했습니다 False.

while루프를 시작하자마자 목록이 이미 정렬되어 있다고 가정합니다. 아이디어는 이것입니다. 올바른 순서가 아닌 두 가지 요소를 찾으면 sorted다시로 설정 합니다 False. 잘못된 순서로 요소가없는 경우에만sorted 유지 True 됩니다 .

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"index" 와 같은 임시 변수 이름 만 사용하십시오 .

  for i in range(0, length):

• 이 range명령은 하나의 인수 ( stop) 만 사용할 수도 있습니다 . 이 경우 0에서 해당 인수까지의 모든 정수 목록이 표시됩니다.

  for i in range(length):

• 파이썬 스타일 가이드는 변수가 밑줄과 소문자로 명명하는 것이 좋습니다. 이것은 다음과 같은 작은 스크립트에 대한 아주 작은 nitpick입니다. 파이썬 코드와 가장 유사한 것에 익숙해지는 것이 더 좋습니다.

  def bubble(bad_list):

• 두 변수의 값을 바꾸려면 튜플 할당으로 작성하십시오. 오른쪽은 튜플로 평가 된 다음 (예 : (badList[i+1], badList[i])is (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:
    ...

반면에 알고리즘의 논리는 약간 벗어났습니다. for 루프 중에 두 요소가 서로 바뀌 었는지 확인해야합니다. 내가 쓰는 방법은 다음과 같습니다.

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

정렬되지 않은 변수 사용이 잘못되었습니다. 두 요소를 교체했는지 여부를 알려주는 변수가 필요합니다. 그렇게 한 경우 루프를 종료 할 수 있습니다. 그렇지 않으면 다시 루프해야합니다. 여기있는 것을 고치려면 if 케이스 본문에 "unsorted = false"를 넣으십시오. else 케이스를 제거하십시오. for루프 앞에 "unsorted = true"를 입력하십시오 .

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

# 두 번째 어레이의 문제 공간을 줄임으로써 매우 간단한 기능을 최적화 할 수 있습니다. 그러나 동일한 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

나는 신선하고 신선한 초보자이며 어제 파이썬에 대해 읽기 시작했습니다. 당신의 예에서 영감을 얻어 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에서 a까지의 요소 (기본적으로 해당 라운드의 정렬되지 않은 모든 요소)를 가져 와서 인접한 요소와 비교하고 인접한 요소보다 큰 경우 스왑을 만듭니다. 라운드가 끝나면 마지막 요소가 정렬되고 모든 요소가 정렬 될 때까지 프로세스가 다시 실행됩니다.

sort참이든 아니든 조건이 필요 하지 않습니다.

이 알고리즘은 교환 할 때만 숫자의 위치를 ​​고려하므로 반복되는 숫자는 영향을 미치지 않습니다.

추신. 이 질문이 게시 된 지 매우 오래 걸렸지 만이 아이디어를 공유하고 싶었습니다.

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)

9 년 후 도움이 될 경우 idk ... 간단한 버블 정렬 프로그램

    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