上位 10 の古典的なソートアルゴリズムを理解するのに役立つ 20 枚の写真

上位 10 の古典的なソートアルゴリズムを理解するのに役立つ 20 枚の写真

[[433768]]

ソートアルゴリズムのトップ10のアイデアのまとめ

手書きのソートアルゴリズムは面接中によく遭遇するので、この記事では簡単にまとめます。アルゴリズムの詳細については紹介せず、一般的な説明のみを行います。

交換クラス: ソートは要素をペアで交換することで実現されます

挿入: 数字を2つの部分に分割し、順序のない数字を順序付けられたシーケンスに1つずつ挿入します。

選択クラス: ソートするシーケンスから最小または最大の要素を見つけ、ソートされたシーケンスの後に置きます。

「カウンティング ソートと基数ソートはバケット ソートの特別な実装と見なすことができますが、どちらも要素を比較することによってソートを実現するものではありません。」

バブルソート

バブルソートは最初から始まり、配列内の隣接する 2 つの要素を順番に比較します。後者の数値が前者の数値より大きい場合は 2 つの数値が交換され、そうでない場合は交換されません。各比較の後、配列内の最大の要素が最後に配置されます。

下の図に示すように、比較ラウンドのプロセスは次のようになります。

配列に n 個の要素がある場合、必要な比較は n 回だけであり、配列全体が整列します。

  1. 公共 静的voidバブルソート( int []a){
  2.  // i 回の比較を実行する
  3. ( int i = 0; i < a.length - 1; i++) {
  4.  ( int j = 0; j < a.length - 1 - i; j++) {
  5.             もし(a[j] > a[j + 1])であれば{
  6.                 スワップ(a, j, j + 1);
  7.             }
  8.         }
  9.     }
  10.  } 
  11.  
  12. 公共 静的void swap( int [] a, int i, int j) {
  13. 整数  temp = a[i];
  14.     関数 i は、次の式で表されます。
  15.     a[j] =一時;
  16.  }

クイックソート

クイックソートの実行プロセスは主に次の3つのステップに分かれています。

シーケンスから基数として数字を取ります

分割し、それより大きい数字はすべて右側に、それより小さいか等しい数字はすべて左側に置く

各間隔に数字が 1 つだけになるまで、左と右の間隔に対して 2 番目の手順を繰り返します。

  1. 公共 静的voidクイックソート( int []a, int  左、 int  右） {
  2.     （左>=右）の場合{
  3. 戻る;
  4.     }
  5. 整数 インデックス= sort(a, left , right );
  6.     quickSort(a,左,インデックス- 1);
  7.     quickSort(a,インデックス+ 1,右);
  8.  } 
  9.  
  10. 公共 静的  intソート( int [] a, int  左、 int  右） {
  11. 整数 キー= a[左];
  12.     （左<右）{
  13.         // high が指す位置から前方に検索して、 keyより小さいキーワードを持つ最初のレコードを見つけ、それをkeyと交換します。
  14.         while (左<右&& a[右] >=キー) {
  15. 右- ;  
  16.         }
  17.         a[左] = a[右];
  18.         // low が指す位置から逆方向に検索し、 keyより大きいキーワードを持つ最初のレコードを見つけて、 keyと交換します。
  19.         while (左<右&& a[左] <=キー) {
  20. 左++;
  21.         }
  22.         a[右] = a[左];
  23.     }
  24.     //キー値を入れると、左と右が同じになります
  25.     a[左] =キー;
  26. 戻る 左;
  27.  }

次の図はパーティションのプロセスを示しています

「古典的なトップ K 面接の質問は、通常、クイック ソートとヒープ ソートを使用して解決できます。」次のセクションで分析してみましょう。

挿入ソート

配列を順序付き配列と順序なし配列の両端に分割し、順序なし配列の値を順序なし配列に 1 つずつ挿入します。

下の図に示すように、3 6 7 は順序付き配列であり、4 2 は順序なし配列です。順序付けられていない配列に 4 と 2 を順番に挿入します。

図に示すように、4を挿入するプロセスは次のとおりです。

プログラムは順序付き配列と順序なし配列をどのように分割するのでしょうか? 最初の要素を順序付き配列と考えることができ、後続の値は順番に挿入することができます。

  1. 公共 静的void挿入ソート( int []a){
  2.  ( int i = 1; i < a.length; i++) {
  3.  ( int j = i; j > 0; j --) {  
  4.             (a[j] < a[j - 1]) である間 {
  5.                 スワップ(a, j, j - 1);
  6.             }
  7.         }
  8.     }
  9.  } 
  10.  
  11. 公共 静的void swap( int [] a, int i, int j) {
  12. 整数  temp = a[i];
  13.     関数 i は、次の式で表されます。
  14.     a[j] =一時;
  15.  }

「無駄なスワッピング処理がたくさんあることがわかります。スワップする要素を直接特定して、スワップを実行できます。挿入ソート コードの改善」

  1. 公共 静的void挿入ソート( int []a){
  2.  ( int i = 1; i < a.length; i++) {
  3. 整数  temp = a[i];
  4. 整数j;
  5.         // 適切な挿入位置を見つけて挿入する
  6. (j = i - 1; j >= 0 && a[j] > temp ; j --)の場合{  
  7.             1 は 0 です。
  8.         }
  9.         a[j + 1] =温度;
  10.     }
  11.  }

シェルソート

「シェルソートは挿入ソートをベースに改良したアルゴリズムです。データの移動回数が多すぎると効率が悪くなります。そこで、まず配列全体を整然とした状態にして（移動範囲を最初は大きくし、後半は小さくする）、移動回数を減らして効率を上げます。」

元のアドレス: Blog Park「グラフィカルソートアルゴリズム (II) - ヒルソート」

  1. 公共 静的voidシェルソート( int []a){
  2.  ( intステップ = a.length / 2; ステップ > 0; ステップ /= 2) {
  3.  ( int i = ステップ; i < a.length; i++) {
  4. 整数  temp = a[i];
  5. 整数j;
  6.  ( j = i - ステップ; j >= 0 && a[j] > temp ; j -= ステップ) {
  7.                 a[j + ステップ] = a[j];
  8.             }
  9.             a[j + ステップ] = temp ;
  10.         }
  11.     }
  12.  }

選択ソート

最初の反復では、最小の値が配列の位置 0 に配置されます。2 番目の反復では、2 番目に小さい値が配列の位置 1 に配置されます。

  1. 公共 静的void選択ソート( int []a){
  2.  ( int i = 0; i < a.length; i++) {
  3. 整数 インデックス= i;
  4.  ( int j = i + 1; j < a.length; j++) {
  5.             if (a[インデックス] > a[j]) {
  6. インデックス= j;
  7.             }
  8.         }
  9.         if (インデックス!= i ) {
  10.             swap(a,インデックス, i);
  11.         }
  12.     }
  13.  } 
  14.  
  15. 公共 静的void swap( int [] a, int i, int j) {
  16. 整数  temp = a[i];
  17.     関数 i は、次の式で表されます。
  18.     a[j] =一時;
  19.  }

ヒープソート

ヒープソートを手動で記述してみましょう。まず、ヒープとは何かを説明しましょう。

  1. ヒープは、次の特性を満たす必要があるデータ構造です。
  2. ヒープは完全な二分木です（ノードが生成される順序は左から右、上から下です）

ヒープ内のノードの値は、常にその親ノードの値より大きくも小さくもありません。

「最大のルート ノードを持つヒープは最大ヒープまたはビッグ ルート ヒープと呼ばれ、最小のルート ノードを持つヒープは最小ヒープまたはスモール ルート ヒープと呼ばれます。」

大きな根杭と小さな根杭を下図に示します。

次のような完全な二分木があるとします。これをヒープに合わせて調整するにはどうすればよいでしょうか。

10 とその子ノードは条件を満たし、3 とその子ノードは条件を満たし、ノード 4 は条件を満たしていないことがわかります。

「そこで、ノード 4 を調整する必要があります。調整プロセスはヒープ化と呼ばれます。」

  • ノード4の左右のノードから大きなノード（つまりノード10）を探し、それをノード4と交換する。
  • 交換後、交換したノードが条件を満たさなくなる可能性があるため、調整が必要になります（調整プロセスは1と同様です）
  • 最後に、ノード 4 と 5 が交換されます。バイナリツリーがヒープになる

実際の開発プロセスでは、ヒープを表すためにツリー構造ではなく配列を使用します。下付き文字の特性から、次のような規則をまとめることができる。

配列内のノードのノードインデックスがiの場合、

親ノードの添え字は: parent = (i - 1) / 2 左ノードの添え字は: c1 = 2 * i + 1 右ノードの添え字は: c2 = 2 * i + 2

したがって、上図のヒープは[10, 5, 3, 4, 1, 2, 0]という配列で表されます。

ヒープを配列で表現する方法がわかったので、次のノード 4 をヒープ化するプロセスを記述してみましょう。

  1.  /**
  2.  * @param 配列
  3.  * @param n 配列の長さ
  4.  * @param i ヒープ化されるノード
  5.  */
  6. 公共 静的voidヒープ化( int []a, intn , inti ){
  7.     // 再帰終了
  8.     もし (i >= n) {
  9. 戻る;
  10.     }
  11.     //左ノードの添え字
  12. c1 = 2 * i + 1;整数
  13.     // 右ノードの添え字
  14. 整数c2 = 2 * i + 2;
  15. 整数 最大値= i;
  16.     c1 < n && a[c1] > a[ max ]の場合{
  17. 最大値c1;
  18.     }
  19.     c2 < n && a[c2] > a[ max ]の場合{
  20. 最大値c2;
  21.     }
  22.     //左ノードと右ノードの最大値を親ノードと交換する
  23.     （最大値！= i）の場合{
  24.         swap(a, max , i);
  25.         ヒープ化(a, n, max );
  26.     }
  27.  }
  1.  @テスト
  2. パブリックボイドヒープ化() {
  3.  int [] 配列 = 新しいint []{4, 10, 3, 5, 1, 2};
  4.     // 調整後: 10、5、3、4、1、2
  5.     HeapSort.heapify(配列、配列の長さ、0);

「完全な二分木をヒープに変換するにはどうすればよいでしょうか？」

「非リーフ ノードを左から右、下から上にヒープ化するだけです。」次の図に示すように、10、3、4 を順番にヒープ化するだけです。

  1. 公共 静的voidビルドツリー( int []a){
  2.     // 最後の非リーフノードを見つける
  3. int lastNode = a.length - 1;
  4.  int親 = (lastNode - 1) / 2;
  5.  ( int i = 親; i >= 0; i --) {  
  6.         ヒープ化(a, a.length, i);
  7.     }
  8.  }

テストしてみましょう

  1. @テスト
  2. パブリックボイドビルドツリー() {
  3.  int [] 配列 = 新しいint []{3, 5, 7, 2, 4, 9, 6};
  4.     // 9 5 7 2 4 3 6
  5.     HeapSort.buildTree(配列);
  6.  }

ヒープがどのように生成され、どのように調整されるかがわかれば、ヒープソートのプロセスを分析するのは非常に簡単になります。

最大ヒープを例にとると、最大値はルートノードである必要があります。

  1. ルートノードを最後のリーフノードと交換し、リーフノードをヒープから削除します。
  2. このとき、ルートノードは要件を満たしていないため、ルートノードをヒープ化した後、再びヒープになります。
  3. 手順 1 と 2 を繰り返して、残りのノードの中で最大値を見つけます。

毎回見つかる最大値は配列の最後の位置にあるため、実際にヒープを削除する必要はありません。ヒープ化するときに、配列の長さを徐々に減らすだけで済みます。最終的な配列は昇順です

  1. 公共 静的voidヒープソート( int []a){
  2.     // 最初にヒープを構築します
  3.     ツリーを構築します。
  4.     // 毎回、ルートノードとヒープの最後のノードを交換し、ヒープ化します
  5. ( int i = a.length - 1; i >= 0; i --) {  
  6.         スワップ(a, i, 0);
  7.         ヒープ化(a, i, 0);
  8.     }
  9.  }

最終的なヒープソートコードは次のようになります。

  1. パブリッククラスHeapSort { 
  2.  
  3. 公共 静的voidヒープソート( int []a){
  4.         ツリーを構築します。
  5.  ( int i = a.length - 1; i >= 0; i --) {  
  6.             スワップ(a, i, 0);
  7.             ヒープ化(a, i, 0);
  8.         }
  9.     } 
  10.  
  11. 公共 静的voidビルドツリー( int []a){
  12.         // 最後の非リーフノードを見つける
  13. int lastNode = a.length - 1;
  14.  int親 = (lastNode - 1) / 2;
  15.  ( int i = 親; i >= 0; i --) {  
  16.             ヒープ化(a, a.length, i);
  17.         }
  18.     } 
  19.  
  20.     /**
  21.      * @param 配列
  22.      * @param n 配列の長さ
  23.      * @param i ヒープ化されるノード
  24.      */
  25. 公共 静的voidヒープ化( int []a, intn , inti ){
  26.         もし (i >= n) {
  27. 戻る;
  28.         }
  29.  c1 = 2 * i + 1;整数
  30. 整数c2 = 2 * i + 2;
  31. 整数 最大値= i;
  32.         c1 < n && a[c1] > a[ max ]の場合{
  33. 最大値c1;
  34.         }
  35.         c2 < n && a[c2] > a[ max ]の場合{
  36. 最大値c2;
  37.         }
  38.         （最大値！= i）の場合{
  39.             swap(a, max , i);
  40.             ヒープ化(a, n, max );
  41.         }
  42.     } 
  43.  
  44. 公共 静的void swap( int [] a, int i, int j) {
  45. 整数  temp = a[i];
  46.         関数 i は、次の式で表されます。
  47.         a[j] =一時;
  48.     }
  49.  }

ここでは、ヒープの構築方法とヒープソートのプロセスがどのようなものかのみを説明します。

「完全なヒープ実装には、ノードを挿入し、ルート ノードを削除するメソッドも提供する必要があります。」実装は書きませんが、図を使ってプロセスを説明します。興味があれば書き留めておいてもいいでしょう。「ほとんどの言語には組み込みのヒープ実装、つまり優先度キュー (Java では PriorityQueue) があるので、ヒープが必要なときは PriorityQueue を使うだけで済みます。」

ヒープにノードを挿入する

ノードがヒープ内に挿入されると、挿入された位置は完全なバイナリ ツリーの最後の位置になります。たとえば、値 8 を持つ新しいノードを挿入します。

8 をその親ノードと比較します。8 > 5 の場合、新しいノードを浮かせて、親ノードと位置を交換します。

スワップ後、親ノードとの比較を続けます。8<9 の場合、調整は必要ありません。

ヒープ削除ノード

ヒープからノードが削除されると、ヒープの最上部のノードが削除されます。例えば、最大ヒープの9番目のノードを削除します

ヒープ構造を維持するために、ヒープの最後のノード 6 をヒープの先頭に追加します。

次に、ヒープの最上位ノードをその左と右の子ノードと比較します。左と右の子のうち最大のノードがノード 6 より大きい場合、ノード 6 は下に移動します。

次に、左のノードと右のノードを比較します。3<6 の場合、調整は必要ありません。

最初のK高周波要素

タイトルアドレス: オファー40。kの最小数

整数配列 arr を入力し、その中の最小の k 個の数値を見つけます。たとえば、4、5、1、6、2、7、3、8 の 8 つの数字を入力した場合、最小の 4 つの数字は 1、2、3、4 になります。

  1. 入力: arr = [3,2,1]、k = 2
  2. 出力: [1,2] または [2,1]

制限:

0 <= k <= arr.length <= 10000 0 <= arr[i] <= 10000

"ヒープ"

大きなトップ ヒープを維持します。ヒープ内に k に対して十分な要素がない場合は、ヒープに要素を追加し続けます。ヒープ内の要素が k 以上になった場合は、ヒープの最上部の要素と新しく追加された要素を比較します。新しく追加された要素がヒープの最上部の要素よりも小さい場合は、ヒープの最上部の要素を削除し、新しく追加された要素をヒープに配置する必要があります。これにより、ヒープ内の要素は常に最小の k になります。

  1. 公共  int [] getLeastNumbers( int [] arr, int k) {
  2.     （arr.length == 0 || k == 0）の場合{
  3. 新しいint [0]を返します。
  4.     }
  5.     PriorityQueue<整数> キュー = 新しい PriorityQueue<>((num1, num2) -> num2 - num1);
  6.  for ( int num : arr ) {
  7.         キューサイズ() < kの場合
  8.             キューに数値を追加します。
  9.         }そうでない場合 (num < queue.peek()) {
  10.             キュー.ポーリング();
  11.             キューに数値を追加します。
  12.         }
  13.     }
  14.  int [] 結果 = 新しいint [k];
  15.  ( int i = 0; i < k; i++) {
  16.         結果[i] = queue.poll();
  17.     }
  18. 結果を返します。
  19.  }

「クイックソート」

クイックソートのプロセスを変更するだけで済みます。配列全体をソートするのではなく、ベンチマーク値と k の位置に基づいて、左セグメントと右セグメントのどちらをソートするかを決定できます。

  1. クラスソリューション{ 
  2.  
  3. 公共  int [] getLeastNumbers( int [] arr, int k) {
  4.         （arr.length == 0 || k == 0）の場合{
  5. 新しいint [0]を返します。
  6.         }
  7.  quickSort(arr, 0, arr.length - 1, k - 1) を返します。
  8.     } 
  9.  
  10. 公共  int [] クイックソート( int [] 数値, int  左、 int  右、 int k) {
  11. 整数 インデックス= sort(nums, left , right );
  12.         if (インデックス== k ) {
  13.  Arrays.copyOf(nums, k + 1) を返します。
  14.         }
  15.         //インデックスと kの位置に基づいて、左または右のセグメントをカットするかどうかを決定します
  16. 戻る  index > k の場合、quickSort(nums, left , index - 1, k) : quickSort(nums, index + 1, right , k);
  17.     } 
  18.  
  19. 公共  intソート( int [] a, int  左、 int  右） {
  20. 整数 キー= a[左];
  21.         （左<右）{
  22.             while (左<右&& a[右] >=キー) {
  23. 右- ;  
  24.             }
  25.             a[左] = a[右];
  26.             while (左<右&& a[左] <=キー) {
  27. 左++;
  28.             }
  29.             a[右] = a[左];
  30.         }
  31.         a[左] =キー;
  32. 戻る 左;
  33.     }
  34.  }

「数え順」

質問には 0 <= arr[i] <= 10000 という条件があり、これは配列内の要素が比較的集中していることを意味するため、カウントソートを使用してこの問題を解決できます。 arr[i] の最大値は 10000 なので、毎回 10001 の配列を直接開きます。

  1. 公共  int [] getLeastNumbers( int [] arr, int k) {
  2.     （arr.length == 0 || k == 0）の場合{
  3. 新しいint [0]を返します。
  4.     }
  5.  int [] countArray = 新しいint [10001];
  6.  for ( int num : arr ) {
  7.         countArray[num]++;
  8.     }
  9.  int [] 結果 = 新しいint [k];
  10. 整数 インデックス= 0;
  11.  ( int i = 0; i < countArray.length &&インデックス< k; i++) {
  12.         countArray[i] > 0 &&インデックス< k である間 {
  13.             countArray[i] --;  
  14.             結果[インデックス++] = i;
  15.         }
  16.     }
  17. 結果を返します。
  18.  }

マージソート

まず配列を 1 つの要素だけに分割し、分割した配列を結合します。結合時に行うべき主なことは、結合した配列が正しい順序になっていることを確認することです。結合が完了すると、配列全体が正しい順序になります。

  1. 公共 静的void mergeSort( int [] a, int  左、 int  右） {
  2.     // 配列を1つの要素のみを持つセグメントに分割します
  3.     if (左==右) {
  4. 戻る;
  5.     }
  6.  int中央 = (左+右) / 2;
  7.     mergeSort(a, left , mid);
  8.     mergeSort(a, 中央 + 1,右);
  9.     マージ(a、左、中央、右);
  10.  } 
  11.  
  12. 公共 静的voidマージ( int []a, int  左、 int中央、 int  右） {
  13.  int [] temp = 新しいint [右-左+ 1];
  14.  int i =左;
  15. 整数j = ミッド + 1;
  16. 整数k = 0;
  17.     (i <= 中央 && j <=右) の間 {
  18.         もし(a[i] < a[j])であれば{
  19.  temp [k++] = a[i++];
  20.         }それ以外{
  21.  temp [k++] = a[j++];
  22.         }
  23.     }
  24.     // 左の配列の残りの値をコピーします
  25.     (i <= 中間) {
  26.  temp [k++] = a[i++];
  27.     }
  28.     // 右側の配列の残りの値をコピーします
  29.     (j <=右) の間 {
  30.  temp [k++] = a[j++];
  31.     }
  32. 整数 インデックス= 0;
  33.     （左<=右）{
  34.         a[左++] = temp [インデックス++];
  35.     }
  36.  }

カウントソート

新しい配列が作成され、num[i]は元の配列に値iを持つ数値がnum[i]個あることを意味します。したがって、このアルゴリズムには大きな制限があり、配列要素の範囲が大きくないシナリオにのみ適しています。

  1. 公共 静的void countingSort( int [] a) {
  2. 整数 最大値= Integer.MIN_VALUE ;
  3.  for ( int数値: a ) {
  4.  max =整数。max ( max , num) ;
  5.     }
  6.  int [] count = 新しいint [ max + 1];
  7.  for ( int num : a ) {
  8.  [数値]++をカウントします。
  9.     }
  10. 整数 インデックス= 0;
  11.  ( int i = 0; i < count .length; i++) {
  12.         （カウント[i]> 0）{
  13.             a[インデックス++] = i;
  14. カウント[i] --;  
  15.         }
  16.     }
  17.  }

上記のアルゴリズムには実は欠陥があります。配列内の要素が 10000、10001、10002 の場合、サイズ 10003 の配列を作成する必要がありますが、これは非現実的です。したがって、マッピング関係num[i]を変更して、元の配列内のi+minの値の数がnum[i]であることを意味することができます。

上級バージョン

  1. 公共 静的void countingSort( int [] a) {
  2. 整数 最大値= Integer.MIN_VALUE ;
  3. 整数 最小値= Integer.MAX_VALUE ;
  4.  for ( int num : a ) {
  5.  max =整数。max ( max , num) ;
  6.  min =整数。min ( min , num) ;
  7.     }
  8.  int [] count = 新しいint [最大値-最小値+ 1];
  9.  for ( int num : a ) {
  10.  count [数値 -最小値]++;
  11.     }
  12. 整数 インデックス= 0;
  13.  ( int i = 0; i < count .length; i++) {
  14.         （カウント[i]> 0）{
  15.             a[インデックス++] = i + min ;
  16. カウント[i] --;  
  17.         }
  18.     }
  19.  }

「面接の過程では、配列の過半数を見つける問題によく遭遇しますが、カウントソートの考え方を使ってそれを解決することができます。」

基数ソート

「面接ではスナップショットやマージソートについてたくさん聞かれました。応用シナリオも豊富です。」基数ソートについては基本的に聞かれなかったので説明はしません。

バケットソート

「先ほど述べたカウンティング ソートと基数ソートは、バケット ソートの考え方を特別に表現したものと言えます。つまり、配列要素を比較する必要がないということです。」基本的には聞かれなかったので説明しませんでした。

さまざまなソートアルゴリズムの応用

面接でよく聞かれるトップ k の質問については、まず並べ替えてからトップ k の要素を見つけることができます。さまざまなソート アルゴリズムの効率は、次の図に示されています。「より効率的なアイデアは、ヒープ ソートとクイック ソートを使用することです。Top K 問題を問う方法は多数ありますが、上位 K 個の最大要素、上位 K 個の最小要素、上位 K 個の高頻度要素を見つけるなど、基本的なアイデアは同じです。」

この記事はWeChatのパブリックアカウント「Java Knowledge Hall」から転載したものです。以下のQRコードからフォローできます。この記事を転載する場合は、Java Knowledge Hall 公式アカウントまでご連絡ください。

<<:  自己教師あり学習の概要と3つの主要分野における現状

>>:  AIは採用に何をもたらすのでしょうか?

ブログ    
ブログ    

推薦する

Transformerを廃止すれば、完全な畳み込みネットワークでもE2E検出を実現できる。

研究者は最近、ターゲット検出のための Transformer の使用を熱心に研究していますが、この論...

絶賛されていたGPT-3が充電開始します！ネットユーザー：値段が高す​​ぎる。もう行っちゃった。

少し前に絶賛されたGPT-3を覚えていますか？招待されたユーザーのみがテスト・使用できるもので、史上...

Alibaba Cloudは、Llama2トレーニングの展開を全面的にサポートする最初の企業であり、企業が独自の大規模モデルを迅速に構築できるように支援します。

Llama2 はオープンソースであり、無料の商用利用をサポートしているため、オープンソースの大規模...

人工知能の時代では、機械学習とAIアルゴリズムが「80/20ルール」を変えるだろう

[[186517]]ハーバード・ビジネス・レビューは、機械学習と AI アルゴリズムの進歩により、私...

Python のデータクロール、分析、マイニング、機械学習、Python 分散コンピューティングに関するコンテンツ共有

01 データキャプチャ1. 背景調査1) robots.txt をチェックして、サイトのクロールにど...

...

マイクロソフト：新しいアルゴリズムにより Windows 11 の累積アップデートのサイズが 40% 削減

本日、Windows 11 システムは Patch Tuesday でリリースされた最初の累積的な更...

モノのインターネットにおける人工知能と機械学習の役割は何ですか?

人工知能 (AI) と機械学習 (ML) をモノのインターネット (IoT) システムに統合すること...

Excelが変わりました！ MicrosoftはPythonを搭載しているので、機械学習を直接行うことができます。

素晴らしいニュースです！ Microsoft が Excel に Python を導入しました。 E...

食品サービス機器業界の主な動向

[[442813]]画像ソース: https://pixabay.com/images/id-673...

...

...

空飛ぶ車の将来展望は？

空飛ぶ車というアイデアは何十年も私たちの想像力をかき立て、交通渋滞の上を飛ぶことができる未来のビジョ...

AI に適切なデータ戦略を構築するにはどうすればよいでしょうか?

適切なデータ戦略を使用して人工知能 (AI) を実装すると、データがシステムにシームレスに流れ込み、...

人工知能時代のセキュリティ専門職とは？

人工知能の時代におけるセキュリティ専門職は何かという問題は、徐々に人々が直面しなければならない問題に...