常用的排序算法

1. 冒泡排序
   设有n个整数需要由小到大排序：
   缺点：效率低
   原理：循环n次每次选出最大的一个数
   时间复杂度为O(n2)

public class BubbleSort {
    public static void main(String[] args){
        int[] a={3,1,6,2,5};
        for(int i=4;i>0;i--){
            for (int j=0;j<i;j++){
                if(a[j]>a[j+1]){
                    int temp;
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
        for (int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
    }
}

2. 选择排序
   冒泡排序的思想就是不断的再交换，通过交换完成最终的排序。
   而选择排序的基本思想是每一趟在
   n-i+1(i=1,2,3,…,n-1)个记录中选取关键字最小的记录作为有序序列的第i记录
   时间复杂度为O（n2）

public class SelectSort {
    public static void main(String[] args){
        int[] a={3,1,6,2,5};
        for (int i=0;i<=4;i++){
            //假设第I一个数据是最小的
            //记录这个最小元素的下标
            int min=i;
            for (int j=i+1;j<=4;j++){
                if (a[min]>a[j]){
                    min=j;
                }
            }
            if (min!=i){
                int temp;
                temp=a[i];
                a[i]=a[min];
                a[min]=temp;
            }
        }
        for (int i=0;i<=4;i++){
            System.out.println(a[i]);
        }
    }
}

3. 直接插入排序
   直接插入的算法基本思想是：仅有一个元素的序列总是有序的，因此，对n个记录的序列，可从第二个元素开始直接到第n个元素，逐个向有序序列中执行插入操作，从而得到n个元素按关键字有序的序列。一般来说，在含有j-1个元素的有序序列中插入一个元素的方法是：从第j-1个元素开始依次向前搜索应当插入的位置，并且在搜索插入位置的同时可以后移元素，这样当找到适当的位置时，即可插入元素。
   通俗的说就是一个无序的数组，或者一段需要排序的序列，我们通常用第一个元素作为参考值，从第二个元素开始和这个参考值进行比较，比这个参考值大的时候放在这个参考值的后面，比这个参考值小的时候在和这个参考值的前一位进行比较，当比较至适当位置进行插入。
   时间复杂度为O（n2）

public class InsertSortTest {
    public static void main(String[] s) {
        int[] a = {3,1,6,2,5};
        insertSort(a,0,a.length);
         for(int n : a){
                System.out.print(n+" ");
            }
    }
public void insertSort(Object[] r,int low,int high){
  for(int i = low +1;i<=high;i++){ //小于时，需要将r[i]插入有序列表
    if(r[i] < r[i-1]){
      Object temp = r[i];
      r[i]  = r[i-1];
      int j=i-2;
      for(;j>=low&&temp < r[j];j++){
      r[j+1] = r[j];//记录后移
      }
      r[j+1] = temp;//插入到正确位置
    }
  }
}

4. 快速排序
   快速排序的基本思想：通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序的目的。
   时间复杂度O（nlogn）

package com.cssl;

import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        int[] arrays = {3, 4, 6, 1, 8, 2, 5, 10, 7, 9};
        quickSort(arrays,0,arrays.length-1);
        System.out.println(Arrays.toString(arrays));

    }

    /**
     * 快速排序
     */

    public static void quickSort(int[] arr, int left, int right) {
        //声明一个变量来存储准基数
        int pivot;
        if (left < right) {
            //从小到大
            pivot =partinton(arr,left,right);
            System.out.println(pivot);
            //一直递归处理左边的一堆数
            quickSort(arr,left,pivot-1);
            //一直递归处理右边的一堆数
            quickSort(arr,pivot+1,right);
        }

    }

    /**
     * 分片排序
     */

    private static int partinton(int[] arr, int left, int rigth) {
        //取一个参照数,获取数组中的第一个值
        //数字中的3
        int key = arr[left];
        while (left < rigth) {
            //第一次右边先走，右边往左边一步一步移动
            while (left < rigth && arr[rigth] >= key) {
                //右边向左一步
                rigth--;
            }
            //交换位置
            arr[left] = arr[rigth];
            //左边往右边走
            while (left < rigth && arr[left] <= key) {
                left++;
            }
            //交换位置
            arr[rigth] = arr[left];
        }
        //交换位置
        arr[left] = key;
        //返回左边的数
        return left;
    }

}