排序算法

1. 直接插入排序
   

public static void straightInsertSort(int[] arr,int len){
        int temp=0;
        int j=0;
        for (int i = 1; i <len ; i++) {
            if(arr[i]<arr[i-1]){
                temp=arr[i];
                for (j = i-1; j>=0&&temp<arr[j] ; j--) {
                    arr[j+1]=arr[j];//从后向前移动数组
                }
                arr[j+1]=temp;
            }
        }
        System.out.println("直接插入排序后数组" + Arrays.toString(arr));
    }

2.冒泡排序
冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。相同元素的前后顺序并没有改变，冒泡排序是一种稳定排序算法。

//冒泡排序
    public static void bubbleSort(int[] arr,int len){
        int temp=0;
        int compareRange=len-1;//冒泡排序中，参与比较的数字的边界。
        //冒泡排序主要是比较相邻两个数字的大小，以升序排列为例，如果前侧数字大于后侧数字，就进行交换，一直到比较边界。
        for (int i = 0; i <len ; i++) {//n个数使用冒泡排序，最多需要n趟完成排序。最外层循环用于控制排序趟数
            for (int j = 1; j <=compareRange ; j++) {
                if(arr[j-1]>arr[j]){
                    temp=arr[j-1];
                    arr[j-1]=arr[j];
                    arr[j]=temp;
                }
            }
            compareRange--;//每进行一趟排序，序列中最大数字就沉到底部，比较边界就向前移动一个位置。
        }
        System.out.println("排序后数组"+Arrays.toString(arr));
    }

3.快速排序
分治思想

int quicksort(vector<int> &v, int left, int right){
        if(left < right){
                int key = v[left];
                int low = left;
                int high = right;
                while(low < high){
                        while(low < high && v[high] > key){
                                high--;
                        }
                        v[low] = v[high];
                        while(low < high && v[low] < key){
                                low++;
                        }
                        v[high] = v[low];
                }
                v[low] = key;
                quicksort(v,left,low-1);
                quicksort(v,low+1,right);
        }
}