重複を消去してベクターをソートする最も効率的な方法は何ですか?


274

潜在的に多くの要素を持つC ++ベクトルを取得し、重複を消去して、並べ替える必要があります。

現在、以下のコードがありますが、機能しません。

vec.erase(
      std::unique(vec.begin(), vec.end()),
      vec.end());
std::sort(vec.begin(), vec.end());

これを正しく行うにはどうすればよいですか?

さらに、最初に重複を消去する(上記のコードと同様)か、ソートを最初に実行する方が高速ですか?最初にソートを実行した場合、std::unique実行後もソートされたままになることが保証されますか?

または、これをすべて行う別の(おそらくより効率的な)方法はありますか?


3
そもそも複製を避けるために挿入前にチェックするオプションがないと思いますか?
Joe

正しい。それは理想的でしょう。
カイルライアン

29
上記のコードを修正するか、実際にそれが間違っていることを示すことをお勧めします。std :: uniqueは、範囲がすでにソートされていることを前提としています。
Matthieu M.

回答:


584

R.パテトッドガードナーに同意します。std::setここでは良い考えかもしれません。ベクトルを使用して立ち往生している場合でも、十分な重複がある場合は、ダーティな作業を行うためのセットを作成することをお勧めします。

3つのアプローチを比較してみましょう。

ベクトルを使用して、並べ替え+一意

sort( vec.begin(), vec.end() );
vec.erase( unique( vec.begin(), vec.end() ), vec.end() );

セットに変換(手動)

set<int> s;
unsigned size = vec.size();
for( unsigned i = 0; i < size; ++i ) s.insert( vec[i] );
vec.assign( s.begin(), s.end() );

セットに変換(コンストラクターを使用)

set<int> s( vec.begin(), vec.end() );
vec.assign( s.begin(), s.end() );

重複の数が変化したときのパフォーマンスは次のとおりです。

ベクトルとセットのアプローチの比較

概要:重複の数が十分に多い場合、セットに変換してからデータをベクターにダンプする方が実際には高速です。

そして、何らかの理由で、手動でセット変換を行う方が、少なくとも私が使用したおもちゃのランダムデータでは、セットコンストラクターを使用するよりも高速のようです。


61
コンストラクターアプローチが一貫して手動よりも測定可能な程度に悪いことにショックを受けています。あなたはいくつかの小さな一定のオーバーヘッドを除いて、それは手動のことだけをするでしょう。誰かがこれを説明できますか?
Ari

17
クール、グラフをありがとう。Number of Duplicatesの単位を教えてください。(つまり、「十分な大きさ」はどのくらいの大きさですか)?
カイルライアン

5
@カイル:それはかなり大きいです。このグラフには、1〜1000、100、および10の間でランダムに描画された1,000,000の整数のデータセットを使用しました。
ネイトコール、

5
あなたの結果は間違っていると思います。私のテストでは、より多くの複製された要素がより速いベクトル(比較)であり、実際には逆にスケーリングします。最適化をオンにしてコンパイルし、ランタイムチェックをオフにしましたか?私の側では、ベクトルは常により速く、重複の数に応じて最大100倍です。VS2013、cl / Ox -D_SECURE_SCL = 0。
davidnr 2014

39
X軸の説明が欠落しているようです。
BartoszKP 2016年

72

私はネイト・コールのプロファイリングをやり直し、異なる結果を得ました。私のテストケースでは、ベクトルを直接ソートする方が、セットを使用するよりも常に効率的です。を使用して、新しいより効率的なメソッドを追加しましたunordered_set

このunordered_setメソッドが機能するのは、一意化してソートする必要がある型に適切なハッシュ関数がある場合のみであることに注意してください。intの場合、これは簡単です。(標準ライブラリは、単に識別関数であるデフォルトのハッシュを提供します。)また、unordered_setはまあ、無秩序なので、最後にソートすることを忘れないでください:)

setunordered_set実装の内部を掘り下げたところ、値をチェックして実際に挿入する必要があるかどうかを判断する前に、コンストラクターがすべての要素に対して実際に新しいノードを構築していることがわかりました(少なくともVisual Studioの実装では)。

5つの方法は次のとおりです。

f1:vectorsort+ を使用するだけunique

sort( vec.begin(), vec.end() );
vec.erase( unique( vec.begin(), vec.end() ), vec.end() );

f2:変換set(コンストラクターを使用)

set<int> s( vec.begin(), vec.end() );
vec.assign( s.begin(), s.end() );

f3:(set手動で)に変換

set<int> s;
for (int i : vec)
    s.insert(i);
vec.assign( s.begin(), s.end() );

f4:変換unordered_set(コンストラクターを使用)

unordered_set<int> s( vec.begin(), vec.end() );
vec.assign( s.begin(), s.end() );
sort( vec.begin(), vec.end() );

f5:(unordered_set手動で)に変換

unordered_set<int> s;
for (int i : vec)
    s.insert(i);
vec.assign( s.begin(), s.end() );
sort( vec.begin(), vec.end() );

[1,10]、[1,1000]、および[1,100000]の範囲でランダムに選択された100,000,000整数のベクトルを使用してテストを行いました

結果(秒単位で、小さいほど良い):

range         f1       f2       f3       f4      f5
[1,10]      1.6821   7.6804   2.8232   6.2634  0.7980
[1,1000]    5.0773  13.3658   8.2235   7.6884  1.9861
[1,100000]  8.7955  32.1148  26.5485  13.3278  3.9822

4
整数の場合、基数ソートを使用できます。これはstd :: sortよりもはるかに高速です。
Changming Sun

2
簡単なヒント、使用方法sortまたはunique方法は次の#include <algorithm>
とおり

3
@ChangmingSunなぜオプティマイザがf4で失敗したように見えたのでしょうか。数値はf5とは大きく異なります。それは私には意味がありません。
サンソーン

1
@sandthorn私の回答で説明したように、実装は、入力シーケンスから各要素のノード(動的割り当てを含む)を構築します。これは、重複するすべての値に対して無駄になります。オプティマイザがそれをスキップできることを知る方法はありません。
alexk7 2018

ああ、それは私にスコット・マイヤーの話の1つを思い出させます。それは、建設の種類を遅くする可能性の性質を持つシーンリオについての話CWUK ですemplace
サンソーン2018

58

std::unique それらが隣接している場合にのみ、重複する要素を削除します。意図したとおりに機能する前に、まずベクターをソートする必要があります。

std::unique は安定していると定義されているため、ベクターは一意で実行された後もソートされます。


42

あなたがこれを何に使用しているのかわからないので、100%の確実性でこれを言うことはできませんが、通常、「並べ替えられた、一意の」コンテナと考えるとき、私はstd :: setを考えます。それはあなたのユースケースにより適しているかもしれません:

std::set<Foo> foos(vec.begin(), vec.end()); // both sorted & unique already

それ以外の場合は、(他の回答が指摘しているように)uniqueを呼び出す前にソートする方法です。


まあポイントまで!std :: setは、ソートされた一意のセットになるように指定されています。ほとんどの実装では、効率的な順序付けられたバイナリツリーなどが使用されます。
notnoop 2009年

+1セットの考えも。この回答を複製したくありませんでした
Tom

std :: setはソートされることが保証されていますか?実際にはそうなるのは理にかなっていますが、規格はそれを要求していますか?
MadCoder 2009年

1
うん、23.1.4.9を参照してください。「連想コンテナのイテレータの基本的な特性は、キーの非降順でコンテナを反復することです。非降順は、それらを構築するために使用された比較によって定義されます」
Todd Gardner

1
@MadCoder:セットがソートされた方法で実装されていることは必ずしも「意味をなさない」。ソートされていないハッシュテーブルを使用して実装されたセットもあります。実際、ほとんどの人は、利用可能な場合はハッシュテーブルの使用を好みます。ただし、C ++の命名規則では、ソートされた連想コンテナに「set」/「map」という名前が付けられているだけです(JavaのTreeSet / TreeMapに類似)。標準から取り残されたハッシュ連想コンテナは、 "hash_set" / "hash_map"(SGIのSTL)または"unordered_set" / "unordered_map"(TR1)(HashSetのとJavaでのHashMapに類似)と呼ばれる
newacct

22

std::unique重複する要素の連続した実行でのみ機能するため、最初にソートすることをお勧めします。ただし、安定しているため、ベクターはソートされたままになります。


18

これはあなたのために行うテンプレートです:

template<typename T>
void removeDuplicates(std::vector<T>& vec)
{
    std::sort(vec.begin(), vec.end());
    vec.erase(std::unique(vec.begin(), vec.end()), vec.end());
}

次のように呼び出します:

removeDuplicates<int>(vectorname);

2
+1テンプレート化してください!-しかし、テンプレート引数を明示的に指定せずに、removeDuplicates(vec)と書くだけでよい
Faisal Vali

10
またはさらに良いことに、テンプレート化されたイテレータを直接(開始と終了)取得するだけで、ベクトル以外の他の構造体でも実行できます。
カイルライアン

ええ、テンプレート!小さなリストのクイックフィックス、完全なSTLスタイル。+1 thx
QuantumKarl 2015年

@Kyle- erase()メソッドを持つ他のコンテナーでのみ、それ以外の場合は、新しい終了イテレーターを返し、呼び出しコードでコンテナーを切り捨てる必要があります。
Toby Speight 2016年

8

効率は複雑な概念です。時間とスペースの考慮事項、および一般的な測定値(O(n)などのあいまいな回答しか得られない場合)と特定の測定値があります(たとえば、入力特性によっては、バブルソートはクイックソートよりもはるかに高速です)。

重複が比較的少ない場合は、並べ替えの後に一意の消去を実行するのが適切です。重複が比較的多い場合は、ベクターからセットを作成し、それを実行させると、簡単に打ち負かされる可能性があります。

時間効率だけに集中しないでください。Sort + unique + eraseはO(1)空間で動作し、set構造はO(n)空間で動作します。また、どちらも直接map-reduce並列化には向いていません(本当に巨大なデータセットの場合)。


あなたにマップ/リデュース能力を与えるものは何ですか?私が考えることができる唯一のものは分散マージソートであり、最終的なマージではまだ1つのスレッドしか使用できません。
Zan Lynx

1
はい、1つの制御ノード/スレッドが必要です。ただし、制御/親スレッドが処理するワーカー/子スレッドの数、および各リーフノードが処理する必要のあるデータセットのサイズに上限を設けるために、必要な回数だけ問題を分割できます。map-reduceですべての問題を簡単に解決できるわけではありません。10テラバイトのデータを処理することを「火曜日」と呼ぶ、同様の(表面上はともかく)最適化の問題を扱う人々がいることを指摘したかっただけです。


7

unique(線形時間で実行するために必要な)連続する重複要素のみを削除するため、最初にソートを実行する必要があります。への呼び出し後もソートされたままになりますunique


7

要素の順序を変更したくない場合は、次の解決策を試すことができます。

template <class T>
void RemoveDuplicatesInVector(std::vector<T> & vec)
{
    set<T> values;
    vec.erase(std::remove_if(vec.begin(), vec.end(), [&](const T & value) { return !values.insert(value).second; }), vec.end());
}

おそらく、セットの代わりにunordered_setを使用します(利用可能な場合はboost :: remove_erase_ifを使用)
gast128

4

aがベクトルであると仮定して、次を使用して隣接する重複を削除します

a.erase(unique(a.begin(),a.end()),a.end());O(n)時間で実行されます。


1
連続した重複。わかりましたので、std::sort最初に必要です。
v.oddou

2

すでに述べたようにunique、ソートされたコンテナが必要です。さらに、unique実際にはコンテナから要素を削除しません。代わりに、それらは最後にコピーされ、unique最初のそのような重複要素を指すイテレータを返しますerase。実際に要素を削除するために呼び出すことが期待されています。


一意にはソートされたコンテナーが必要ですか、それとも隣接する重複を含まないように単に入力シーケンスを再配置するだけですか?後者だと思いました。

@パテ、正解です。必要ありません。隣接する重複を削除します。
ビル・リンチ

重複している可能性のあるコンテナーがあり、コンテナー内のどこにも重複した値がないコンテナーが必要な場合は、最初にコンテナーを並べ替えてから一意に渡し、次に消去を使用して重複を実際に削除する必要があります。隣接する重複を単に削除する場合は、コンテナーを並べ替える必要はありません。ただし、値が重複することになります。12 2 3 2 4 2 5 2は、ソートなしで一意に渡された場合は1 2 3 2 4 2 5 2に変更され、ソートされた場合は1 2 3 4 5に変更され、一意に渡されて消去されます。 。
Max Lybbert、2009年

2

ネイト・コールが提案した標準的なアプローチは、ベクトル、ソート+ユニークを使用するだけです。

sort( vec.begin(), vec.end() );
vec.erase( unique( vec.begin(), vec.end() ), vec.end() );

ポインタのベクトルに対しては機能しません。

cplusplus.comこの例を注意深く見てください。

彼らの例では、最後に移動された「いわゆる複製」は実際には?(未定義の値)、これらの「いわゆる重複」はSOMETIMESの「余分な要素」であり、SOMETIMESは元のベクトルにあった「欠落した要素」があるためです。

std::unique()オブジェクトへのポインターのベクトルで使用すると問題が発生します(メモリリーク、HEAPからのデータの読み取り不良、重複解放、セグメンテーション違反など)。

これが私の問題の解決策です:に置き換えstd::unique()てくださいptgi::unique()

以下のptgi_unique.hppファイルを参照してください。

// ptgi::unique()
//
// Fix a problem in std::unique(), such that none of the original elts in the collection are lost or duplicate.
// ptgi::unique() has the same interface as std::unique()
//
// There is the 2 argument version which calls the default operator== to compare elements.
//
// There is the 3 argument version, which you can pass a user defined functor for specialized comparison.
//
// ptgi::unique() is an improved version of std::unique() which doesn't looose any of the original data
// in the collection, nor does it create duplicates.
//
// After ptgi::unique(), every old element in the original collection is still present in the re-ordered collection,
// except that duplicates have been moved to a contiguous range [dupPosition, last) at the end.
//
// Thus on output:
//  [begin, dupPosition) range are unique elements.
//  [dupPosition, last) range are duplicates which can be removed.
// where:
//  [] means inclusive, and
//  () means exclusive.
//
// In the original std::unique() non-duplicates at end are moved downward toward beginning.
// In the improved ptgi:unique(), non-duplicates at end are swapped with duplicates near beginning.
//
// In addition if you have a collection of ptrs to objects, the regular std::unique() will loose memory,
// and can possibly delete the same pointer multiple times (leading to SEGMENTATION VIOLATION on Linux machines)
// but ptgi::unique() won't.  Use valgrind(1) to find such memory leak problems!!!
//
// NOTE: IF you have a vector of pointers, that is, std::vector<Object*>, then upon return from ptgi::unique()
// you would normally do the following to get rid of the duplicate objects in the HEAP:
//
//  // delete objects from HEAP
//  std::vector<Object*> objects;
//  for (iter = dupPosition; iter != objects.end(); ++iter)
//  {
//      delete (*iter);
//  }
//
//  // shrink the vector. But Object * pointers are NOT followed for duplicate deletes, this shrinks the vector.size())
//  objects.erase(dupPosition, objects.end));
//
// NOTE: But if you have a vector of objects, that is: std::vector<Object>, then upon return from ptgi::unique(), it
// suffices to just call vector:erase(, as erase will automatically call delete on each object in the
// [dupPosition, end) range for you:
//
//  std::vector<Object> objects;
//  objects.erase(dupPosition, last);
//
//==========================================================================================================
// Example of differences between std::unique() vs ptgi::unique().
//
//  Given:
//      int data[] = {10, 11, 21};
//
//  Given this functor: ArrayOfIntegersEqualByTen:
//      A functor which compares two integers a[i] and a[j] in an int a[] array, after division by 10:
//  
//  // given an int data[] array, remove consecutive duplicates from it.
//  // functor used for std::unique (BUGGY) or ptgi::unique(IMPROVED)
//
//  // Two numbers equal if, when divided by 10 (integer division), the quotients are the same.
//  // Hence 50..59 are equal, 60..69 are equal, etc.
//  struct ArrayOfIntegersEqualByTen: public std::equal_to<int>
//  {
//      bool operator() (const int& arg1, const int& arg2) const
//      {
//          return ((arg1/10) == (arg2/10));
//      }
//  };
//  
//  Now, if we call (problematic) std::unique( data, data+3, ArrayOfIntegersEqualByTen() );
//  
//  TEST1: BEFORE UNIQ: 10,11,21
//  TEST1: AFTER UNIQ: 10,21,21
//  DUP_INX=2
//  
//      PROBLEM: 11 is lost, and extra 21 has been added.
//  
//  More complicated example:
//  
//  TEST2: BEFORE UNIQ: 10,20,21,22,30,31,23,24,11
//  TEST2: AFTER UNIQ: 10,20,30,23,11,31,23,24,11
//  DUP_INX=5
//  
//      Problem: 21 and 22 are deleted.
//      Problem: 11 and 23 are duplicated.
//  
//  
//  NOW if ptgi::unique is called instead of std::unique, both problems go away:
//  
//  DEBUG: TEST1: NEW_WAY=1
//  TEST1: BEFORE UNIQ: 10,11,21
//  TEST1: AFTER UNIQ: 10,21,11
//  DUP_INX=2
//  
//  DEBUG: TEST2: NEW_WAY=1
//  TEST2: BEFORE UNIQ: 10,20,21,22,30,31,23,24,11
//  TEST2: AFTER UNIQ: 10,20,30,23,11,31,22,24,21
//  DUP_INX=5
//
//  @SEE: look at the "case study" below to understand which the last "AFTER UNIQ" results with that order:
//  TEST2: AFTER UNIQ: 10,20,30,23,11,31,22,24,21
//
//==========================================================================================================
// Case Study: how ptgi::unique() works:
//  Remember we "remove adjacent duplicates".
//  In this example, the input is NOT fully sorted when ptgi:unique() is called.
//
//  I put | separatators, BEFORE UNIQ to illustrate this
//  10  | 20,21,22 |  30,31 |  23,24 | 11
//
//  In example above, 20, 21, 22 are "same" since dividing by 10 gives 2 quotient.
//  And 30,31 are "same", since /10 quotient is 3.
//  And 23, 24 are same, since /10 quotient is 2.
//  And 11 is "group of one" by itself.
//  So there are 5 groups, but the 4th group (23, 24) happens to be equal to group 2 (20, 21, 22)
//  So there are 5 groups, and the 5th group (11) is equal to group 1 (10)
//
//  R = result
//  F = first
//
//  10, 20, 21, 22, 30, 31, 23, 24, 11
//  R    F
//
//  10 is result, and first points to 20, and R != F (10 != 20) so bump R:
//       R
//       F
//
//  Now we hits the "optimized out swap logic".
//  (avoid swap because R == F)
//
//  // now bump F until R != F (integer division by 10)
//  10, 20, 21, 22, 30, 31, 23, 24, 11
//       R   F              // 20 == 21 in 10x
//       R       F              // 20 == 22 in 10x
//       R           F          // 20 != 30, so we do a swap of ++R and F
//  (Now first hits 21, 22, then finally 30, which is different than R, so we swap bump R to 21 and swap with  30)
//  10, 20, 30, 22, 21, 31, 23, 24, 11  // after R & F swap (21 and 30)
//           R       F 
//
//  10, 20, 30, 22, 21, 31, 23, 24, 11
//           R          F           // bump F to 31, but R and F are same (30 vs 31)
//           R               F      // bump F to 23, R != F, so swap ++R with F
//  10, 20, 30, 22, 21, 31, 23, 24, 11
//                  R           F       // bump R to 22
//  10, 20, 30, 23, 21, 31, 22, 24, 11  // after the R & F swap (22 & 23 swap)
//                  R            F      // will swap 22 and 23
//                  R                F      // bump F to 24, but R and F are same in 10x
//                  R                    F  // bump F, R != F, so swap ++R  with F
//                      R                F  // R and F are diff, so swap ++R  with F (21 and 11)
//  10, 20, 30, 23, 11, 31, 22, 24, 21
//                      R                F  // aftter swap of old 21 and 11
//                      R                  F    // F now at last(), so loop terminates
//                          R               F   // bump R by 1 to point to dupPostion (first duplicate in range)
//
//  return R which now points to 31
//==========================================================================================================
// NOTES:
// 1) the #ifdef IMPROVED_STD_UNIQUE_ALGORITHM documents how we have modified the original std::unique().
// 2) I've heavily unit tested this code, including using valgrind(1), and it is *believed* to be 100% defect-free.
//
//==========================================================================================================
// History:
//  130201  dpb dbednar@ptgi.com created
//==========================================================================================================

#ifndef PTGI_UNIQUE_HPP
#define PTGI_UNIQUE_HPP

// Created to solve memory leak problems when calling std::unique() on a vector<Route*>.
// Memory leaks discovered with valgrind and unitTesting.


#include <algorithm>        // std::swap

// instead of std::myUnique, call this instead, where arg3 is a function ptr
//
// like std::unique, it puts the dups at the end, but it uses swapping to preserve original
// vector contents, to avoid memory leaks and duplicate pointers in vector<Object*>.

#ifdef IMPROVED_STD_UNIQUE_ALGORITHM
#error the #ifdef for IMPROVED_STD_UNIQUE_ALGORITHM was defined previously.. Something is wrong.
#endif

#undef IMPROVED_STD_UNIQUE_ALGORITHM
#define IMPROVED_STD_UNIQUE_ALGORITHM

// similar to std::unique, except that this version swaps elements, to avoid
// memory leaks, when vector contains pointers.
//
// Normally the input is sorted.
// Normal std::unique:
// 10 20 20 20 30   30 20 20 10
// a  b  c  d  e    f  g  h  i
//
// 10 20 30 20 10 | 30 20 20 10
// a  b  e  g  i    f  g  h  i
//
// Now GONE: c, d.
// Now DUPS: g, i.
// This causes memory leaks and segmenation faults due to duplicate deletes of same pointer!


namespace ptgi {

// Return the position of the first in range of duplicates moved to end of vector.
//
// uses operator==  of class for comparison
//
// @param [first, last) is a range to find duplicates within.
//
// @return the dupPosition position, such that [dupPosition, end) are contiguous
// duplicate elements.
// IF all items are unique, then it would return last.
//
template <class ForwardIterator>
ForwardIterator unique( ForwardIterator first, ForwardIterator last)
{
    // compare iterators, not values
    if (first == last)
        return last;

    // remember the current item that we are looking at for uniqueness
    ForwardIterator result = first;

    // result is slow ptr where to store next unique item
    // first is  fast ptr which is looking at all elts

    // the first iterator moves over all elements [begin+1, end).
    // while the current item (result) is the same as all elts
    // to the right, (first) keeps going, until you find a different
    // element pointed to by *first.  At that time, we swap them.

    while (++first != last)
    {
        if (!(*result == *first))
        {
#ifdef IMPROVED_STD_UNIQUE_ALGORITHM
            // inc result, then swap *result and *first

//          THIS IS WHAT WE WANT TO DO.
//          BUT THIS COULD SWAP AN ELEMENT WITH ITSELF, UNCECESSARILY!!!
//          std::swap( *first, *(++result));

            // BUT avoid swapping with itself when both iterators are the same
            ++result;
            if (result != first)
                std::swap( *first, *result);
#else
            // original code found in std::unique()
            // copies unique down
            *(++result) = *first;
#endif
        }
    }

    return ++result;
}

template <class ForwardIterator, class BinaryPredicate>
ForwardIterator unique( ForwardIterator first, ForwardIterator last, BinaryPredicate pred)
{
    if (first == last)
        return last;

    // remember the current item that we are looking at for uniqueness
    ForwardIterator result = first;

    while (++first != last)
    {
        if (!pred(*result,*first))
        {
#ifdef IMPROVED_STD_UNIQUE_ALGORITHM
            // inc result, then swap *result and *first

//          THIS COULD SWAP WITH ITSELF UNCECESSARILY
//          std::swap( *first, *(++result));
//
            // BUT avoid swapping with itself when both iterators are the same
            ++result;
            if (result != first)
                std::swap( *first, *result);

#else
            // original code found in std::unique()
            // copies unique down
            // causes memory leaks, and duplicate ptrs
            // and uncessarily moves in place!
            *(++result) = *first;
#endif
        }
    }

    return ++result;
}

// from now on, the #define is no longer needed, so get rid of it
#undef IMPROVED_STD_UNIQUE_ALGORITHM

} // end ptgi:: namespace

#endif

そして、これは私がそれをテストするために使用したUNITテストプログラムです:

// QUESTION: in test2, I had trouble getting one line to compile,which was caused  by the declaration of operator()
// in the equal_to Predicate.  I'm not sure how to correctly resolve that issue.
// Look for //OUT lines
//
// Make sure that NOTES in ptgi_unique.hpp are correct, in how we should "cleanup" duplicates
// from both a vector<Integer> (test1()) and vector<Integer*> (test2).
// Run this with valgrind(1).
//
// In test2(), IF we use the call to std::unique(), we get this problem:
//
//  [dbednar@ipeng8 TestSortRoutes]$ ./Main7
//  TEST2: ORIG nums before UNIQUE: 10, 20, 21, 22, 30, 31, 23, 24, 11
//  TEST2: modified nums AFTER UNIQUE: 10, 20, 30, 23, 11, 31, 23, 24, 11
//  INFO: dupInx=5
//  TEST2: uniq = 10
//  TEST2: uniq = 20
//  TEST2: uniq = 30
//  TEST2: uniq = 33427744
//  TEST2: uniq = 33427808
//  Segmentation fault (core dumped)
//
// And if we run valgrind we seen various error about "read errors", "mismatched free", "definitely lost", etc.
//
//  valgrind --leak-check=full ./Main7
//  ==359== Memcheck, a memory error detector
//  ==359== Command: ./Main7
//  ==359== Invalid read of size 4
//  ==359== Invalid free() / delete / delete[]
//  ==359== HEAP SUMMARY:
//  ==359==     in use at exit: 8 bytes in 2 blocks
//  ==359== LEAK SUMMARY:
//  ==359==    definitely lost: 8 bytes in 2 blocks
// But once we replace the call in test2() to use ptgi::unique(), all valgrind() error messages disappear.
//
// 130212   dpb dbednar@ptgi.com created
// =========================================================================================================

#include <iostream> // std::cout, std::cerr
#include <string>
#include <vector>   // std::vector
#include <sstream>  // std::ostringstream
#include <algorithm>    // std::unique()
#include <functional>   // std::equal_to(), std::binary_function()
#include <cassert>  // assert() MACRO

#include "ptgi_unique.hpp"  // ptgi::unique()



// Integer is small "wrapper class" around a primitive int.
// There is no SETTER, so Integer's are IMMUTABLE, just like in JAVA.

class Integer
{
private:
    int num;
public:

    // default CTOR: "Integer zero;"
    // COMPRENSIVE CTOR:  "Integer five(5);"
    Integer( int num = 0 ) :
        num(num)
    {
    }

    // COPY CTOR
    Integer( const Integer& rhs) :
        num(rhs.num)
    {
    }

    // assignment, operator=, needs nothing special... since all data members are primitives

    // GETTER for 'num' data member
    // GETTER' are *always* const
    int getNum() const
    {
        return num;
    }   

    // NO SETTER, because IMMUTABLE (similar to Java's Integer class)

    // @return "num"
    // NB: toString() should *always* be a const method
    //
    // NOTE: it is probably more efficient to call getNum() intead
    // of toString() when printing a number:
    //
    // BETTER to do this:
    //  Integer five(5);
    //  std::cout << five.getNum() << "\n"
    // than this:
    //  std::cout << five.toString() << "\n"

    std::string toString() const
    {
        std::ostringstream oss;
        oss << num;
        return oss.str();
    }
};

// convenience typedef's for iterating over std::vector<Integer>
typedef std::vector<Integer>::iterator      IntegerVectorIterator;
typedef std::vector<Integer>::const_iterator    ConstIntegerVectorIterator;

// convenience typedef's for iterating over std::vector<Integer*>
typedef std::vector<Integer*>::iterator     IntegerStarVectorIterator;
typedef std::vector<Integer*>::const_iterator   ConstIntegerStarVectorIterator;

// functor used for std::unique or ptgi::unique() on a std::vector<Integer>
// Two numbers equal if, when divided by 10 (integer division), the quotients are the same.
// Hence 50..59 are equal, 60..69 are equal, etc.
struct IntegerEqualByTen: public std::equal_to<Integer>
{
    bool operator() (const Integer& arg1, const Integer& arg2) const
    {
        return ((arg1.getNum()/10) == (arg2.getNum()/10));
    }
};

// functor used for std::unique or ptgi::unique on a std::vector<Integer*>
// Two numbers equal if, when divided by 10 (integer division), the quotients are the same.
// Hence 50..59 are equal, 60..69 are equal, etc.
struct IntegerEqualByTenPointer: public std::equal_to<Integer*>
{
    // NB: the Integer*& looks funny to me!
    // TECHNICAL PROBLEM ELSEWHERE so had to remove the & from *&
//OUT   bool operator() (const Integer*& arg1, const Integer*& arg2) const
//
    bool operator() (const Integer* arg1, const Integer* arg2) const
    {
        return ((arg1->getNum()/10) == (arg2->getNum()/10));
    }
};

void test1();
void test2();
void printIntegerStarVector( const std::string& msg, const std::vector<Integer*>& nums );

int main()
{
    test1();
    test2();
    return 0;
}

// test1() uses a vector<Object> (namely vector<Integer>), so there is no problem with memory loss
void test1()
{
    int data[] = { 10, 20, 21, 22, 30, 31, 23, 24, 11};

    // turn C array into C++ vector
    std::vector<Integer> nums(data, data+9);

    // arg3 is a functor
    IntegerVectorIterator dupPosition = ptgi::unique( nums.begin(), nums.end(), IntegerEqualByTen() );

    nums.erase(dupPosition, nums.end());

    nums.erase(nums.begin(), dupPosition);
}

//==================================================================================
// test2() uses a vector<Integer*>, so after ptgi:unique(), we have to be careful in
// how we eliminate the duplicate Integer objects stored in the heap.
//==================================================================================
void test2()
{
    int data[] = { 10, 20, 21, 22, 30, 31, 23, 24, 11};

    // turn C array into C++ vector of Integer* pointers
    std::vector<Integer*> nums;

    // put data[] integers into equivalent Integer* objects in HEAP
    for (int inx = 0; inx < 9; ++inx)
    {
        nums.push_back( new Integer(data[inx]) );
    }

    // print the vector<Integer*> to stdout
    printIntegerStarVector( "TEST2: ORIG nums before UNIQUE", nums );

    // arg3 is a functor
#if 1
    // corrected version which fixes SEGMENTATION FAULT and all memory leaks reported by valgrind(1)
    // I THINK we want to use new C++11 cbegin() and cend(),since the equal_to predicate is passed "Integer *&"

//  DID NOT COMPILE
//OUT   IntegerStarVectorIterator dupPosition = ptgi::unique( const_cast<ConstIntegerStarVectorIterator>(nums.begin()), const_cast<ConstIntegerStarVectorIterator>(nums.end()), IntegerEqualByTenPointer() );

    // DID NOT COMPILE when equal_to predicate declared "Integer*& arg1, Integer*&  arg2"
//OUT   IntegerStarVectorIterator dupPosition = ptgi::unique( const_cast<nums::const_iterator>(nums.begin()), const_cast<nums::const_iterator>(nums.end()), IntegerEqualByTenPointer() );


    // okay when equal_to predicate declared "Integer* arg1, Integer*  arg2"
    IntegerStarVectorIterator dupPosition = ptgi::unique(nums.begin(), nums.end(), IntegerEqualByTenPointer() );
#else
    // BUGGY version that causes SEGMENTATION FAULT and valgrind(1) errors
    IntegerStarVectorIterator dupPosition = std::unique( nums.begin(), nums.end(), IntegerEqualByTenPointer() );
#endif

    printIntegerStarVector( "TEST2: modified nums AFTER UNIQUE", nums );
    int dupInx = dupPosition - nums.begin();
    std::cout << "INFO: dupInx=" << dupInx <<"\n";

    // delete the dup Integer* objects in the [dupPosition, end] range
    for (IntegerStarVectorIterator iter = dupPosition; iter != nums.end(); ++iter)
    {
        delete (*iter);
    }

    // shrink the vector
    // NB: the Integer* ptrs are NOT followed by vector::erase()
    nums.erase(dupPosition, nums.end());


    // print the uniques, by following the iter to the Integer* pointer
    for (IntegerStarVectorIterator iter = nums.begin(); iter != nums.end();  ++iter)
    {
        std::cout << "TEST2: uniq = " << (*iter)->getNum() << "\n";
    }

    // remove the unique objects from heap
    for (IntegerStarVectorIterator iter = nums.begin(); iter != nums.end();  ++iter)
    {
        delete (*iter);
    }

    // shrink the vector
    nums.erase(nums.begin(), nums.end());

    // the vector should now be completely empty
    assert( nums.size() == 0);
}

//@ print to stdout the string: "info_msg: num1, num2, .... numN\n"
void printIntegerStarVector( const std::string& msg, const std::vector<Integer*>& nums )
{
    std::cout << msg << ": ";
    int inx = 0;
    ConstIntegerStarVectorIterator  iter;

    // use const iterator and const range!
    // NB: cbegin() and cend() not supported until LATER (c++11)
    for (iter = nums.begin(), inx = 0; iter != nums.end(); ++iter, ++inx)
    {
        // output a comma seperator *AFTER* first
        if (inx > 0)
            std::cout << ", ";

        // call Integer::toString()
        std::cout << (*iter)->getNum();     // send int to stdout
//      std::cout << (*iter)->toString();   // also works, but is probably slower

    }

    // in conclusion, add newline
    std::cout << "\n";
}

ここでは根拠がわかりません。それで、ポインタのコンテナがあり、重複を削除したい場合、それはポインタが指すオブジェクトにどのように影響しますか?それらを指すポインターが少なくとも1つ(このコンテナーには正確に1つ)あるため、メモリーリークは発生しません。まあ、まあ、私はあなたのメソッドがいくつかの奇妙なオーバーロードされた演算子または特別な考慮を必要とする奇妙な比較関数でいくつかのメリットがあるかもしれないと思います。
kccqzy 2013

私はあなたのポイントを理解しているかどうかわかりません。4つのポインタが整数{1、2. 2、3}を指すvector <int *>の単純なケースを考えます。ソートされていますが、std :: uniqueを呼び出した後、4つのポインターは整数{1、2、3、3}へのポインターです。これで、3への2つの同一のポインターがあるため、deleteを呼び出すと、重複した削除が行われます。悪い!次に、2番目の2つが欠落している、メモリリークがあることに注意してください。
ジョー

kccqzy、あなたが私の答えをよりよく理解するためのサンプルプログラムをここに示します:
joe

@joe:std::unique[ 1、2、3、2]があった後でも、2にぶら下がりポインタが残るため、2でdeleteを呼び出すことはできません。=> newEnd = std::uniqueとの間の要素に対しては、deleteを呼び出さないでください。std::endこれらの要素へのポインタがまだ[std::begin, newEnd)
MFH 2014

2
@ArneVogel:おそらく「うまくいく」という些細な値の場合。そのようなベクトルに含めることができる唯一の複製された値はuniqueであるためvector<unique_ptr<T>>、を呼び出すことはかなり無意味ですnullptr
Ben Voigt

2

Rangesライブラリ(C ++ 20で提供)を使用すると、簡単に使用できます

action::unique(vec);

単に移動するのではなく、実際には重複する要素を削除することに注意してください。


1

alexK7ベンチマークについて。私はそれらを試して同様の結果を得ましたが、値の範囲が100万の場合、std :: sort(f1)を使用した場合とstd :: unordered_set(f5)を使用した場合は同様の時間が生成されます。値の範囲が1000万の場合、f1はf5より高速です。

値の範囲が制限されていて、値がunsigned intである場合、std :: vectorを使用できます。そのサイズは指定された範囲に対応します。これがコードです:

void DeleteDuplicates_vector_bool(std::vector<unsigned>& v, unsigned range_size)
{
    std::vector<bool> v1(range_size);
    for (auto& x: v)
    {
       v1[x] = true;    
    }
    v.clear();

    unsigned count = 0;
    for (auto& x: v1)
    {
        if (x)
        {
            v.push_back(count);
        }
        ++count;
    }
}

1

sort(v.begin()、v.end())、v.erase(unique(v.begin()、v、end())、v.end());


1

パフォーマンスを求めてを使用している場合はstd::vector、このドキュメントリンクで提供されているものをお勧めします。

std::vector<int> myvector{10,20,20,20,30,30,20,20,10};             // 10 20 20 20 30 30 20 20 10
std::sort(myvector.begin(), myvector.end() );
const auto& it = std::unique (myvector.begin(), myvector.end());   // 10 20 30 ?  ?  ?  ?  ?  ?
                                                                   //          ^
myvector.resize( std::distance(myvector.begin(),it) ); // 10 20 30

cplusplus.comは、公式ドキュメントではありません。
イリヤ・ポポフ

0
std::set<int> s;
std::for_each(v.cbegin(), v.cend(), [&s](int val){s.insert(val);});
v.clear();
std::copy(s.cbegin(), s.cend(), v.cbegin());

1
おそらく、ベクターをクリアした後にベクターのサイズを変更して、ベクターを構築するときにメモリ割り当てが1つだけになるようにします。セットを後で必要としないので、intをコピーするのではなく、std :: copyではなくstd :: moveを使用してベクターに移動することをお勧めします。
YoungJohn

0

ベクトルを変更したくない場合(消去、ソート)、Newtonライブラリを使用できます。アルゴリズムサブライブラリには、copy_singleという関数呼び出しがあります。

template <class INPUT_ITERATOR, typename T>
    void copy_single( INPUT_ITERATOR first, INPUT_ITERATOR last, std::vector<T> &v )

だからあなたはできる:

std::vector<TYPE> copy; // empty vector
newton::copy_single(first, last, copy);

どこコピーは、あなたがしたい場所のベクトルである一backするユニークな要素のコピーを。ただし、要素をpush_backすることを忘れないでください。、新しいベクトルを作成しないことを

とにかく、要素を消去()しないので、これはより高速です(再割り当てのためにpop_back()を除いて、これには長い時間がかかります)。

私はいくつかの実験を行い、それはより高速です。

また、次のものを使用できます。

std::vector<TYPE> copy; // empty vector
newton::copy_single(first, last, copy);
original = copy;

時にはさらに速いです。


1
この関数は、標準ライブラリにとして存在しunique_copyます。
LF

0

より理解しやすいコード:https : //en.cppreference.com/w/cpp/algorithm/unique

#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <cctype>

int main() 
{
    // remove duplicate elements
    std::vector<int> v{1,2,3,1,2,3,3,4,5,4,5,6,7};
    std::sort(v.begin(), v.end()); // 1 1 2 2 3 3 3 4 4 5 5 6 7 
    auto last = std::unique(v.begin(), v.end());
    // v now holds {1 2 3 4 5 6 7 x x x x x x}, where 'x' is indeterminate
    v.erase(last, v.end()); 
    for (int i : v)
      std::cout << i << " ";
    std::cout << "\n";
}

出力:

1 2 3 4 5 6 7

0
void removeDuplicates(std::vector<int>& arr) {
    for (int i = 0; i < arr.size(); i++)
    {
        for (int j = i + 1; j < arr.size(); j++)
        {
            if (arr[i] > arr[j])
            {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
    std::vector<int> y;
    int x = arr[0];
    int i = 0;
    while (i < arr.size())
    {
        if (x != arr[i])
        {
            y.push_back(x);
            x = arr[i];
        }
        i++;
        if (i == arr.size())
            y.push_back(arr[i - 1]);
    }
    arr = y;
}

2
StackOverflowへようこそ!してください編集あなたの質問の説明に追加する方法を、あなたのコードの作品、そしてなぜそれが同等または他の答えよりはましだが。この質問は10年以上前のものであり、すでに十分に説明された良い答えがたくさんあります。あなたの説明がなければ、それはあまり役に立たず、反対票が投じられたり削除されたりする可能性が高くなります。
Das_Geek

-1

std :: unique()で発生する重複削除の問題の例を次に示します。Linuxマシンでは、プログラムがクラッシュします。詳細についてはコメントを読んでください。

// Main10.cpp
//
// Illustration of duplicate delete and memory leak in a vector<int*> after calling std::unique.
// On a LINUX machine, it crashes the progam because of the duplicate delete.
//
// INPUT : {1, 2, 2, 3}
// OUTPUT: {1, 2, 3, 3}
//
// The two 3's are actually pointers to the same 3 integer in the HEAP, which is BAD
// because if you delete both int* pointers, you are deleting the same memory
// location twice.
//
//
// Never mind the fact that we ignore the "dupPosition" returned by std::unique(),
// but in any sensible program that "cleans up after istelf" you want to call deletex
// on all int* poitners to avoid memory leaks.
//
//
// NOW IF you replace std::unique() with ptgi::unique(), all of the the problems disappear.
// Why? Because ptgi:unique merely reshuffles the data:
// OUTPUT: {1, 2, 3, 2}
// The ptgi:unique has swapped the last two elements, so all of the original elements in
// the INPUT are STILL in the OUTPUT.
//
// 130215   dbednar@ptgi.com
//============================================================================

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>

#include "ptgi_unique.hpp"

// functor used by std::unique to remove adjacent elts from vector<int*>
struct EqualToVectorOfIntegerStar: public std::equal_to<int *>
{
    bool operator() (const int* arg1, const int* arg2) const
    {
        return (*arg1 == *arg2);
    }
};

void printVector( const std::string& msg, const std::vector<int*>& vnums);

int main()
{
    int inums [] = { 1, 2, 2, 3 };
    std::vector<int*> vnums;

    // convert C array into vector of pointers to integers
    for (size_t inx = 0; inx < 4; ++ inx)
        vnums.push_back( new int(inums[inx]) );

    printVector("BEFORE UNIQ", vnums);

    // INPUT : 1, 2A, 2B, 3
    std::unique( vnums.begin(), vnums.end(), EqualToVectorOfIntegerStar() );
    // OUTPUT: 1, 2A, 3, 3 }
    printVector("AFTER  UNIQ", vnums);

    // now we delete 3 twice, and we have a memory leak because 2B is not deleted.
    for (size_t inx = 0; inx < vnums.size(); ++inx)
    {
        delete(vnums[inx]);
    }
}

// print a line of the form "msg: 1,2,3,..,5,6,7\n", where 1..7 are the numbers in vnums vector
// PS: you may pass "hello world" (const char *) because of implicit (automatic) conversion
// from "const char *" to std::string conversion.

void printVector( const std::string& msg, const std::vector<int*>& vnums)
{
    std::cout << msg << ": ";

    for (size_t inx = 0; inx < vnums.size(); ++inx)
    {
        // insert comma separator before current elt, but ONLY after first elt
        if (inx > 0)
            std::cout << ",";
        std::cout << *vnums[inx];

    }
    std::cout << "\n";
}

PS: "valgrind ./Main10"も実行しましたが、valgrindは何の問題も検出しませんでした。Linuxを使用するすべてのC ++プログラマーに、この非常に生産的なツールを使用することを強くお勧めします。特に、24時間年中無休で実行する必要があり、リークやクラッシュを起こさないリアルタイムアプリケーションを作成している場合は特にそうです。
joe

std :: uniqueの問題の核心は、「std :: uniqueが指定されていない状態で重複を返す」というステートメントで要約できます!!!!! なぜ標準化委員会がこれを行ったのか、私にはわかりません。委員会メンバー..コメント???
joe

1
はい、「std :: uniqueは不特定の状態で重複を返します」。したがって、メモリを手動で管理するために「一意」にされた配列に依存しないでください。これを行う最も簡単な方法は、生のポインタの代わりにstd :: unique_ptrを使用することです。
alexk7 14年

これは別の答えへの応答のようです。質問には答えません(vectorポインタには整数ではなく整数が含まれ、コンパレータは指定されていません)。
Toby Speight 2016年

-2
void EraseVectorRepeats(vector <int> & v){ 
TOP:for(int y=0; y<v.size();++y){
        for(int z=0; z<v.size();++z){
            if(y==z){ //This if statement makes sure the number that it is on is not erased-just skipped-in order to keep only one copy of a repeated number
                continue;}
            if(v[y]==v[z]){
                v.erase(v.begin()+z); //whenever a number is erased the function goes back to start of the first loop because the size of the vector changes
            goto TOP;}}}}

これは、繰り返しを削除するために使用できる、私が作成した関数です。必要なヘッダファイルだけである<iostream><vector>

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.