八大排序算法 -笔记

1、冒泡排序
        基本介绍：冒泡排序是一种交换排序
        基本思想：（假定从小到大的顺序）从第一个元素开始，相邻两个数据进行比较，将小的值放在左边。第一轮：从第一个元素开始，和与其相邻的后一个元素进行比较，
　　　　　　　　若后一个比前一个小，则交换位置，否则不变，然后两个索引都向后移动一位，继续判断至最后一组数据，第二轮：从第二个元素出发，继续重复上述进行比较、换位，
　　　　　　　　再进行下一轮比较，直到最后一轮结束。
　　　　　　　　　　　　　　　　
        时间复杂度：O (n2), 通过测试，长度为 80000 的数组，数组中的元素从 0-800000 随机赋值，运行时间为 6s；
    代码实现：   
     

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

 

 

2、简单选择排序
        基本介绍： 选择排序也属于内部排序；与堆排序共为选择排序
        基本思想： （也是假定从小到大的顺序） 先设定第一个元素为最小，让其后边的每个元素都与其判断，保存最小的数据和最小数据的索引位置，
　　　　　　　　在一轮判断后将最小值与第一个元素做替换，再设定第二个元素为当前最小值，继续判断，直到最后一组结束。
　　　　　　　　
        时间复杂度：O (n2), 通过测试，长度为 80000 的数组，数组中的元素从 0-800000 随机赋值，运行时间不到 1s;
    代码实现：
   

public static void select2(int[] arr) { // 80000 : 不到一秒 // 800000 : 一分钟    int minIndex = 0;    int min = arr[minIndex];    for(int i = 0; i < arr.length - 1; i++) {     for(int j = i + 1; j < arr.length;j++) {       if(arr[j] < min) {         min = arr[j];         minIndex = j;       }     }     if(minIndex != i) {       arr[minIndex] = arr[i];       arr[i] = min;     }    }  }

 

 
3、简单插入排序
        基本介绍：插入排序也属于内部排序；与希尔排序同为插入排序
        基本思路：（小 -> 大）先假定有两个数组，无序数组和有序数组，将无序数组中的一个元素与有序中的元素一一比较，找出合适的位置后插入进去。   
　　　　　　　　　　　
  　   时间复杂度： O (n2), 通过测试，长度为 80000 的数组，数组中的元素从 0-800000 随机赋值，运行时间不到 1s;
    代码实现 ：           
      

public static void insert(int[] arr) {      for(int i = 1; i < arr.length ; i++) {     int insertIndex = i - 1;     int insertVal = arr[i];     while(insertIndex >= 0 && insertVal < arr[insertIndex]) { //找插入的地方       arr[insertIndex + 1] = arr[insertIndex]; //逐个往后移一位，       insertIndex--;     }     arr[insertIndex + 1] = insertVal; //找到了小的数放的位置    }  }

 

          
4、希尔排序 （插入排序）
　　基本介绍：希尔排序是插入排序的一种。
       基本思路： 希尔排序是将一个数组先分成长度 / 2 组数据，同一组数据相邻间距为长度 / 2，根据交换法或位移法将数据进行交换，交换完后再将数据分为间距 / 2 组数据，
　　　　　　　　每一组之间继续进行比较交换，直到间距为 0，即为结束。　　　　　　
　　　　　　　　　　
        时间复杂度：O（n2） 通过测试，  交换法 8 万数据 4s；    位移法 80 万数据 不到 1s   800 万数据 2s，   显然希尔位移法排序效率更高。
代码实现：
      

//交换法  public static void shellSort(int[] arr) { // 八万 ： 4s    int count = 0;    int temp = 0;    for(int gsp = arr.length / 2; gsp > 0; gsp /= 2) {     for(int i = gsp; i < arr.length; i++) {       for(int j = i - gsp; j > 0; j -= gsp) {         if(arr[j] > arr[j + gsp]) {          temp = arr[j];          arr[j] = arr[j + gsp];          arr[j + gsp] = temp;         }       }     }    }  } //移位法  public static void shellSort2(int[] arr) { // 8000000 两秒    for(int gap = arr.length / 2; gap > 0; gap /= 2) {     for(int i = gap; i < arr.length; i++) {       int j = i;       int temp = arr[j];       while(j - gap > 0 && temp < arr[j - gap]) {         arr[j] = arr[j - gap];         j -= gap;       }       arr[j] = temp;     }    }  }

 

 
5、快速排序
    基本介绍：快速排序是对冒泡排序的一种改进。
    基本思想：通过一趟排序，将数据分为以某个值大小为界限的两部分，再将这两部分值分别以以上方式继续分组，直到数据变为有序。此方法可以用递归调用，用空间换时间，
           　　  大大提高了排序所耗费的时间。
 　　　　　　
    时间复杂度：O (n*logn)  80 万数据 不到 1s   800 万数据 2s 
        代码实现：
       

public static void quick(int[] arr,int lift,int right) {       if(lift < right) {     int l = lift;     int r = right;     int key = arr[l];     while(l < r) {       while(l < r && arr[r] >= key) {         r -= 1;       }       arr[l] .........

本