冒泡，選擇，插入排序算法

時間 2019-12-04

標籤冒泡選擇插入排序算法欄目應用數學简体版

原文原文鏈接

排序算法

排序也成排序算法(Sort Algorithm)，排序是將一組數據，依指定的順序進行排列的過程java

排序的分類算法

內部排序：指將須要處理的全部數據都加載到內部存儲器中進行排序數組

外部排序法：數據量過大，沒法所有加載到內存中，須要藉助外部存儲進行排序dom

度量一個程序(算法)執行時間的兩種方法函數

1.過後統計的方法性能

這種方法可行，可是有兩個問題，一是要想對設計的算法的運行性能進行評測，須要實際運行該程序：二是所得時間的統計量依賴於計算機的硬件，軟件等環境因素，這種方式，要在同一臺計算機的相同狀態下運行，才能比較那個算法速度更快測試

2.事前估算的方法設計

經過分析某個算法的時間複雜度來判斷那個算法更優code

算法的時間複雜度orm

時間頻度：一個算法花費的時間與算法中語句的執行次數成正比例，哪一個算法中語句執行次數多，他花費時間就多，一個算法中的語句執行次數稱爲語句頻度或時間頻度 . 記爲:T(n)

統計時間頻度時：隨着n的變大，常數項，低次項，係數能夠忽略

時間複雜度

1.通常狀況下，算法中的操做語句的重複執行次數是問題規模n的某個函數，用T(n)表示，如有某個輔助函數f(n)，使得當n趨近於無窮大時，T(n)/f(n)的極限值爲不等於零的常數，則稱f(n)是T(n)的同數量級函數。記做T(n)=O(f(n))，稱O(f(n))爲算法的漸進時間複雜度，簡稱時間複雜度

2.T(n)不一樣，但時間複雜度可能相同

3計算時間複雜度的方法

用常數1代替運行時間中的全部加法常數 T(n)=n^2+7n+6 => T(n)=n^2+7n+1
修改後的運行次數函數中，只保留最高階項 T(n)=n^2+7n+1 => T(n)=n^2
去除最高階項的係數 T(n)=n^2=> T(n)=n^2

常見的時間複雜度

1.常數階O(1) :不管代碼執行多少行，只要是沒有循環等複雜結構，那麼這個代碼的時間複雜度就都是O(1)

2.對數階O(log2n) ：

//說明：在while循環裏面，每次都將i乘以2，乘完以後，i距離n就愈來愈近了，假設循環x次以後，退出循環，也就是說2的x次方等於n，那麼x=log2n也就是說當循環log2n次之後，這個代碼就結束了。所以這個代碼的時間複雜度爲:O(log2n)
//若是a的x次方等於N（a>0，且a不等於1），那麼數x叫作以a爲底N的對數（logarithm），記做x=logaN。其中，a叫作對數的底數，N叫作真數
//這段代碼執行log2^1024次
public static void main(String[] args) {
      int count=0;
      int i=1;
      int n=1024;
      while(i<n) {
          i=i*2;
          count++;
      }
      //log2^1024=10
      System.out.println(count);//10
      
    }

3.線性階O(n) ：for循環代碼執行n遍，所以他消耗的時間是隨着n的變化而變化的

4線性對數階O(nlog2n) ：線性對數階O(nlogN)其實很是容易理解，將時間複雜度爲O(logn)的代碼循環N遍的話，那麼時間複雜度就是n*O(logN)

5.平方階O(n^2) :若是把O(n)的代碼在嵌套一遍，他的時間複雜度就是O(n^2),

//這段代碼其實就是嵌套了2層n循環，他的時間複雜度就是O(n*n)
for(x=1;i<=n;x++) {
     for(x=1;i<=n;x++) {
            j=i;
            j++;
        }
    }

6.立方階O(n^3) :至關於三層for循環

7.k次方階(n^K)

8.指數階O(2^n)

空間複雜度

相似於時間複雜度的討論，一個算法的空間複雜度定義爲該算法鎖耗費的存儲空間，他也是問題規模n的函數

冒泡排序

每一次進行排序都會肯定出一個最大值

package sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class BubbleSort {
    public static void main(String[] args) {
        //int arr[] = {3,9,-1,10,-2};
        //時間複雜度O(n^2)
        //測試冒泡排序的速度，要求排序80000個數字
        int[] arr = new int[80000];
        for(int i=0;i<arr.length;i++) {
            //每循環一次就添加一個元素
            arr[i]=(int)(Math.random()*80000);
        }
        Date data1 = new Date();
        System.out.println(data1);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateStr = sdf.format(data1);
        System.out.println("開始時間"+dateStr);
        System.out.println("排序進行中........");
        //對數組進行排序
        bubbleSort(arr);
        Date data2 = new Date();
        String dateStr2 = sdf.format(data2);
        System.out.println("開始時間"+dateStr2);
        System.out.println("排序結束");
        
    }
    public static void bubbleSort(int[] arr) {
        int temp = 0;//臨時變量
        boolean b = false;
        for(int i=0;i<arr.length-1;i++) {//一共須要進行arr.length-1次排序
            for(int j=0; j<arr.length-1-i;j++) {
                if(arr[j]>arr[j+1]) {
                    b=true;
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
            //System.out.println("第"+(i+1)+"次冒泡。。。。。");
            //System.out.println(Arrays.toString(arr));
            if(!b) {
                break;
            }else {
                b=false;//重置爲false，是由於已經有進行過排序
            }
        }
    }
}
//冒泡排序平均15秒

選擇排序

每次排序都肯定出一個最小值

package sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class SelectSort {
    public static void main(String[] args) {
        int[] arr = new int[80000];
        for(int i=0;i<arr.length;i++) {
            //每循環一次就添加一個元素
            arr[i]=(int)(Math.random()*80000);
        }
        Date data1 = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateStr = sdf.format(data1);
        System.out.println("開始時間"+dateStr);
        System.out.println("排序進行中........");
        selectSort(arr);
        Date data2 = new Date();
        String dateStr2 = sdf.format(data2);
        System.out.println("開始時間"+dateStr2);
        System.out.println("排序結束");
        //System.out.println(Arrays.toString(arr));
    }
    //選擇排序arr[0]=min
    public static void selectSort(int[] arr) {
        for(int i=0;i<arr.length-1;i++) {
            int minIndex = i;//假定最小索引爲0
            int min = arr[i];//假定最小值是arr數組的0索引
            for(int j = 1+i;j<arr.length;j++) {
                if(min > arr[j]) {
                    min=arr[j];//重置最小值
                    minIndex=j;//重置最小值得索引 
                }
            }
            if(minIndex !=i) {//表示minIndex沒有放生交換
                arr[minIndex] = arr[i+0];//101賦值給索引3
                arr[0+i] = min;//1賦值給索引0
            }
        }
    }
    
}
//選擇排序平均3秒

插入排序

插入式排序屬於內部排序法，是對於欲排序的元素以插入的方式找尋該元素的適當位置，已達到排序的目的

插入排序的思想：就是把一個數組當作兩張表，一張表存放有序元素，一張表存放無序元素，有序表初始元素爲arr[0],經過與arr[0]的比較來決定插入的位置，以此類推。

package sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class InsertSort {
    public static void main(String[] args) {
        int[] arr = new int[80000];
        for(int i=0;i<arr.length;i++) {
            //每循環一次就添加一個元素
            arr[i]=(int)(Math.random()*80000);
        }
        Date data1 = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateStr = sdf.format(data1);
        System.out.println("開始時間"+dateStr);
        System.out.println("排序進行中........");
        insertSort(arr);
        Date data2 = new Date();
        String dateStr2 = sdf.format(data2);
        System.out.println("開始時間"+dateStr2);
        System.out.println("排序結束");
        //int arr[] = {3,9,-1,10,-2};
    }
    
    public static void insertSort(int[] arr) {
        for(int i = 1;i < arr.length; i++) {
            int insertVal = arr[i];
            int insertIndex = i-1;//i-1的意思是要把插入的數與前一個數比較
            //insertIndex >=0 防止越界
            //insertVal < arr[insertIndex])
            while(insertIndex >=0 && insertVal < arr[insertIndex]) {
                arr[insertIndex+1] = arr[insertIndex];//日後移
                insertIndex--;//繼續與前面的數比較
            }
            if(insertIndex+1!=i) {
                arr[insertIndex+1] = insertVal;
            }
        }
    }
}
//平均時間5秒