データ構造とアルゴリズム[0-1]学習白道から（上級章）

免責事項：再現した場合 - 次のマイクロチャネルを追加してください457556886知識が共有されて知らせることができhttps://blog.csdn.net/wolf_love666/article/details/90815450

分類に基づいて：

時間の複雑さに応じて分類
安定性の分類によると、
サルを並べ替え、並べ替えなどの他のカクテルは、ソート眠ります。

一般的に使用されるアルゴリズム：
ここに画像を挿入説明

バブルソート、および最適化された4つのアルゴリズム
名が示唆するように、バブルソートを気泡として上昇する過程で、バブルソートの基本的な考え方は、（昇順と仮定して）一方向である：所定のn個のレコードについて、最初から記録が順次隣接する二つのレコードを比較し、現在のレコードが交換位置した後、記録の裏面の表面よりも大きく、比較転置を実行し、N個の最大記録ビットnの記録位置、および前者する起動時（N-1）比較の第二ラウンドを記録するステップと、プロセスは、残りの日付を記録するまで繰り返されます。

ベース：ループ用の2つ、すべての制御層、すべての内部データ交換のための制御の実行回数。

   //1-基础冒泡排序
    public static void bubbleSort_1(int [] intarr){
        //冒泡排序
        //先进行所有元素迭代遍历
        int count = 0;
        //由于两两比较，则肯定是有个数不需要比较的所以这里需要减去1
        for (int i = 0;i < intarr.length-1;i++){
            //比较其中的每一个元素element，由于冒泡排序是下沉的小数在前，
            大数在后，先下沉大数，
            则每次外部循环的次数正好是已经排序好的不需要再排序的,所以这里是需要减去已经排好序的，由于i=0开始，那么不需要自己相比较，所以j从1开始。
            for(int j = 1;j < intarr.length - i;j++){
                //如果当前的元素>之后比较的元素，则交换位置，
                将小的元素放至在当前的元素的位置
                if(intarr[j-1]>intarr[j]){
                    int temp = intarr[j-1];
                    intarr[j-1] = intarr[j];
                    intarr[j] = temp;

                }
                count++;
                //假设数组2,3,1
                //则arr[0]=2与arr[1]，比较，小于则通过，与arr[2]比较，大于则交换，arr[0]=1,arr[2]=3.则经历过第一次循环以后，{1,3,2}
                //则arr[1]=3与arr[1]，比较，等于则通过，与arr[2]比较，大于则交换，arr[1]=2,arr[2]=3，则经历过第二次循环以后，{1,2,3}
                //第三次循环，arr[2]=2与arr[1],比较，等于则通过，与arr[2]比较，小于则通过，所以最终顺序为{1,2,3}
            }
            System.out.println("bubbleSort_1::"+Arrays.toString(intarr));
        }
        System.out.println("bubbleSort_1比较次数："+count);
    }

ここに画像を挿入説明

最良のケースは、それ自体ソートするとき発注される配列があることが必要である（N-1）の比較、データ交換は、時間計算量はO（N）で
ソートされる最悪の場合、即ち表は、逆の順序の場合であり、この時間は、回数を比較する必要がある：1 + 2 + 3 + ... +（N-1）= N（N-1）/ 2 回、記録動作の他の順序のため、合計時間そう複雑さはO（N2）であります

最適化1：既にソートすることなく並べ替えのために、標識されたソート、比較は、（逆が完全な場合は、その後上記区別できない基づいてソート）過剰減らすソート

//2-增加标记冒泡排序
    public static void bubbleSort_2(int [] intarr){
        //根据上面的冒泡排序我们知道其中我们每次遍历的时候都进行了所有的元素的比较
        //那么我们可以增加标记，减少不必要的重复比较
        int k = intarr.length;
        boolean sorted = true;
        int count = 0;
        //循环遍历
        while(sorted){
            //首次进入的时候我们需要设置为未排序过
            sorted = false;
            //交换一遍顺序
            for (int i = 1;i < k ;i++){
                if (intarr[i-1] > intarr[i]){
                    int temp = intarr[i-1];
                    intarr[i-1] = intarr[i];
                    intarr[i] = temp;
                    sorted = true;
                }
                count++;
            }
            System.out.println("bubbleSort_2::"+Arrays.toString(intarr));
            k--;
        }
        System.out.println("bubbleSort_2比较次数："+count);
    }

最適化2：上記に言えば、内側ループに基づいて、各ランダム位置更新をソートコンパレータ（上記の最適化も可能違いないと仮定が、無秩序状態である減少しているいくつかの最後の層のスイッチング素子であり、横断します後者が順序付けられている場合は1に、より良い最適化であり、例えば1,5,4,8,9,42,5,7,7,8,9,10,11,12 {}）

 public static void bubbleSort_3(int [] intarr) {
    //基于上面讲每次无序遍历的内层循环更新为最后一层交换元素的位置，
    减少一些已经排序好的比较、、
    假设我们前面大部分是无序的，后面是有序的
//(1，2，5，7，4，3，6，8，9，10)这种场景，
则我们可以记录最后一次的交换位置，
下一次排序从第一个比较到上次记录的位置就可以了
        //所以基于以上的排序算法更改如下,初始化尾边界
        int tailBorder = intarr.length;
        int count = 0;
        int length = 0;
        while(tailBorder > 0){//尾边界排序未结束
            //遍历两两比较和交换位置
            length = tailBorder;
            tailBorder = 0;
            for (int i = 1;i < length;i++) {
                if (intarr[i-1] > intarr[i]){
                    int temp = intarr[i-1];
                    intarr[i-1] = intarr[i];
                    intarr[i] = temp;
                    tailBorder = i;
                }
                //假设已经排序好了m个，后面n个待排序

                count++;
            }

            System.out.println("bubbleSort_3::"+Arrays.toString(intarr));

        }

        System.out.println("bubbleSort_3比较次数："+count);
    }

比較の基準91倍の数、比較の最適化46、比較の数2 37回、比較の16倍の数の最適化3の最適化の数

最適化3：カクテルソート実装アイデア：アウターループのすべての要素は、内層2つの総論理セット、前後比較の第二セット、同様の比較振り子、右から左へ、左から右への論理比較の最初のセット。欠点は、コードの増加は、該当シーンが最も整然とした状況であるということです。

 //鸡尾酒的排序实现
    public static void bubbleSort_4(int [] intarr) {
        //外层循环所有元素
        int count = 0;
        boolean sorted = false;//初始是没有排序
        for (int i = 0; i < intarr.length/2;i++){
            //left->right比较
            System.out.println("bubbleSort_4:left->right 比较前:"+Arrays.toString(intarr));
            for (int j = i;j < intarr.length - 1 - i;j++){
                if (intarr[j] > intarr [j+1]){
                    int temp = intarr[j];
                    intarr[j] = intarr[j+1];
                    intarr[j+1] = temp;
                    sorted = true;
                    count++;
                }
            }

            System.out.println("bubbleSort_4:left->right 比较后:"+Arrays.toString(intarr));
            //right->left比较

            System.out.println("bubbleSort_4:right->left 比较前:"+Arrays.toString(intarr));
            for (int j = intarr.length - 1 - i;j > i;j--){
                if (intarr[j-1] > intarr [j]){
                    int temp = intarr[j-1];
                    intarr[j-1] = intarr[j];
                    intarr[j] = temp;
                    sorted = true;
                    count++;
                }
            }
            //如果是排序完成或者排序好的则退出

            System.out.println("bubbleSort_4:right->left 比较后:"+Arrays.toString(intarr));
            if (sorted == false){
                break;
            }
        }

        System.out.println("bubbleSort_4比较次数："+count);
    }

ここに画像を挿入説明

ソートカウント
アプリケーションシナリオ：列要素の数が整数倍である場合、列の数は、最大値と最小ギャップでない場合。

バケットソート

列の最大値と最小数を求めて、演算量は、Nであります

空の樽を作成し、計算はnは

各バケットに割り当てられた元の数列の要素を、計算量はnが

各内部ソートパス要素の比較的均一な分布、n個のすべてのバケット計算の和

ソーティング順序の出力は、演算量は、Nであります

クイックソート・
ヒープソート
 ソートマージ
 バイナリサーチ
 線形探索
 第1の深さを
 幅優先
 ダイクストラ
 動的プログラミング
 ナイーブベイズ

データ構造とアルゴリズム[0-1]学習白道から（上級章）

おすすめ