blocks|key|2076117|text|我想有几个问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2076118|首先，当你做sourcei:时，我相信会返回一个新的请求的子元素数组，而不是原始数组的一部分，因此如果你修改了它，你就不会修改原始数组。第二，你从索引中减去了1，而你不应该这样做。|2076119|source+=+[4,2,1,10,5,3,100]
for+i+in+range(len(source)):
++++mini+=+min(source[i:])+#find+minimum+element
++++min_index+=+source[i:].index(mini)+#find+index+of+minimum+element
++++source[i+%2B+min_index]+=+source[i]+#replace+element+at+min_index+with+first+element
++++source[i]+=+mini++++++++++++++++++#replace+first+element+with+min+element
print+source|code-block|syntax|javascript|2076120|这提供了：|2076121|[1,+2,+3,+4,+5,+10,+100]|2076122|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I think there were a couple issues.

First, when your do source[i:], I believe that returns a new array of the sub-elements requested and not part of the original array, thus if you modify it, your don't modify the original. Second, you were subtracting 1 from an index when you shouldn't.

<pre><code>source = [4,2,1,10,5,3,100]
for i in range(len(source)):
 mini = min(source[i:]) #find minimum element
 min_index = source[i:].index(mini) #find index of minimum element
 source[i + min_index] = source[i] #replace element at min_index with first element
 source[i] = mini #replace first element with min element
print source
</code></pre>

This gives:

<pre><code>[1, 2, 3, 4, 5, 10, 100]
</code></pre>

blocks|key|5428640|text|这就是我如何重写你的代码。当然，在Python语言中，我只会使用list.sort()对列表进行排序，但在Python语言中，这是一种选择排序。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5428641|我们创建了一个生成器表达式，它返回值的(value,+i)元组及其列表中的索引。然后，当min()求值为查找minimum时，它将查找最低的元组值；由于该值在元组中排在索引之前，因此该值将是最重要的部分，而min()将查找最低的值。(如果存在平局，min()将使用元组的第二部分，即索引，作为平局的决定者。但对于排序，我们并不关心关系是如何被打破的。)|5428642|现在，我们不再搜索子列表来查找最小值，然后再次搜索它来确定索引，而是搜索一次，得到最小值和索引。|5428643|但我们实际上并不关心最小值；我们关心的是索引。因此，在min()完成后，我们只需丢弃实际值，但保留索引。将索引调整为在整个列表中正确(而不是在列表的片段中)，然后我们就可以交换了。|5428644|我们使用标准的Python惯用法来交换两个值。Python将构建一个元组对象作为中间层，然后将该元组解压到左侧。|5428645|lst+=+[4,2,1,10,5,3,100]

for+i_sortpos+in+range(len(lst)):
++++#+Make+a+generator+expression+to+return+(value,+i)+pairs.
++++genexp+=+((n,+i)+for+i,+n+in+enumerate(lst[i_sortpos:]))
++++#+Use+genexp+with+min()+to+find+lowest+and+its+index.
++++#+(Use+'_'+for+variable+name+for+the+actual+value;+we+don't+use+it.)
++++_,+i_min+=+min(genexp)
++++#+Adjust+index+to+be+correct+in+full+list.
++++i_min+%2B=+i_sortpos
++++#+Swap+the+number+at+i_sortpos+with+the+lowest+found.
++++lst[i_sortpos],+lst[i_min]+=+lst[i_min],+lst[i_sortpos]

print(lst)|code-block|syntax|javascript|5428646|编辑:这是对上面内容的改进。列表中的片段实际上分配了一个新的列表；我们的代码不需要新的列表，它只需要一种方便的方法来检查子列表。itertools模块提供了一个函数islice()，该函数返回迭代列表片段的迭代器。这避免了在我们检查每个子列表时重复创建和销毁列表。|5428647|我相信这是在Python中进行选择排序的最有效的方法。(您可以去掉将生成器表达式绑定到名称genexp的部分，并节省几微秒的时间……只需让对min()的调用成为一个很长的一行代码。但失去可读性是不值得的。)|5428648|import+itertools+as+it

lst+=+[4,2,1,10,5,3,100]

for+i_sortpos+in+range(len(lst)):
++++#+Make+a+generator+expression+to+return+(value,+i)+pairs.
++++#+Use+it.islice()+for+to+look+at+sublist.
++++genexp+=+((n,+i)+for+i,+n+in+enumerate(it.islice(lst,+i_sortpos,+len(lst))))
++++#+Use+genexp+with+min()+to+find+lowest+and+its+index.
++++#+(Use+'_'+for+variable+name+for+the+actual+value;+we+don't+use+it.)
++++_,+i_min+=+min(genexp)
++++#+Adjust+index+to+be+correct+in+full+list.
++++i_min+%2B=+i_sortpos
++++#+Swap+the+number+at+i_sortpos+with+the+lowest+found.
++++lst[i_sortpos],+lst[i_min]+=+lst[i_min],+lst[i_sortpos]

print(lst)|5428649|entityMap^0|W|B|0|J|A|18|5|2V|5|3G|5|0|0|R|5|0|0|0|1S|9|2A|8|0|19|6|1Y|5|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1C|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|1D|8|@$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|L|3|M|5|6|7|1G|8|@]|D|@]|E|$]]|$1|N|3|O|5|P|7|1H|8|@]|D|@]|E|$Q|R]]|$1|S|3|T|5|6|7|1I|8|@$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|1N|8|@$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|C]]|D|@]|E|$]]|$1|W|3|X|5|P|7|1S|8|@]|D|@]|E|$Q|R]]|$1|Y|3|-4|5|6|7|1T|8|@]|D|@]|E|$]]]|Z|$]]

Here is how I would rewrite your code. Of course in Python I would just use <code>list.sort()</code> to sort a list, but here is a selection sort in Python.

We make a generator expression that returns tuples of <code>(value, i)</code> for a value and its index from the list. Then when <code>min()</code> evaluates to find minimum, it finds the lowest tuple value; since the value comes first in the tuple before the index, the value will be the important part, and <code>min()</code> will find the lowest value. (If there is a tie, <code>min()</code> will use the second part of the tuple, the index, as a tie-breaker. But for sort we don't care how ties are broken.)

Now, instead of searching through the sub-list to find the min value, and then searching through it again to figure out the index, we search through it once and get both min value and index.

But we don't actually care about the min value; we care about the index. So after <code>min()</code> is done, we just throw away the actual value but keep the index. Adjust the index to be correct in the whole list (not in the slice of the list) and then we can swap.

We use the standard Python idiom for swapping two values. Python will build a tuple object to be the intermediate, then unpack this tuple into the left-hand-side.

<pre><code>lst = [4,2,1,10,5,3,100]

for i_sortpos in range(len(lst)):
 # Make a generator expression to return (value, i) pairs.
 genexp = ((n, i) for i, n in enumerate(lst[i_sortpos:]))
 # Use genexp with min() to find lowest and its index.
 # (Use '_' for variable name for the actual value; we don't use it.)
 _, i_min = min(genexp)
 # Adjust index to be correct in full list.
 i_min += i_sortpos
 # Swap the number at i_sortpos with the lowest found.
 lst[i_sortpos], lst[i_min] = lst[i_min], lst[i_sortpos]

print(lst)
</code></pre>

EDIT: And here is a refinement of the above. A slice from a list actually allocates a new list; our code here doesn't need a new list, it just needs a convenient way to examine a sublist. The <code>itertools</code> module offers a function, <code>islice()</code>, that returns an iterator that iterates over a slice of a list. This avoids repeatedly creating and destroying lists as we examine each sublist.

I believe this is the most efficient way to do selection sort in Python. (You could get rid of the part where we bind the generator expression to the name <code>genexp</code> and save a few microseconds... just make the call to <code>min()</code> a long one-liner. But it's not really worth the loss of readability.)

<pre><code>import itertools as it

lst = [4,2,1,10,5,3,100]

for i_sortpos in range(len(lst)):
 # Make a generator expression to return (value, i) pairs.
 # Use it.islice() for to look at sublist.
 genexp = ((n, i) for i, n in enumerate(it.islice(lst, i_sortpos, len(lst))))
 # Use genexp with min() to find lowest and its index.
 # (Use '_' for variable name for the actual value; we don't use it.)
 _, i_min = min(genexp)
 # Adjust index to be correct in full list.
 i_min += i_sortpos
 # Swap the number at i_sortpos with the lowest found.
 lst[i_sortpos], lst[i_min] = lst[i_min], lst[i_sortpos]

print(lst)
</code></pre>

blocks|key|2076157|text|def+Selection_Sort(Sarray):
++++length+=+len(Sarray)
++++i+=+0
++++j+=+0
++++for+i+in+range(length):
++++++++j+=+i%2B1
++++++++for+j+in+range(length):
++++++++++++if+Sarray[i]+<+Sarray[j]
++++++++++++++++t+=+Sarray[i]
++++++++++++++++Sarray[i]+=+Sarray[j]
++++++++++++++++Sarray[j]+=+t
++++++++j+=+j%2B1
++++++++i+=+i%2B1

++++return+Sarray|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2076158|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def Selection_Sort(Sarray):
 length = len(Sarray)
 i = 0
 j = 0
 for i in range(length):
 j = i+1
 for j in range(length):
 if Sarray[i] &lt; Sarray[j]
 t = Sarray[i]
 Sarray[i] = Sarray[j]
 Sarray[j] = t
 j = j+1
 i = i+1

 return Sarray
</code></pre>

blocks|key|2076179|text|从麻省理工学院在线课程选择排序的代码。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2076180|def+selSort(L):
++++for+i+in+range(len(L)+-+1):
++++++++minIndx+=+i
++++++++minVal+=+L[i]
++++++++j+=+i%2B1
++++++++while+j+<+len(L):
++++++++++++if+minVal+>+L[j]:
++++++++++++++++minIndx+=+j
++++++++++++++++minVal+=+L[j]
++++++++++++j+%2B=+1
++++++++if+minIndx+!=+i:
++++++++++++temp+=+L[i]
++++++++++++L[i]+=+L[minIndx]
++++++++++++L[minIndx]+=+temp|code-block|syntax|javascript|2076181|entityMap^0|G|3|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Code of select sort from MIT online course .

<pre><code>def selSort(L):
 for i in range(len(L) - 1):
 minIndx = i
 minVal = L[i]
 j = i+1
 while j &lt; len(L):
 if minVal &gt; L[j]:
 minIndx = j
 minVal = L[j]
 j += 1
 if minIndx != i:
 temp = L[i]
 L[i] = L[minIndx]
 L[minIndx] = temp
</code></pre>

blocks|key|5910952|text|def+selectSort(L):
++for+i+in+range(len(L)):
++++print+L
++++minIndex+=+i
++++minValue+=+L[i]
++++j+=+i+%2B+1
++++while+j+<+len(L):
++++++++if+minValue+>+L[j]:
++++++++++++minIndex+=+j
++++++++++++minValue+=+L[j]++
++++++++j+%2B=1
++++temp+=+L[i]
++++L[i]+=+L[minIndex]
++++L[minIndex]+=+temp|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|5910953|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def selectSort(L):
 for i in range(len(L)):
 print L
 minIndex = i
 minValue = L[i]
 j = i + 1
 while j &lt; len(L):
 if minValue &gt; L[j]:
 minIndex = j
 minValue = L[j] 
 j +=1
 temp = L[i]
 L[i] = L[minIndex]
 L[minIndex] = temp
</code></pre>

blocks|key|800356|text|def+ss(l):++++
++++for+i+in+range(0,len(l)):
++++++++d=l.index(min(l[i:]))++++++++
++++++++c=l[i]
++++++++l[i]=min(l[i:])
++++++++l[d]=c
++++++++print(l)++#it+prints+each+step+of+selection+sort
y=[10,9,1,5,0,6]
ss(y)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|800357|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def ss(l): 
 for i in range(0,len(l)):
 d=l.index(min(l[i:])) 
 c=l[i]
 l[i]=min(l[i:])
 l[d]=c
 print(l) #it prints each step of selection sort
y=[10,9,1,5,0,6]
ss(y)
</code></pre>

blocks|key|803065|text|以下是我认为对数字列表进行排序的一个好方法，我希望它能有所帮助：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|803066|list=[5,4,3,1,6,8,10,9]
listsorted=[]
for+i+in+range(len(list)):
++++x=min(list)
++++list.remove(x)
++++listsorted.append(x)
print+listsorted+|code-block|syntax|javascript|803067|结果将是1，3，4，5，6，8，9，10|803068|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

here is what I think is a good way to sort a list of numbers and I hope it helps:

<pre><code>list=[5,4,3,1,6,8,10,9]
listsorted=[]
for i in range(len(list)):
 x=min(list)
 list.remove(x)
 listsorted.append(x)
print listsorted 
</code></pre>

and the result will be [1, 3, 4, 5, 6, 8, 9, 10]

blocks|key|5910977|text|def+selSort(L):
++++"""
++++Find+the+smallest+element+in+the+list+and+put+it+(swap+it)+in+the+first+location,+
++++Find+the+second+element+and+put+it+(swap+it)+in+the+second+locaiton,+and+so+on.+

++++"""
++++for+i+in+range(len(L)+-+1):
++++++++minIndx+=+i
++++++++minVal=+L[i]
++++++++j+=+i+%2B+1
++++++++while+j+<+len(L):
++++++++++++if+minVal+>+L[j]:
++++++++++++++++minIndx+=+j
++++++++++++++++minVal=+L[j]
++++++++++++j+%2B=+1
++++++++temp+=+L[i]
++++++++L[i]+=+L[minIndx]
++++++++L[minIndx]+=+temp+
++++return+L|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|5910978|呼叫：|unstyled|5910979|print(+selSort([120,11,0,1,3,2,3,4,5,6,7,8,9,10])+)|5910980|输出|5910981|[0,+1,+2,+3,+3,+4,+5,+6,+7,+8,+9,+10,+11,+120]|5910982|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|P|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|M|3|-4|5|F|7|T|8|@]|9|@]|A|$]]]|N|$]]

<pre><code>def selSort(L):
 """
 Find the smallest element in the list and put it (swap it) in the first location, 
 Find the second element and put it (swap it) in the second locaiton, and so on. 

 """
 for i in range(len(L) - 1):
 minIndx = i
 minVal= L[i]
 j = i + 1
 while j &lt; len(L):
 if minVal &gt; L[j]:
 minIndx = j
 minVal= L[j]
 j += 1
 temp = L[i]
 L[i] = L[minIndx]
 L[minIndx] = temp 
 return L
</code></pre>

Call:

<pre><code>print( selSort([120,11,0,1,3,2,3,4,5,6,7,8,9,10]) )
</code></pre>

Output

<pre><code>[0, 1, 2, 3, 3, 4, 5, 6, 7, 8, 9, 10, 11, 120]
</code></pre>

blocks|key|800371|text|s+=+[1,8,4,9,3,6,2]
for+i+in+range(len(s)):
++++maxi+=+max(s[0:len(s)-i])+++++#find+max+element
++++tempi+=+s.index(maxi)+++++++++#+find+index+of+max+element
++++temp+=+s[len(s)-1-i]++++++++++#assign+last+element+as+temp
++++s[len(s)-1-i]+=+maxi++++++++++#put+max+element+in+last+position
++++s[tempi]+=+temp+++++++++++++++#+put+the+element+initially+at+last+in+its+new+

print+s++++|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|800372|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>s = [1,8,4,9,3,6,2]
for i in range(len(s)):
 maxi = max(s[0:len(s)-i]) #find max element
 tempi = s.index(maxi) # find index of max element
 temp = s[len(s)-1-i] #assign last element as temp
 s[len(s)-1-i] = maxi #put max element in last position
 s[tempi] = temp # put the element initially at last in its new 

print s 
</code></pre>

blocks|key|5911120|text|我认为这里的“接受”答案是没有帮助的。如果我们看一下，例如|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5911121|mini+=+min(source[i:])+#find+minimum+element
min_index+=+source[i:].index(mini)+#find+index+of+minimum+element|code-block|syntax|javascript|5911122|这不仅在创建不必要的列表切片方面效率低下，而且不必要地搜索它们。|5911123|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I think the "accepted" answer here is unhelpful. If we look at e.g.

<pre><code>mini = min(source[i:]) #find minimum element
min_index = source[i:].index(mini) #find index of minimum element
</code></pre>

not only is this inefficient in terms of creating list slices unnecessarily, but they are searched unnecessarily. It's reasonably concise but I don't think it's the best solution.

blocks|key|5428846|text|def+selectionSort(List_):
++++for+i+in+range(len(List_)):`
++++++++#track+the+current+smallest+value
++++++++smallIndex+=+i
++++++++++++#loop+from+the+current+smallest+value
++++++++++++for+j+in+range(i%2B1,len(List_))
++++++++++++++++if+List_[j]+<+List_[smallIndex]:
++++++++++++++++++++#if+new+value+is+less+that+our+smallest+value,change+
++++++++++++++++++++#smallest+value+to+this
++++++++++++++++++++smallIndex+=+j
++++++++++++if+smallIndex+!=+i:
++++++++++++++++#swap+the+values
++++++++++++++++List_[smallIndex],List_[i]+=+List_[i],List_[smallIndex]
++++#return+sorted+list
++++return+List_|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|5428847|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def selectionSort(List_):
 for i in range(len(List_)):`
 #track the current smallest value
 smallIndex = i
 #loop from the current smallest value
 for j in range(i+1,len(List_))
 if List_[j] &lt; List_[smallIndex]:
 #if new value is less that our smallest value,change 
 #smallest value to this
 smallIndex = j
 if smallIndex != i:
 #swap the values
 List_[smallIndex],List_[i] = List_[i],List_[smallIndex]
 #return sorted list
 return List_
</code></pre>

blocks|key|5911151|text|找到位置(第一个和最后一个)，如果最后一个位置较低，则交换元素。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5911152|nums+=+[4,2,1,10,5,3,100]
def+sort(nums):
+++++###Find+the+position+and+now+first+0th+element+is+sorted+and+rest+is+unsorted
++++#Second+iteration+first+2+element+is+sorted
++++for+i+in+range(len(nums)-1):
++++++++miniposition+=+i
++++++++for+j+in+range(i,len(nums)):
++++++++++++if+nums[j]+<+nums[miniposition]:
++++++++++++++++miniposition+=+j
++++++++temp+=+nums[i]
++++++++nums[i]+=+nums[miniposition]
++++++++nums[miniposition]+=+temp
sort(nums)
print+(nums)|code-block|syntax|javascript|5911153|第一次迭代(交换4和1)+[1,+2,+4,+10,+5,+3,+100]|offset|length|style|CODE|5911154|[1,+2,+4,+10,+5,+3,+100]
[1,+2,+3,+10,+5,+4,+100]
[1,+2,+3,+4,+5,+10,+100]
[1,+2,+3,+4,+5,+10,+100]
[1,+2,+3,+4,+5,+10,+100]|5911155|另一种方式|5911156|nums+=+[4,2,1,10,5,3,100]
i+=+0
while+i<len(nums):
++++#smallest+element+in+the+sublist
++++smallest+=+min(nums[i:])
++++#index+of+smallest+element
++++index_of_smallest+=+nums.index(smallest)
++++#swapping
++++nums[i],nums[index_of_smallest]+=+nums[index_of_smallest],nums[i]
++++i=i%2B1
print+(nums)|5911157|entityMap^0|0|0|D|O|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

Find the position(first and last), swap the elements if last is lower. 

<pre><code>nums = [4,2,1,10,5,3,100]
def sort(nums):
 ###Find the position and now first 0th element is sorted and rest is unsorted
 #Second iteration first 2 element is sorted
 for i in range(len(nums)-1):
 miniposition = i
 for j in range(i,len(nums)):
 if nums[j] &lt; nums[miniposition]:
 miniposition = j
 temp = nums[i]
 nums[i] = nums[miniposition]
 nums[miniposition] = temp
sort(nums)
print (nums)
</code></pre>

First iteration(swapped 4 and 1)
 <code>[1, 2, 4, 10, 5, 3, 100]</code>

<pre><code>[1, 2, 4, 10, 5, 3, 100]
[1, 2, 3, 10, 5, 4, 100]
[1, 2, 3, 4, 5, 10, 100]
[1, 2, 3, 4, 5, 10, 100]
[1, 2, 3, 4, 5, 10, 100]
</code></pre>

Other way

<pre><code>nums = [4,2,1,10,5,3,100]
i = 0
while i&lt;len(nums):
 #smallest element in the sublist
 smallest = min(nums[i:])
 #index of smallest element
 index_of_smallest = nums.index(smallest)
 #swapping
 nums[i],nums[index_of_smallest] = nums[index_of_smallest],nums[i]
 i=i+1
print (nums)
</code></pre>

blocks|key|2076456|text|提供的解决方案的细微变化|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2076457|def+selection_sort(l):
i+=+0
while+i+<+len(l):
++++minium_value+=+min(l[i:])+#+minium+value+at+ith+iteration
++++minium_value_index+=+l[i:].index(minium_value)+#+minium+value+index+at+i+th+iteration

++++if+minium_value+<+l[i]:+#+if+the+current+value+already+min,+skip
++++++++l[i+%2B+minium_value_index]+=+l[i]+#+put+current+value+in+min+value's+index+-+swap+1
++++++++l[i]+=+minium_value+#+set+current+value+with+min+value-+swap+2
++++i+%2B=+1

return+l|code-block|syntax|javascript|2076458|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

a slight variation of the solution provided
<pre><code>def selection_sort(l):
i = 0
while i &lt; len(l):
 minium_value = min(l[i:]) # minium value at ith iteration
 minium_value_index = l[i:].index(minium_value) # minium value index at i th iteration

 if minium_value &lt; l[i]: # if the current value already min, skip
 l[i + minium_value_index] = l[i] # put current value in min value's index - swap 1
 l[i] = minium_value # set current value with min value- swap 2
 i += 1

return l
</code></pre>

blocks|key|2076462|text|def+selection_sort_min()：#排序编号|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2076463|for+i+in+range(len(num)-1):
++++current_min_index+=+i
++++for+j+in+range(i%2B1,len(num)):
++++++++if++num[j]+<+num[current_min_index]+:
++++++++++++current_min_index+=+j
++++num[i],num[current_min_index]+=+num+[current_min_index],num[i]
print(num)|code-block|syntax|javascript|2076464|num+=+23,89,12,0,3,7,33|2076465|selection_sort_min()e|2076466|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

def selection_sort_min(): # sorting number
<pre><code>for i in range(len(num)-1):
 current_min_index = i
 for j in range(i+1,len(num)):
 if num[j] &lt; num[current_min_index] :
 current_min_index = j
 num[i],num[current_min_index] = num [current_min_index],num[i]
print(num)
</code></pre>
num = [23,89,12,0,3,7,33]
selection_sort_min()e

This may seem like a simple question but when I attempted to implement selection sort in Python, I do not get a sorted list. Is there something wrong with my implementation? The subsetting may be a problem. 

<pre><code>source = [4,2,1,10,5,3,100]
for i in range(len(source)):
 mini = min(source[i:]) #find minimum element
 min_index = source[i:].index(mini)-1 #find index of minimum element
 source[i:][min_index]= source[i:][0] #replace element at min_index with first element
 source[i:][0] = mini #replace first element with min element
print source
</code></pre>

Selection Sort Python

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

这看起来可能是一个简单的问题，但是当我尝试在Python中实现选择排序时，我没有得到一个排序列表。我的实现有什么问题吗？子设置可能是一个问题。source = [4,2,1,10,5,3,100]for i in range(len(source)):  mini = min(source[i:]) #find min...

问选择排序Python
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问选择排序PythonEN