ダミーのマージソートの説明
私はこのコードをオンラインで見つけました：
def merge(left, right):
result = []
i ,j = 0, 0
while i < len(left) and j < len(right):
if left[i] <= right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result += left[i:]
result += right[j:]
return result
def mergesort(list):
if len(list) < 2:
return list
middle = len(list) / 2
left = mergesort(list[:middle])
right = mergesort(list[middle:])
return merge(left, right)
実行すると100％動作します。マージソートがどのように機能するのか、または再帰関数が左と右の両方を適切に順序付けることができるのか、実際にはわかりません。
マージソートを理解するための鍵は、次の原則を理解することだと思います。これをマージ原則と呼びます。
最小から最大の順に並べられた2つの別々のリストAとBが与えられた場合、Aの最小値とBの最小値を繰り返し比較し、小さい値を削除してCに追加することにより、リストCを作成します。1つのリストがなくなったら、追加します。他のリストの残りのアイテムを順番にCに追加します。その場合、リストCはソートされたリストでもあります。
これを手作業で数回行うと、正しいことがわかります。例えば：
A = 1, 3
B = 2, 4
C =
min(min(A), min(B)) = 1
A = 3
B = 2, 4
C = 1
min(min(A), min(B)) = 2
A = 3
B = 4
C = 1, 2
min(min(A), min(B)) = 3
A =
B = 4
C = 1, 2, 3
これでAが使い果たされたので、Bの残りの値でCを拡張します。
C = 1, 2, 3, 4
マージの原則も簡単に証明できます。 Aの最小値はAの他のすべての値よりも小さく、Bの最小値はBの他のすべての値よりも小さいです。Aの最小値がBの最小値よりも小さい場合は、それも小さくなければなりません。 Bのすべての値よりも小さい。したがって、Aのすべての値およびBのすべての値よりも小さい。
これらの条件を満たす値をCに追加し続ける限り、ソートされたリストが得られます。これは、上記のmerge関数が行うことです。
さて、この原則を考えると、リストを小さなリストに分割し、それらのリストをソートしてから、それらのソートされたリストをマージすることによってリストをソートするソート手法を理解するのは非常に簡単です。 merge_sort関数は、リストを半分に分割し、それら2つのリストを並べ替えてから、上記の方法でこれら2つのリストをマージする関数です。
唯一の落とし穴は、再帰的であるため、2つのサブリストを並べ替えるときに、それらをそれ自体に渡すことによって並べ替えることです。ここで再帰を理解するのが難しい場合は、最初に簡単な問題を調べることをお勧めします。しかし、再帰の基本をすでに理解している場合は、1項目のリストがすでにソートされていることを理解する必要があります。 2つの1項目リストをマージすると、ソートされた2項目リストが生成されます。 2つの2項目リストをマージすると、ソートされた4項目リストが生成されます。等々。
アルゴリズムがどのように機能するかを理解するのが難しい場合は、デバッグ出力を追加して、アルゴリズム内で実際に何が起こっているかを確認します。
ここにデバッグ出力のあるコードがあります。 mergesortの再帰呼び出しを使用してすべてのステップを理解し、mergeが出力で何をするかを理解してください。
def merge(left, right):
result = []
i ,j = 0, 0
while i < len(left) and j < len(right):
print('left[i]: {} right[j]: {}'.format(left[i],right[j]))
if left[i] <= right[j]:
print('Appending {} to the result'.format(left[i]))
result.append(left[i])
print('result now is {}'.format(result))
i += 1
print('i now is {}'.format(i))
else:
print('Appending {} to the result'.format(right[j]))
result.append(right[j])
print('result now is {}'.format(result))
j += 1
print('j now is {}'.format(j))
print('One of the list is exhausted. Adding the rest of one of the lists.')
result += left[i:]
result += right[j:]
print('result now is {}'.format(result))
return result
def mergesort(L):
print('---')
print('mergesort on {}'.format(L))
if len(L) < 2:
print('length is 1: returning the list withouth changing')
return L
middle = len(L) / 2
print('calling mergesort on {}'.format(L[:middle]))
left = mergesort(L[:middle])
print('calling mergesort on {}'.format(L[middle:]))
right = mergesort(L[middle:])
print('Merging left: {} and right: {}'.format(left,right))
out = merge(left, right)
print('exiting mergesort on {}'.format(L))
print('#---')
return out
mergesort([6,5,4,3,2,1])
出力：
---
mergesort on [6, 5, 4, 3, 2, 1]
calling mergesort on [6, 5, 4]
---
mergesort on [6, 5, 4]
calling mergesort on [6]
---
mergesort on [6]
length is 1: returning the list withouth changing
calling mergesort on [5, 4]
---
mergesort on [5, 4]
calling mergesort on [5]
---
mergesort on [5]
length is 1: returning the list withouth changing
calling mergesort on [4]
---
mergesort on [4]
length is 1: returning the list withouth changing
Merging left: [5] and right: [4]
left[i]: 5 right[j]: 4
Appending 4 to the result
result now is [4]
j now is 1
One of the list is exhausted. Adding the rest of one of the lists.
result now is [4, 5]
exiting mergesort on [5, 4]
#---
Merging left: [6] and right: [4, 5]
left[i]: 6 right[j]: 4
Appending 4 to the result
result now is [4]
j now is 1
left[i]: 6 right[j]: 5
Appending 5 to the result
result now is [4, 5]
j now is 2
One of the list is exhausted. Adding the rest of one of the lists.
result now is [4, 5, 6]
exiting mergesort on [6, 5, 4]
#---
calling mergesort on [3, 2, 1]
---
mergesort on [3, 2, 1]
calling mergesort on [3]
---
mergesort on [3]
length is 1: returning the list withouth changing
calling mergesort on [2, 1]
---
mergesort on [2, 1]
calling mergesort on [2]
---
mergesort on [2]
length is 1: returning the list withouth changing
calling mergesort on [1]
---
mergesort on [1]
length is 1: returning the list withouth changing
Merging left: [2] and right: [1]
left[i]: 2 right[j]: 1
Appending 1 to the result
result now is [1]
j now is 1
One of the list is exhausted. Adding the rest of one of the lists.
result now is [1, 2]
exiting mergesort on [2, 1]
#---
Merging left: [3] and right: [1, 2]
left[i]: 3 right[j]: 1
Appending 1 to the result
result now is [1]
j now is 1
left[i]: 3 right[j]: 2
Appending 2 to the result
result now is [1, 2]
j now is 2
One of the list is exhausted. Adding the rest of one of the lists.
result now is [1, 2, 3]
exiting mergesort on [3, 2, 1]
#---
Merging left: [4, 5, 6] and right: [1, 2, 3]
left[i]: 4 right[j]: 1
Appending 1 to the result
result now is [1]
j now is 1
left[i]: 4 right[j]: 2
Appending 2 to the result
result now is [1, 2]
j now is 2
left[i]: 4 right[j]: 3
Appending 3 to the result
result now is [1, 2, 3]
j now is 3
One of the list is exhausted. Adding the rest of one of the lists.
result now is [1, 2, 3, 4, 5, 6]
exiting mergesort on [6, 5, 4, 3, 2, 1]
#---
マージソートは常に私のお気に入りのアルゴリズムの1つです。
短いソート済みシーケンスから始めて、それらを順番に、より大きなソート済みシーケンスにマージし続けます。とても簡単。
再帰的な部分は、逆方向に作業していることを意味します-シーケンス全体から始めて、2つの半分をソートします。シーケンスに要素が0個または1個しかないときにソートが簡単になるまで、各半分も分割されます。再帰関数が返されると、最初の説明で述べたように、ソートされたシーケンスは大きくなります。
これを理解するのに役立ついくつかの方法：
デバッガーでコードをステップ実行し、何が起こるかを観察します。または、紙の上でそれをステップスルーし（非常に小さな例で）、何が起こるかを観察します。
（個人的には、この種のことを紙で行う方が有益だと思います）
概念的には、次のように機能します。入力リストは、半分にされることで、ますます小さな断片に切り刻まれ続けます（例：list[:middle]は前半です）。それぞれの半分は、長さが2未満になるまで、何度も何度も半分になります。それがまったくなくなるか、単一の要素になるまで。次に、これらの個々の部分は、2つのサブリストをresultリストに追加またはインターリーブすることにより、マージルーチンによって元に戻されます。したがって、ソートされたリストが得られます。 2つのサブリストをソートする必要があるため、追加/インターリーブは高速（O（n））操作です。
これの鍵は（私の見解では）マージルーチンではありません。これは、入力が常にソートされることを理解すれば、かなり明白です。 「トリック」（トリックではないので引用符を使用します。コンピュータサイエンスです:-)）は、マージする入力がソートされることを保証するために、リストに到達するまで再帰し続ける必要があるということですmustを並べ替える必要があります。そのため、リストの長さが2要素未満になるまで、mergesortを再帰的に呼び出し続けます。
再帰、ひいてはマージソートは、最初にそれらに遭遇したときに自明ではない場合があります。優れたアルゴリズムの本を参照することをお勧めします（例： [〜＃〜] dpv [〜＃〜] オンラインで合法的に無料で入手できます）が、あなたが持っているコード。あなたが本当にそれに参加したいのであれば、スタンフォード/コースセラ アルゴリズムコース はすぐに再び実行され、彼はマージソートを詳細にカバーしています。
本当にそれを理解したい場合は、その本のリファレンスの第2章を読んでから、上記のコードを破棄して、最初から書き直してください。真剣に。
写真は千の言葉の価値があり、アニメーションは10,000の価値があります。
Wikipedia から取得した次のアニメーションを確認してください。これは、マージソートアルゴリズムが実際にどのように機能するかを視覚化するのに役立ちます。
詳細 説明付きのアニメーション 好奇心旺盛なものの並べ替えプロセスの各ステップ。
別の興味深いアニメーションさまざまなタイプのソートアルゴリズム。
ここで、マージソートがどのように機能するかを視覚化できます。
http://www.ee.ryerson.ca/~courses/coe428/sorting/mergesort.html
お役に立てば幸いです。
Wikipedia の記事で説明されているように、マージソートを実行するための多くの貴重な方法があります。マージを実行する方法は、マージするもののコレクションにも依存します。特定のコレクションは、コレクションが自由に使用できる特定のツールを有効にします。
書くことができないという理由だけで、Pythonを使用してこの質問に答えるつもりはありません。ただし、「マージソート」アルゴリズムに参加することは、全体として、実際に問題の中心にあるように思われます。私を助けてくれたリソースは、コンテンツの作者という理由だけで、アルゴリズム（教授によって書かれた）に関するKITEのかなり時代遅れの ウェブページ です。 ）eliminatesコンテキストに意味のある識別子。
私の答えはこのリソースから導き出されています。
マージソートアルゴリズムは、提供されたコレクションを分解してから、個々のピースを再びまとめ、コレクションが再構築されるときにピースを相互に比較することで機能することを忘れないでください。
ここに「コード」があります（Java "fiddle"）を最後まで探してください）：
public class MergeSort {
/**
* @param a the array to divide
* @param low the low INDEX of the array
* @param high the high INDEX of the array
*/
public void divide (int[] a, int low, int high, String hilo) {
/* The if statement, here, determines whether the array has at least two elements (more than one element). The
* "low" and "high" variables are derived from the bounds of the array "a". So, at the first call, this if
* statement will evaluate to true; however, as we continue to divide the array and derive our bounds from the
* continually divided array, our bounds will become smaller until we can no longer divide our array (the array
* has one element). At this point, the "low" (beginning) and "high" (end) will be the same. And further calls
* to the method will immediately return.
*
* Upon return of control, the call stack is traversed, upward, and the subsequent calls to merge are made as each
* merge-eligible call to divide() resolves
*/
if (low < high) {
String source = hilo;
// We now know that we can further divide our array into two equal parts, so we continue to prepare for the division
// of the array. REMEMBER, as we progress in the divide function, we are dealing with indexes (positions)
/* Though the next statement is simple arithmetic, understanding the logic of the statement is integral. Remember,
* at this juncture, we know that the array has more than one element; therefore, we want to find the middle of the
* array so that we can continue to "divide and conquer" the remaining elements. When two elements are left, the
* result of the evaluation will be "1". And the element in the first position [0] will be taken as one array and the
* element at the remaining position [1] will be taken as another, separate array.
*/
int middle = (low + high) / 2;
divide(a, low, middle, "low");
divide(a, middle + 1, high, "high");
/* Remember, this is only called by those recursive iterations where the if statement evaluated to true.
* The call to merge() is only resolved after program control has been handed back to the calling method.
*/
merge(a, low, middle, high, source);
}
}
public void merge (int a[], int low, int middle, int high, String source) {
// Merge, here, is not driven by tiny, "instantiated" sub-arrays. Rather, merge is driven by the indexes of the
// values in the starting array, itself. Remember, we are organizing the array, itself, and are (obviously
// using the values contained within it. These indexes, as you will see, are all we need to complete the sort.
/* Using the respective indexes, we figure out how many elements are contained in each half. In this
* implementation, we will always have a half as the only way that merge can be called is if two
* or more elements of the array are in question. We also create to "temporary" arrays for the
* storage of the larger array's elements so we can "play" with them and not propogate our
* changes until we are done.
*/
int first_half_element_no = middle - low + 1;
int second_half_element_no = high - middle;
int[] first_half = new int[first_half_element_no];
int[] second_half = new int[second_half_element_no];
// Here, we extract the elements.
for (int i = 0; i < first_half_element_no; i++) {
first_half[i] = a[low + i];
}
for (int i = 0; i < second_half_element_no; i++) {
second_half[i] = a[middle + i + 1]; // extract the elements from a
}
int current_first_half_index = 0;
int current_second_half_index = 0;
int k = low;
while (current_first_half_index < first_half_element_no || current_second_half_index < second_half_element_no) {
if (current_first_half_index >= first_half_element_no) {
a[k++] = second_half[current_second_half_index++];
continue;
}
if (current_second_half_index >= second_half_element_no) {
a[k++] = first_half[current_first_half_index++];
continue;
}
if (first_half[current_first_half_index] < second_half[current_second_half_index]) {
a[k++] = first_half[current_first_half_index++];
} else {
a[k++] = second_half[current_second_half_index++];
}
}
}
また、役立つ情報を印刷し、上記で起こっていることをより視覚的に表現するバージョン here もあります。それが役立つ場合は、構文の強調表示も優れています。
基本的に、リストを取得し、それを分割してから並べ替えますが、このメソッドを再帰的に適用するため、リストを再度分割することになります。簡単に並べ替えることができる簡単なセットができるまで、すべての単純なソリューションをマージします。完全にソートされた配列を取得します。