常見排序算法及其實現(Binary，Insert、Select、Quick、Bubble.etc.Sort)

時間  2019-11-06
標籤 常見 排序算法 及其 實現 binary insert select quick bubble.etc.sort bubble sort 欄目 SQL 简体版
原文   原文鏈接

常見排序算法及其實現

說明

若是有幸能看到java

  • 一、本文中的代碼是參考《Java編程思想》、某培訓機構。
  • 二、文中的代碼放Github了，有興趣的能夠看看，點個star鼓勵下我。
  • 三、代碼在Sublime中敲的，坑爹的GBK，註釋了不少中文，一轉碼不能用了！！！
  • 四、重點在思想，而不是實現 。再次推薦《Java編程思想》
  • 五、若有拼寫錯誤，還請諒解。本文只爲本身複習使用，最後放了兩個收藏很是有水準的文章連接。

數據結構之排序

排序：假設含有n個記錄的序列{R1,R2,R3..,Rn}，其中的關鍵字序列爲{K1,K2,K3...,Kn}。將這些記錄從新排序爲{Ri1,Ri2,Ri3,Rin} ,使得相應的關鍵字知足Ki1<=Ki2<=..<=Kim,這樣的一種操做被稱爲排序。git

一般來講，排序的目的是快速查找github

衡量排序算法的優點：算法

  • 一、時間複雜度：分析關鍵字的比較次數和記錄的移動次數。
  • 二、空間複雜度：分析排序算法中須要多少輔助內存。
  • 三、若兩個記錄A和B的關鍵字相等，但排序後A、B、的前後次序保持不變，則稱爲這種排序算法是穩定的。

排序算法分類：內部排序和外部排序編程

  • 內部排序：整個排序過程不須要藉助於外部存儲器(如此攀等)，整個排序在內存中完成。
  • 外部排序：參與排序的數據很是多，數據量很是大，計算機沒法把整個排序過程放在內存中完成，必須藉助於外部存儲器，外部排序最多見的是多路歸併排序，能夠認爲外部排序由屢次內部所組成。

經常使用的內部排序api

  • 選擇排序數組

    • 直接選擇排序
    • 堆排序

  • 交換排序數據結構

    • 冒泡排序
    • 快速排序

  • 插入排序性能

    • 直接插入、折半插入
  • 歸併排序
  • 桶式排序
  • 基數排序

選擇排序

基本原理：
將待排序的元素分爲已排序和未排序，依次將爲排序的元素中最小的元素放入已排序的組中，學習

直接排序簡單直觀，但性能略差：堆排序是一種較爲搞笑的選擇排序。但實現起來略爲複雜。

代碼實現：

import java.util.Arrays.*;
//選擇排序,
public class SelectSort{
    public static void selectSort(int[] data) {

        int arrayLength = data.length;
        for (int i = 0; i < arrayLength - 1 ; i++ ) {
            for (int j= i +1; j < arrayLength; j++ ) {
                if (data[i] > data[j]) {
                    swap(data,i,j);
                }
            }
        }
        System.out.println("排序後 " + java.util.Arrays.toString(data));


    }

  //第一種經過臨時變量來完成交換
  //注意這裏能夠用另一中一種方式
    static void swap(int[] data,int i,int j) {
            int tmp = data[i];
            data[i] = data[j];
            data[j] = tmp;
        }


    public static void main(String[] args) {
        int[] data = {3,4,2,6,8,1,9};
        selectSort(data);
    }
}

改進版的選擇排序：

//選擇排序算法
//選擇排序算法
//一、主要思想就是每次假設一個最小的值
public class SelectSort1 {
    public static void selectSort1(int[] data) {
        int arraylength = data.length;
        for (int i = 0; i < arraylength - 1; i++ ) {
            int minIndex = i;      //每次假設一個最小值下標
            for (int j = i + 1; j < arraylength ; j++ ) {
                if (data[minIndex] > data[j]) {
                minIndex = j;
                }
            }
            //判斷須要交換的下標是否爲本身
            if (minIndex != i) {
                 data[minIndex] = data[minIndex] + data[i];
                 date[i] = date[minIndex] - data[i];
                 data[minIndex] = data[minIndex] - data[i];
            }

        }
        //輸出結果
        for (int d :data ) {
            System.out.println("排序以後：" + d);
        }
    }

    public static void main(String[] args) {
        int[] data = {3,4,2,6,8,1,9};
        selectSort1(data);
    }
}

直接選擇排序效率分析

算法的時間效率：不管初始化狀態如何，在第i趟排序中選擇最小的元素，須要n-1次比較

算法的空間效率：空間效率較高，只須要一個附加程序單元用於交換，其空間效率爲O(1)

算法的穩定性：不穩定

堆排序

資料和代碼來自這家，有一種感受，年代越遠，越重視基礎。如今的培訓呢？

堆排序就是把最大堆堆頂的最大數取出，將剩餘的堆繼續調整爲最大堆，再次將堆頂的最大數取出，這個過程持續到剩餘數只有一個時結束

  • 最大堆調整（Max-Heapify）：將堆的末端子節點做調整，使得子節點永遠小於父節點
  • 建立最大堆（Build-Max-Heap）：將堆全部數據從新排序，使其成爲最大堆
  • 堆排序（Heap-Sort）：移除位在第一個數據的根節點，並作最大堆調整的遞歸運算

這個有點難啊，下一個。回來再來看。

冒泡排序

相鄰兩元素進行比較，若有須要則進行交換，每完成一次循環就將最大元素排在前面(從小到大排序)下一次循環是將其餘的數進行相似的比較。

代碼實現：

//冒泡排序
public class BubbleSort {
    static void sort(int[] data) {
        int len = data.length;
        for (int i = 0; i < len - 1; i++ ) {
            for (int j = 0 ; j < len - 1 - i; j++ ) {
                if (data[j] > data[j + 1]) {
                    swap(data,j,j+1);
                }
            }
        }

    }
    static void swap(int[] data,int i,int j) {
        int tmp = data[i];
        data[i] = data[j];
        data[j] = tmp;
    }

    public static void main(String[] args) {
        int[] data = {4,2,6,8,2,1,0};
        sort(data);
        for(int d : data) {
            System.out.print("->" + d);
        }
    }
}

冒泡排序效率分析：

  • 算法的時間效率：從冒泡排序的算法能夠看出，若待排序的元素爲正序，則只需進行一趟排序，比較次數爲n-1次，移動元素次數爲0；若待排序的元素爲逆序，則須要進行n-1趟排序.
  • 算法的空間效率：空間效率很高，只須要一個附加程序單元用於交換，其空間效率爲O(1)
  • 算法的穩定性：穩定

快速排序

快速排序(Quick Sorting)基本思想是：任取待排序序列中的某個元素爲界點，經過一次劃分，將待排序元素分爲左右兩個子序列，左子序列元素的排列序列均小於界點元素的排序碼，右子序列的排序碼則大於或等於界點的排序碼，而後分別對兩個字序列繼續進行劃分，直至每個序列只有一個元素爲止。

必定要認真啊，認真啊，認真啊！！！
代碼實現：

//快速排序
public class QuickSort {
    private static void swap(int[] data,int i,int j) {
        int tmp = data[i];
        data[i] = data[j];
        data[j] = tmp;
    }

    private static void subSort(int[] data,int start,int end) {
        if (start < end) {
         int base = data[end];

         int i = start;
         int j = end + 1;

         while(true) {
             while(i < end && data[++i] <= base) ;
             while(j > start && data[--j] >= base);
             if (i > j) {
                 swap(data,i,j);
             }else {
                 break;
            }
        }

            swap(data, start, j);
            subSort(data, start, j - 1);
            subSort(data, j + 1, end);
        }

    }
    public static void quickSort(int[] data) {
        subSort(data,0,data.length - 1);
    }

    public static void main(String[] args) {
        int[] data = {9,5,6,88};
        quickSort(data);
        System.out.print(java.util.Arrays.toString(data));
    }
}

插入排序

基本思想：每次將一個待排序的元素，按其關鍵字的大小插入到前面已經排好序的子序的合適位置，直到所有記錄插入完成。

* 插入算法.
* 1,從後向前找到合適的位置插入
* 基本思想：每步將一個待排序的記錄，按其順序碼大小插入到前面已經排好的子序列的合適位置
* 直到所有插入爲止
*/
public class InsertSort {
   public static void main(String[] args) {
       //待排序的數列
       int[] nums = {43, 23, 64, 24, 34, 78, 32};
       //控制比較的輪數
       for (int i = 1; i < nums.length; i++) {
           //記錄操做數
           int temp = nums[i];
           int j = 0;
           for (j = i - 1; j >= 0; j--) {
               //後一個和前一個比較，若是前面的大，則把前面的賦值到後面。
               if (nums[j] > temp) {
                   nums[j+1] = nums[j];
               } else {
                   break;
               }
           }
           if (nums[j + 1] != temp) {
               nums[j + 1] = temp;
           }
       }
       //輸出結果
       for(int n : nums) {
           System.out.println(n);
       }
   }
}

直接插入排序：

直接插入排序 的基本思想：把n個待排序的元素堪稱爲一個有序表和無序表，開始時有序表中只包含一個元素，無序表中有n-1個元素，排序過程當中每次從無序表中取出第一個元素的排序碼進行比較，將它插入到有序表中的適當位置，使之成爲新的有序表。

代碼實現：

//直接插入排序
public class InsertSort {
    public static void insertSort(int[] data) {
        int arrayLength = data.length;
        for (int i = 1; i < arrayLength; i++) {
            int tmp = data[i];

            if (data[i] < data[i -1]) {
                int j = i - 1;
                for (;j >=0 && data[j] > tmp; j-- ) {
                    data[j + 1] = data[j];
                }
                data[j + 1] = tmp;
            }

        }
    }
    public static void main(String[] args) {
        int[] data = {5,2,6,9};
        insertSort(data);
        for (int d :data ) {
            System.out.print(" " + d);

        }
    }
}

折半插入排序

  • 折半插入排序是對直接插入排序的簡單改進。
  • 此處介紹的折半插入，其實就是經過不斷地折半來快速肯定第i個元素的插入位置，這其實是一種查找算法：折半查找。Java的Arrays類裏的binarySearch()方法，就是折半查找的實現，用於從指定數組中查找指定元素，前提是該數組已經處於有序狀態。
  • 與直接插入排序的效果相同，只是更快了一些，由於折半插入排序能夠更快地肯定第i個元素的插入位置

代碼實現：

//折半插入排序
public class BinaryInsertSort{
    public static void binaryInsertSort(int[] data) {
        int len = data.length;
        for (int i = 1; i < len; i++) {
            int tmp = data[i];
            int low = 0;
            int high = i - 1;
            while(low <= high) {
                int mid = (low + high) / 2;
                if (tmp > data[mid]) {
                    low = mid + 1;
                }
                else {
                    high = mid -1;
                }

            }for (int j = i;j > low ; j-- ) {
                data[j] = data[j - 1 ];
            }
            data[low] = tmp;
        }
    }

    public static void main(String[] args) {
        int[] data = {5,2,7,3,9};
        binaryInsertSort(data);
        for (int d : data) {
            System.out.print(" " + d);
        }
    }
}

/**
 * Created by guo on 2018/2/2.
 * 二分查找法(折半查找)：前提是在已經排好序的數組中，經過將待查找的元素
 * 與中間索引值對應的元素進行比較，若大於中間索引值對應的元素，去右半邊查找，
 * 不然，去左邊查找。依次類推。直到找到位置；找不到返回一個負數
 */
public class BinarySearchSort {
    public static void main(String[] args) {
        //必須保證數列是有序的
        int[] nums = {12, 32, 55, 67, 87, 98};
        int i = binarySearch(nums, 87);
        System.out.println("查找數的下標爲：" + i);   //輸出下標爲4
    }

    /**
     * 二分查找算法
     *
     * @param nums
     * @param key
     * @return
     */
    public static int binarySearch(int[] nums, int key) {
        int start = 0;             //開始下標
        int end = nums.length - 1; //結束下標
        while (start <= end) {     //開始位置不能穿過結束位置 --start-->|<--end--
            int middle = (start + end) / 2;
            // 若是查找的key比中間的大，則去掉左邊的值
            if (key > nums[middle]) {
                start = middle + 1;
             //若是查找的key比中間的小，則去掉右邊的。
            } else if (key < nums[middle]) {
                end = middle - 1;             //結束位置須要向前移一位。
            } else {
                return middle;
            }
        }
        //找不到則返回-1
        return -1;
    }
}

先到這裏吧，後續還得多敲幾遍，須要學習的太多了，gogogo。

給你們放兩個連接，GitHub、GitHub。裏面收集的文章很是有水準，點進去不會失望的。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程