学习排序

1、简单选择排序
思想：每次排序找出最小的值，放在最前面。并不是在一次排序中，每当发现比目标位置小的元素就交换。而是每次排序只有一次交换。

import java.util.Arrays;


public class test01 {


    public static void main(String[] args) {
        int a[] = {2, 9, 34, 6, 32, 45, 64, 32};
        for (int i = 0; i < a.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < a.length; j++) {
                if (a[minIndex] > a[j]) {
                    minIndex = j;
                }
            }
            int temp = a[i];
            a[i] = a[minIndex];
            a[minIndex] = temp;
        }
        System.out.println(Arrays.toString(a));
    }

}

字符串数组排序 ，以简单选择排序为基础：

import java.util.Arrays;

public class HomeWork01 {


    public static void main(String[] args) {

        String array[] = {"fcf", "af", "ed", "cd", "cf", "vf", "sx"};
        boolean isMatchIf = false;
        for (int i = 0; i < array.length; i++) {
            for (int m = 0; m < array.length - 1; m++) {
                isMatchIf = false;
                char[] temp1 = array[m].toCharArray();
                char[] temp2 = array[m + 1].toCharArray();

                int length = temp1.length > temp2.length? temp2.length : temp1.length; 
                for (int n = 0; n < length; n++) {
                    if (temp1[n] > temp2[n]) {
                        String tempString = array[m];
                        array[m] = array[m + 1];
                        array[m + 1] = tempString;
                        isMatchIf = true;
                        break;
                    }else if(temp1[n] != temp2[n]){
                        break;
                    }


                }
                if(!isMatchIf && temp1.length > temp2.length){
                    String tempString = array[m];
                    array[m] = array[m + 1];
                    array[m + 1] = tempString;

            }

            }
        }
        System.out.println(Arrays.toString(array));
    }

}

2、冒泡排序
思想：每次排序，从第一位与相邻的一位比较，符合条件就换位，注意每次排序内层循环的长度。

import java.util.Arrays;


public class test01 {


    public static void main(String[] args) {
        int a[] = {2, 9, 34, 6, 32, 45, 64, 32};
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a.length - i - 1; j++) {
                if (a[j] > a[j + 1]) {
                    int temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(a));
    }   
}

3、插入排序
int[] a = {34, 67, 32, 2, 56, 46, 45, 21, 46, 43, 32, 78, 54, 32, 7, 78};

int[] a = {34, 67, 32, 2, 56, 46, 45, 21, 46, 43, 32, 78, 54, 32, 7, 78};

public static void inserSort(int[] a){
        for (int i = 1; i < a.length; i++) {
            int temp = a[i];
            int j;
            for ( j = i - 1; j >= 0; j--) {
                if (a[j] > temp) {
                    a[j + 1] = a[j];
                }else {
                    break;
                }
            }
            a[j + 1] = temp;
        }
        System.out.println(Arrays.toString(a));
    }

4、快速排序

1.设置两个变量i,j，排序开始从i = 1, j = n;
2.将第一个元素作为关键数据，赋值给 x,即 x = a[1];
3. 从j开始向前搜索，即由后开始向前搜索，找到第一个小于 x的值，两者交换；
4.从i开始向后搜索，即由前开始往后搜索，找到第一个大于x的值，两者交换；
5，重复第3.4部，直到i=j;
eg:
49, 38, 65, 97, 76, 13, 27;
步骤：
1. x = 49,
进行第一次交换：27,38,65,97,76,13,49;（j）
第二次交换：27,38,49,97,76,13,65(i)
第三次交换：27,38,13,97,76，49,65（j）
第四次交换：27,38,13,49,76,97,65(i)
第五次交换：i=j；结束一躺快速排序
现在以49为关键数据为中心，49前面的数据都要比49小，49后面的数据都要比49大。
然后再对这2组数据进行快速排序。

/**
     * 
     * @return 
     */

    public static int getMiddle(int [] a, int low, int high){
        int temp = a[low];  //初始化中轴的位置
        while(low < high){
            while(low < high && a[high] >= temp){
                high --;
            }
            a[low] = a[high];  // 比中轴小的放在低位

            while(low < high && a[low] <= temp){
                low ++;
            }
            a[high] = a[low]; //比中轴大的放在高位
        }
        a[low] = temp;
        return low;

    }
    public static void quickSort(int [] a, int low, int high){
        if(low < high){
            int middle = getMiddle(a, low, high); //把数组分成两半
            quickSort(a, low, middle - 1);
            quickSort(a, middle + 1, high);

        }
    }

5、希尔排序
代码一：

 //希尔排序
    public static void shellSort(int[] a) {
        int d = a.length;

        while (true) {
            int temp;

            d = (int) Math.ceil(d / 2);

            for (int x = 0; x < d; x++) {
                for (int i = x + d; i < a.length; i += d) {
                    temp = a[i];
                    int j;
                    for (j = i - d; j >= 0 && a[j] > temp; j -= d) {
                        a[j + d] = a[j];
                    }
                    a[j + d] = temp;
                }
            }
            if (d == 1) {
                break;
            }
        }
    }

代码二：

/**
     * 3、用插入排序和希尔排序实现
     * int a = {2,3,4,1,5,7,9,10} 的排序。（不要用以前写好的工具类）
     */
    public static void main(String[] args) {
        int[] array = {2, 3, 4, 1, 5, 7, 9, 10};
        shellSort(array);
        System.out.println(Arrays.toString(array));
    }

    public static void shellSort(int[] array){
        int temp= array.length;

        for (int gap = temp / 2; gap > 0; gap /= 2) {


            for (int i = 0; i < gap; i++) {
                for (int j = i + gap; j < temp; j += gap) {
                    if (array[j] < array[j - gap])  
                    {  
                        int result = array[j];  
                        int k = j - gap;  
                        while (k >= 0 && array[k] > result)  
                        {  
                            array[k + gap] = array[k];  
                            k -= gap;  
                        }  
                        array[k + gap] = result;  
                    }  
                }
            }
        }

    }

6、归并排序

/**
     * 归并排序
     * @param a
     * @return
     */
    public static int [] mergeSort(int [] a){
        //如果待排序的数组就只有一个元素，那么直接返回
        if(a.length < 2){
            return a;
        }

        int middle = a.length / 2;
        int left [] = Arrays.copyOfRange(a, 0, middle);
        int right [] = Arrays.copyOfRange(a, middle, a.length);
        //递归
        left = mergeSort(left);
        right = mergeSort(right);

        return merge(left,right);
    }

    private static int[] merge(int[] left, int[] right) {
        int [] result = new int [left.length + right.length];
        int index = 0;

        while(left.length > 0 && right.length > 0){
            if(left [0] > right [0]){
                //把比较后小的那个值放入目标数组
                result[index ++] =right[0];
                //从原来数组中去掉选中的元素
                right = Arrays.copyOfRange(right, 1, right.length);
            }else{
                //把比较后小的那个值放入目标数组
                result[index ++] =left[0];
                //从原来数组中去掉选中的元素
                left = Arrays.copyOfRange(left, 1, left.length);
            }
        }
        //如果比较完成后原始数组中还有值
        if(left.length > 0){
            System.arraycopy(left, 0, result, index, left.length);
        }else if(right.length > 0){
            System.arraycopy(right, 0, result, index, right.length);
        }
        return result;
    }