N-wayマージのアルゴリズム
2-wayマージは、Mergesortアルゴリズムの一部として広く研究されています。しかし、N-wayマージを実行する最良の方法を見つけることに興味がありますか？
たとえば、それぞれ100万個の整数をソートしたNファイルがあります。それらを1つの単一のファイルにマージし、1億個のソート済み整数を持たせる必要があります。
この問題のユースケースは、実際にはディスクベースの外部ソートであることに注意してください。したがって、実際のシナリオでは、メモリの制限もあります。したがって、一度に2つのファイルをマージする（99回）単純なアプローチは機能しません。各アレイで使用できるメモリのスライディングウィンドウが小さいとしましょう。
このN方向のマージに対する標準化されたソリューションが既にあるかどうかはわかりません。 （グーグルはあまり教えてくれなかった）。
ただし、n方向のマージアルゴリズムが適切かどうかがわかっている場合は、algo/linkを投稿してください。
時間の複雑さ：マージするファイル（N）の数を大幅に増やした場合、それはアルゴリズムの時間の複雑さにどのように影響しますか？
ご回答ありがとうございます。
これはどこにも聞かれませんでしたが、これは興味深いインタビューの質問かもしれないと感じました。したがって、タグ付けされています。
次のアイデアはどうですか：
- 優先キューを作成する
- 各ファイルを反復処理しますf
- ペアをキューに入れます（nextNumberIn（f）、f）最初の値を優先キーとして使用
- ペアをキューに入れます（nextNumberIn（f）、f）最初の値を優先キーとして使用
- キューは空ではありませんが
- デキューヘッド（m、f）キューの
- 出力m
- f枯渇していない場合
- エンキュー（nextNumberIn（f）、f）
優先度キューへの要素の追加は対数時間で実行できるため、項目2はO（N×log N）です。 whileループの（ほとんどすべての）繰り返しが要素を追加するため、while-loop全体はO（M×log N） where [〜＃〜] m [〜＃〜]は、ソートする数字の総数です。
すべてのファイルに空でない数列があると仮定すると、M> Nとなり、アルゴリズム全体がO（M×log N）になります。
「多相マージ」を検索し、クラシックをチェックしてください-ドナルドクヌース＆E.H.フレンド。
また、Seyedafsari＆Hasanzadehが提案したSmart Block Mergingをご覧ください。これは、以前の提案と同様に、優先キューを使用します。
別の興味深い理由は、Kim＆Kutznerによる In-Place Merging Algorithm です。
また、Vitterによるこのペーパーをお勧めします。 外部メモリアルゴリズムとデータ構造：大量データの処理 。
単純なアイデアの1つは、マージする範囲の優先度キューを保持し、最初の要素が最小の範囲が最初にキューから削除されるように保存することです。その後、次のようにN方向のマージを実行できます。
- 空の範囲を除くすべての範囲を優先度キューに挿入します。
- 優先キューは空ではありませんが：
- キューから最小要素をデキューします。
- この範囲の最初の要素を出力シーケンスに追加します。
- 空でない場合は、シーケンスの残りを優先度キューに挿入します。
このアルゴリズムの正確さは、基本的に、双方向のマージが正しく機能することの証明の一般化です-常に任意の範囲から最小要素を追加し、すべての範囲がソートされると、全体としてソートされたシーケンスになります。
このアルゴリズムの実行時の複雑さは次のとおりです。 Mをすべてのシーケンスの要素の総数とします。バイナリヒープを使用する場合、各要素ごとに、最大でO(M)挿入およびO(M)優先キューからの削除）を行います。出力シーケンスに書き込まれる最小のシーケンスを引き出すデキューがあり、その後にキューにシーケンスの残りを戻すエンキューが続きます。これらの各ステップは、バイナリからの挿入または削除のため、O（lg N）操作を取りますN個の要素を含むヒープにはO（lg N）時間かかり、これにより、O（M lg N）の正味ランタイムが得られますが、これは入力シーケンスの数に比例して増加しません。
これをもっと速くする方法があるかもしれませんが、これはかなり良い解決策のようです。メモリ使用量はO(N)です。これは、バイナリヒープにO(N)オーバーヘッドが必要だからです。バイナリヒープを実装する場合、シーケンス自体ではなく、シーケンスは、本当にとんでもない数のシーケンスをマージする場合を除いて、あまり問題になりません。その場合は、メモリに収まるグループにマージしてから、すべての結果をマージします。
お役に立てれば！
K個のソートされた配列（長さnのそれぞれ）をマージする簡単なアプローチは、O(nk)時間ではなくO（nk ^ 2）時間を必要とします。最初の2つの配列をマージするときは2n時間かかります次に、3番目の出力とマージするとき、長さ2nとnの2つの配列をマージするため、3n時間かかります。この出力を4番目の配列とマージすると、このマージには4n時間かかります。既にソートされた配列にk番目の配列を追加する場合）k * n時間を必要とするため、必要な合計時間は2n + 3n + 4n + ... k * n（O（nk ^ 2））です。
O(kn)の時間で実行できるように見えますが、そうではありません。マージする配列のサイズが大きくなるためです。
分割と征服を使用してより良い範囲を達成できますが。私はまだそれに取り組んでおり、解決策を見つけたら投稿します。
Here is my implementation using MinHeap...
package merging;
import Java.io.BufferedReader;
import Java.io.BufferedWriter;
import Java.io.File;
import Java.io.FileReader;
import Java.io.FileWriter;
import Java.io.IOException;
import Java.io.PrintWriter;
public class N_Way_Merge {
int No_of_files=0;
String[] listString;
int[] listIndex;
PrintWriter pw;
private String fileDir = "D:\\XMLParsing_Files\\Extracted_Data";
private File[] fileList;
private BufferedReader[] readers;
public static void main(String[] args) throws IOException {
N_Way_Merge nwm=new N_Way_Merge();
long start= System.currentTimeMillis();
try {
nwm.createFileList();
nwm.createReaders();
nwm.createMinHeap();
}
finally {
nwm.pw.flush();
nwm.pw.close();
for (BufferedReader readers : nwm.readers) {
readers.close();
}
}
long end = System.currentTimeMillis();
System.out.println("Files merged into a single file.\nTime taken: "+((end-start)/1000)+"secs");
}
public void createFileList() throws IOException {
//creates a list of sorted files present in a particular directory
File folder = new File(fileDir);
fileList = folder.listFiles();
No_of_files=fileList.length;
assign();
System.out.println("No. of files - "+ No_of_files);
}
public void assign() throws IOException
{
listString = new String[No_of_files];
listIndex = new int[No_of_files];
pw = new PrintWriter(new BufferedWriter(new FileWriter("D:\\XMLParsing_Files\\Final.txt", true)));
}
public void createReaders() throws IOException {
//creates array of BufferedReaders to read the files
readers = new BufferedReader[No_of_files];
for(int i=0;i<No_of_files;++i)
{
readers[i]=new BufferedReader(new FileReader(fileList[i]));
}
}
public void createMinHeap() throws IOException {
for(int i=0;i<No_of_files;i++)
{
listString[i]=readers[i].readLine();
listIndex[i]=i;
}
WriteToFile(listString,listIndex);
}
public void WriteToFile(String[] listString,int[] listIndex) throws IOException{
BuildHeap_forFirstTime(listString, listIndex);
while(!(listString[0].equals("zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz")))
{
pw.println(listString[0]);
listString[0]=readers[listIndex[0]].readLine();
MinHeapify(listString,listIndex,0);
}
}
public void BuildHeap_forFirstTime(String[] listString,int[] listIndex){
for(int i=(No_of_files/2)-1;i>=0;--i)
MinHeapify(listString,listIndex,i);
}
public void MinHeapify(String[] listString,int[] listIndex,int index){
int left=index*2 + 1;
int right=left + 1;
int smallest=index;
int HeapSize=No_of_files;
if(left <= HeapSize-1 && listString[left]!=null && (listString[left].compareTo(listString[index])) < 0)
smallest = left;
if(right <= HeapSize-1 && listString[right]!=null && (listString[right].compareTo(listString[smallest])) < 0)
smallest=right;
if(smallest!=index)
{
String temp=listString[index];
listString[index]=listString[smallest];
listString[smallest]=temp;
listIndex[smallest]^=listIndex[index];
listIndex[index]^=listIndex[smallest];
listIndex[smallest]^=listIndex[index];
MinHeapify(listString,listIndex,smallest);
}
}
}
http://en.wikipedia.org/wiki/External_sorting を参照してください。ヒープベースのk-wayマージについて、ソースからのバッファー読み取りを使用してI/O削減をエミュレートします。
public class KWayMerger<T>
{
private readonly IList<T[]> _sources;
private readonly int _bufferSize;
private readonly MinHeap<MergeValue<T>> _mergeHeap;
private readonly int[] _indices;
public KWayMerger(IList<T[]> sources, int bufferSize, Comparer<T> comparer = null)
{
if (sources == null) throw new ArgumentNullException("sources");
_sources = sources;
_bufferSize = bufferSize;
_mergeHeap = new MinHeap<MergeValue<T>>(
new MergeComparer<T>(comparer ?? Comparer<T>.Default));
_indices = new int[sources.Count];
}
public T[] Merge()
{
for (int i = 0; i <= _sources.Count - 1; i++)
AddToMergeHeap(i);
var merged = new T[_sources.Sum(s => s.Length)];
int mergeIndex = 0;
while (_mergeHeap.Count > 0)
{
var min = _mergeHeap.ExtractDominating();
merged[mergeIndex++] = min.Value;
if (min.Source != -1) //the last item of the source was extracted
AddToMergeHeap(min.Source);
}
return merged;
}
private void AddToMergeHeap(int sourceIndex)
{
var source = _sources[sourceIndex];
var start = _indices[sourceIndex];
var end = Math.Min(start + _bufferSize - 1, source.Length - 1);
if (start > source.Length - 1)
return; //we're done with this source
for (int i = start; i <= end - 1; i++)
_mergeHeap.Add(new MergeValue<T>(-1, source[i]));
//only the last item should trigger the next buffered read
_mergeHeap.Add(new MergeValue<T>(sourceIndex, source[end]));
_indices[sourceIndex] += _bufferSize; //we may have added less items,
//but if we did we've reached the end of the source so it doesn't matter
}
}
internal class MergeValue<T>
{
public int Source { get; private set; }
public T Value { get; private set; }
public MergeValue(int source, T value)
{
Value = value;
Source = source;
}
}
internal class MergeComparer<T> : IComparer<MergeValue<T>>
{
public Comparer<T> Comparer { get; private set; }
public MergeComparer(Comparer<T> comparer)
{
if (comparer == null) throw new ArgumentNullException("comparer");
Comparer = comparer;
}
public int Compare(MergeValue<T> x, MergeValue<T> y)
{
Debug.Assert(x != null && y != null);
return Comparer.Compare(x.Value, y.Value);
}
}
MinHeap<T> 。いくつかのテスト：
[TestMethod]
public void TestKWaySort()
{
var Rand = new Random();
for (int i = 0; i < 10; i++)
AssertKwayMerge(Rand);
}
private static void AssertKwayMerge(Random Rand)
{
var sources = new[]
{
GenerateRandomCollection(Rand, 10, 30, 0, 30).OrderBy(i => i).ToArray(),
GenerateRandomCollection(Rand, 10, 30, 0, 30).OrderBy(i => i).ToArray(),
GenerateRandomCollection(Rand, 10, 30, 0, 30).OrderBy(i => i).ToArray(),
GenerateRandomCollection(Rand, 10, 30, 0, 30).OrderBy(i => i).ToArray(),
};
Assert.IsTrue(new KWayMerger<int>(sources, 20).Merge().SequenceEqual(sources.SelectMany(s => s).OrderBy(i => i)));
}
public static IEnumerable<int> GenerateRandomCollection(Random Rand, int minLength, int maxLength, int min = 0, int max = int.MaxValue)
{
return Enumerable.Repeat(0, Rand.Next(minLength, maxLength)).Select(i => Rand.Next(min, max));
}
N-wayマージを行うこのSTLスタイルのコードを書き、他の人が車輪を再発明するのを防ぐためにここに投稿すると思いました。 :)
警告：軽度のテストのみです。使用前にテストしてください。：）
次のように使用できます。
#include <vector>
int main()
{
std::vector<std::vector<int> > v;
std::vector<std::vector<int>::iterator> vout;
std::vector<int> v1;
std::vector<int> v2;
v1.Push_back(1);
v1.Push_back(2);
v1.Push_back(3);
v2.Push_back(0);
v2.Push_back(1);
v2.Push_back(2);
v.Push_back(v1);
v.Push_back(v2);
multiway_merge(v.begin(), v.end(), std::back_inserter(vout), false);
}
また、コンテナ自体の代わりにイテレータのペアを使用できます。
Boost.Rangeを使用する場合、定型コードの一部を削除できます。
コード：
#include <algorithm>
#include <functional> // std::less
#include <iterator>
#include <queue> // std::priority_queue
#include <utility> // std::pair
#include <vector>
template<class OutIt>
struct multiway_merge_value_insert_iterator : public std::iterator<
std::output_iterator_tag, OutIt, ptrdiff_t
>
{
OutIt it;
multiway_merge_value_insert_iterator(OutIt const it = OutIt())
: it(it) { }
multiway_merge_value_insert_iterator &operator++(int)
{ return *this; }
multiway_merge_value_insert_iterator &operator++()
{ return *this; }
multiway_merge_value_insert_iterator &operator *()
{ return *this; }
template<class It>
multiway_merge_value_insert_iterator &operator =(It const i)
{
*this->it = *i;
++this->it;
return *this;
}
};
template<class OutIt>
multiway_merge_value_insert_iterator<OutIt>
multiway_merge_value_inserter(OutIt const it)
{ return multiway_merge_value_insert_iterator<OutIt>(it); };
template<class Less>
struct multiway_merge_value_less : private Less
{
multiway_merge_value_less(Less const &less) : Less(less) { }
template<class It1, class It2>
bool operator()(
std::pair<It1, It1> const &b /* inverted */,
std::pair<It2, It2> const &a) const
{
return b.first != b.second && (
a.first == a.second ||
this->Less::operator()(*a.first, *b.first));
}
};
struct multiway_merge_default_less
{
template<class T>
bool operator()(T const &a, T const &b) const
{ return std::less<T>()(a, b); }
};
template<class R>
struct multiway_merge_range_iterator
{ typedef typename R::iterator type; };
template<class R>
struct multiway_merge_range_iterator<R const>
{ typedef typename R::const_iterator type; };
template<class It>
struct multiway_merge_range_iterator<std::pair<It, It> >
{ typedef It type; };
template<class R>
typename R::iterator multiway_merge_range_begin(R &r)
{ return r.begin(); }
template<class R>
typename R::iterator multiway_merge_range_end(R &r)
{ return r.end(); }
template<class R>
typename R::const_iterator multiway_merge_range_begin(R const &r)
{ return r.begin(); }
template<class R>
typename R::const_iterator multiway_merge_range_end(R const &r)
{ return r.end(); }
template<class It>
It multiway_merge_range_begin(std::pair<It, It> const &r)
{ return r.first; }
template<class It>
It multiway_merge_range_end(std::pair<It, It> const &r)
{ return r.second; }
template<class It, class OutIt, class Less, class PQ>
OutIt multiway_merge(
It begin, It const end, OutIt out, Less const &less,
PQ &pq, bool const distinct = false)
{
while (begin != end)
{
pq.Push(typename PQ::value_type(
multiway_merge_range_begin(*begin),
multiway_merge_range_end(*begin)));
++begin;
}
while (!pq.empty())
{
typename PQ::value_type top = pq.top();
pq.pop();
if (top.first != top.second)
{
while (!pq.empty() && pq.top().first == pq.top().second)
{ pq.pop(); }
if (!distinct ||
pq.empty() ||
less(*pq.top().first, *top.first) ||
less(*top.first, *pq.top().first))
{
*out = top.first;
++out;
}
++top.first;
pq.Push(top);
}
}
return out;
}
template<class It, class OutIt, class Less>
OutIt multiway_merge(
It const begin, It const end, OutIt out, Less const &less,
bool const distinct = false)
{
typedef typename multiway_merge_range_iterator<
typename std::iterator_traits<It>::value_type
>::type SubIt;
if (std::distance(begin, end) < 16)
{
typedef std::vector<std::pair<SubIt, SubIt> > Remaining;
Remaining remaining;
remaining.reserve(
static_cast<size_t>(std::distance(begin, end)));
for (It i = begin; i != end; ++i)
{
if (multiway_merge_range_begin(*i) !=
multiway_merge_range_end(*i))
{
remaining.Push_back(std::make_pair(
multiway_merge_range_begin(*i),
multiway_merge_range_end(*i)));
}
}
while (!remaining.empty())
{
typename Remaining::iterator smallest =
remaining.begin();
for (typename Remaining::iterator
i = remaining.begin();
i != remaining.end();
)
{
if (less(*i->first, *smallest->first))
{
smallest = i;
++i;
}
else if (distinct && i != smallest &&
!less(
*smallest->first,
*i->first))
{
i = remaining.erase(i);
}
else { ++i; }
}
*out = smallest->first;
++out;
++smallest->first;
if (smallest->first == smallest->second)
{ smallest = remaining.erase(smallest); }
}
return out;
}
else
{
std::priority_queue<
std::pair<SubIt, SubIt>,
std::vector<std::pair<SubIt, SubIt> >,
multiway_merge_value_less<Less>
> q((multiway_merge_value_less<Less>(less)));
return multiway_merge(begin, end, out, less, q, distinct);
}
}
template<class It, class OutIt>
OutIt multiway_merge(
It const begin, It const end, OutIt const out,
bool const distinct = false)
{
return multiway_merge(
begin, end, out,
multiway_merge_default_less(), distinct);
}
Kソートされた配列をマージするための最小ヒープアルゴリズムのJava実装：
public class MergeKSorted {
/**
* helper object to store min value of each array in a priority queue,
* the kth array and the index into kth array
*
*/
static class PQNode implements Comparable<PQNode>{
int value;
int kth = 0;
int indexKth = 0;
public PQNode(int value, int kth, int indexKth) {
this.value = value;
this.kth = kth;
this.indexKth = indexKth;
}
@Override
public int compareTo(PQNode o) {
if(o != null) {
return Integer.valueOf(value).compareTo(Integer.valueOf(o.value));
}
else return 0;
}
@Override
public String toString() {
return value+" "+kth+" "+indexKth;
}
}
public static void mergeKSorted(int[][] sortedArrays) {
int k = sortedArrays.length;
int resultCtr = 0;
int totalSize = 0;
PriorityQueue<PQNode> pq = new PriorityQueue<>();
for(int i=0; i<k; i++) {
int[] kthArray = sortedArrays[i];
totalSize+=kthArray.length;
if(kthArray.length > 0) {
PQNode temp = new PQNode(kthArray[0], i, 0);
pq.add(temp);
}
}
int[] result = new int[totalSize];
while(!pq.isEmpty()) {
PQNode temp = pq.poll();
int[] kthArray = sortedArrays[temp.kth];
result[resultCtr] = temp.value;
resultCtr++;
temp.indexKth++;
if(temp.indexKth < kthArray.length) {
temp = new PQNode(kthArray[temp.indexKth], temp.kth, temp.indexKth);
pq.add(temp);
}
}
print(result);
}
public static void print(int[] a) {
StringBuilder sb = new StringBuilder();
for(int v : a) {
sb.append(v).append(" ");
}
System.out.println(sb);
}
public static void main(String[] args) {
int[][] sortedA = {
{3,4,6,9},
{4,6,8,9,12},
{3,4,9},
{1,4,9}
};
mergeKSorted(sortedA);
}
}