在android中會經常使用一些演算法來實現一些複雜的邏輯;
在這片博文中主要介紹五種演算法:

    1.選擇排序;
    2.插入排序;
    3.快速排序;
    4.合併排序;
    5.堆排序;

在看下面之前,需要注意:有的演算法語言表述比較乏力,在看下面博文時候要注意力在程式碼之上以下程式碼親測可用;

1.選擇排序

從陣列一端選擇一個數組中的一個元素,通過比較對比取出最小值(或者最大值)放在array的左邊(右邊 這裡主要視遍歷的開始為左還是右);逐個遍歷;
下面看程式碼:

 /**選擇排序
 *遍歷陣列  然後每次遍歷到一個元素之後  繼續遍歷該元素之後的所有元素 然後找         到最小的元素 和其換位置*/
 

    public static int[] select(int[] array){
        for (int i = 0; i < array.length; i++) {
            int minPos = i;
            for (int j = i + 1; j < array.length; j++) {
                if (array[j] < array[minPos]){
                    minPos = j;
                }
            }


            if
 
 (array[i] > array[minPos]){
                int temp = array[i];
                array[i] = array[minPos];
                array[minPos] = temp;
            }

        }
        return array;

    }

2.插入排序

同樣逐個遍歷陣列,每次兩兩比較,排列所遍歷元素及其之前的元素;遍歷完成,排序亦完成;

    /***插入排序
     *相當於  從0開始一直++  然後一直排列索引跟之前的元素
     * */
 

    public static int[] insert(int[] array){
        for (int i = 1; i < array.length; i++) {
            int temp = array[i];
            for (int j = i - 1; j >= 0 ; j--) {
                if (array[j] > temp ){
                    array[j + 1] = array[j];
                    array[j] = temp;
                }

            }

        }
        return array;
    }

3.快速排序

下面來看快速排序;選擇一個元素(一般取array的第一個元素),然後作為目標元素,將array中比目標元素小的放在目標元素左邊,比目標元素大的放在目標元素右邊;
然後繼續用相同方式排列左右兩邊的array; 下面來看程式碼:

/**快速排序
     * 在快排中要設定分水嶺 就是隨機一個元素  然後比他小的放置到其左邊 比其大的在有邊 迴圈往復
     * */
    public static int[] quick(int[] array){

        int length = array.length - 1;

        sortQuick(array,0,length);



        return array;
    }

    private static void sortQuick(int[] array, int low, int length) {
        if(low < length){
            int div = firstRun(array, low, length);
            sortQuick(array,0,div - 1);
            sortQuick(array,div + 1,length);
        }
    }

    private static int firstRun(int[] array, int low, int length) {
        int base = array[low];

        while (low < length){
            while (array[length] > base){
                length--;
            }
            swrap(array,low,length);
            while (array[low] < base){
                low++;
            }
            swrap(array,low,length);
        }
        return low;
    }

    private static void swrap(int[] array, int low, int length) {
        int temp = array[length];
        array[length] = array[low];
        array[low] = temp;
        //return array;
    }

4.合併排序

合併排序就是將陣列拆分,然後比較多的再用插入排序的方式實現排序;用於處理元素或者較為複雜的情況;分而治之,合而為一;

 /**合併排序
     * 一直在分割
     * 然後 兩部分 一直分割  然後一直遞迴*/
    public static int[] mesh(int[] array){
        int length = array.length - 1 ;
        int[] mysort = mysort(array, 0, length);
        return mysort;

    }

    private static int[] mysort(int[] array, int low, int length) {
        int mid = (length + low)/2;
        if (low < length){
            mysort(array,low,mid);
            mysort(array,mid + 1,length);
            merge(array,low,mid,length);
        }
        return array;

    }

    private static void merge(int[] array, int low, int mid, int length) {
        int[] temp = new int[length - low + 1];

        int i = low;
        int j = mid + 1;
        int n = 0;
        while (i <= mid && j <= length){
            if (array[i] > array[j]){
                temp[n++] = array[j++];
            }else {
                temp[n++] = array[i++];
            }
        }

        while (i <= mid){
            temp[n++] = array[i++];
        }


        while (j <= length){
            temp[n++] = array[j++];
        }


        //合併的邏輯  賦值給array

        for (int k = 0; k < temp.length; k++) {
            array[low + k] = temp[k];
        }


    }

5.堆排序

首先介紹下堆:堆就是一個具備任何根元素大於(或者小於)左右孩子的完全的二叉樹
堆排序其實就是一直構建大頂堆或者小頂堆,然後把堆頂和最後的元素調換,然後排除堆頂,重構其他元素為頂堆,再次替換頂元素,再替換,這麼一個迴圈往復的過程;
ok~ 下面看程式碼:

/**
     * 堆演算法  大頂堆 小頂堆
     * 每次取堆定 然後放入陣列 重構堆   再取再重構
     * */
    public static int[] heap(int[] array){
        int length = array.length - 1;
        for (int i = 0; i < length; i++) {
            buildHeap(array,length - i);
            swapHeap(array,0,length - i);
        }


        return array;
    }

    private static void swapHeap(int[] array, int a, int b) {
        int temp = array[b];
        array[b] = array[a];
        array[a] = temp;

    }

    private static void buildHeap(int[] array, int lastIndex) {
        //獲取左孩子和右孩子
        int pos = (lastIndex - 1)/2;
        for (int i = pos; i >= 0; i--) {
            int childL = i * 2 + 1;
            int childR = i * 2 + 2;
            int maxIndex = childL;
            if (childR <= lastIndex){
                //有右孩子
                if (array[childL] < array[childR]){
                    maxIndex ++;
                }
            }else if (childL <= lastIndex){
                //有左孩子
            }

            if (array[i] < array[maxIndex]){
                swrap(array,i,maxIndex);
            }
        }


    }

感謝閱讀 期待意見