排序算法 常见排序算法的实现

排序->插入排序

1.直接插入排序

 public static void insertsort(int[] arr) {
        int i, j;
        for (i = 1; i < arr.length; i++) {
            if (arr[i] < arr[i - 1]) {
                int temp = arr[i];
                //遍历i前的区域，将比temp值大的向右移动
                for (j = i - 1; j > 0 && arr[j] > temp; j--) {
                    arr[j + 1] = arr[j];
                }
                //将临时变量值(外层for循环的当前元素)赋给不满足条件的后一个元素
                arr[j + 1] = temp;
            }
        }

    }

2.希尔排序

 public static void shellSort(int[] array){
        //新建步长 每次除以2
        for (int i = array.length/2; i > 0 ; i/=2) {
            //遍历所有的元素
            for (int j = i; j < array.length; j++) {
                //遍历本组中的所有元素
                for (int k = j-i; k >= 0; k-=i) {
                    //如果当前元素大于加上步长后的元素
                    if (array[k] > array[k+i]){
                        int temp =array[k];
                        array[k] = array[k+i];
                        array[k+i] = temp;
                    }
                }
            }
        }
    }

排序->归并排序

1.归并实现

  private static void Merge(int[] a, int p, int q, int r) {
//		n1和n2分别表示左边序列和右边序列的长度。左边从p开始包括q，右边从q+1开始
        int n1 = q-p+1;
        int n2 = r-q;
        int L[] = new int[n1];
        int R[] = new int[n2];
//		k用来表示当前遍历的数组a的索引
        int i=0,j=0,k=0;
//		分别给L和R赋值
        for(i=0,k=p; i<n1; i++,k++){
            L[i] = a[k];
        }
//		从右边开始
        for(j=0,k=q+1; j<n2; j++,k++){
            R[j] = a[k];
        }
//		比较大小,从小到大排列
        for(i=0,j=0,k=p; i<n1&&j<n2; k++){
            if(L[i] > R[j]){
                a[k] = R[j];
                j++;
            }else{
                a[k] = L[i];
                i++;
            }
        }//for
//		将两个数组中剩下的数放到a中
        if(i<n1){
            for(j=i; j<n1; j++,k++){
                a[k] = L[j];
            }
        }
        if(j<n2){
            for(i=j; i<n2; i++,k++){
                a[k] = R[i];
            }
        }
    }

2.递归

   private static void MergeSort(int[] a, int p, int r) {
        if(p<r){
            int q = (p+r)/2;
			//p表示从子序列的哪个索引开始，q表示子序列中间的位置
            MergeSort(a,p,q);
            MergeSort(a,q+1,r);
            Merge(a,p,q,r);
        }
    }

排序->交换排序

1.冒泡排序

/**
     * 冒泡排序
     * @param arr 传入需要排序的数组
     * 需要执行 length -1 次
     *
     *
     */
    public static void bubbleSort(int[] arr){
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j] > arr[j+1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }

2.快速排序

public static void quickSort(int[] arr, int start, int stop) {
        if (start < stop){
            int stard = arr[start];
            int low = start;
            int high = stop;
            while (low < high) {
                //如果右边的数字比标准数大，只需要移动，就可以
                while (low < high && arr[high] >= stard) {
                    high--;
                }
                //否则用当前比标准数小的的替换左边的数
                arr[low] = arr[high];
                //如果左边的数字比标准数小，只需要移动，就可以
                while (low < high && arr[low] <= stard) {
                    low++;
                }
                //否则用当前比标准数大的的替换右边的数
                arr[high] = arr[low];
            }
            //把标准数赋值给重合点low=high
            arr[low] = stard;
            quickSort(arr,start,low);
            quickSort(arr,low+1,stop);
        }
}

选择排序

1.简单选择排序

public static void simSelectSort(int[] arr){
        //外层循环控制第几个数进行比较，从第一个开始比较
        for (int i = 0; i < arr.length; i++) {
            //假设第一个为最小
            int minindex = i;
            //内层循环找到最小值
            for (int j = i+1; j < arr.length; j++) {
                if(arr[minindex] > arr[j]) {
                    minindex = j;
                }
            }
            //当下标不等时，将最小的和外层的位置交换
            if(i != minindex){
                int temp = arr[i];
                arr[i] = arr[minindex];
                arr[minindex] = temp;
            }
        }
    }