数据结构(一)排序算法

列举几种常见的排序算法,如:冒泡、选择、插入、快速排序。

准备工作

/**
 * 初始化数据
 */
public static void init(int[] datas){
    for (int i = 0; i < datas.length; i++) {
        datas[i] = new Random().nextInt(100);
    }
}

/**
 * 交换数据
 * @param datas
 * @param i
 * @param minIndex
 */
private static void exchange(int[] datas, int i, int minIndex) {
    int temp = datas[minIndex];
    datas[minIndex] = datas[i];
    datas[i] = temp;
}

/**
 * 打印数据
 */
public static void print(int[] datas){
    for (int i = 0; i < datas.length; i++) {
        System.out.print(datas[i]+" ");
    }
    System.out.println();
}

冒泡排序

/**
 * 冒泡排序
 */
public static void bubble(int[] datas){
    for (int i = datas.length-1; i > 0; i--) {
        for (int j = 0; j < i; j++) {
            if (datas[j]>datas[j+1]) {
                exchange(datas, j, j+1);
            }
        }
    }
}

选择排序

/**
 * 选择排序
 */
public static void select(int[] datas){
    for (int i = 0; i < datas.length-1; i++) {
        int minIndex = i;
        for (int j = i+1; j < datas.length; j++) {
            if (datas[minIndex]>datas[j]) {
                minIndex = j;
            }
            //交换数据
            exchange(datas, i, minIndex);
        }
    }
}

插入排序

/**
 * 插入排序
 */
public static void insert(int[] datas){
    for (int i = 1; i < datas.length; i++) {
        int temp = datas[i];
        int j = i-1;
        for (; j >=0; j--) {
            if (datas[j] > temp) {
                datas[j+1] = datas[j];
            }else {
                break;
            }
        }
        datas[j+1] = temp;
    }
}

快速排序

/**
 * 快速排序
 */
public static void quickSort(int[] datas,int left,int right){
    //跳出递归的条件,左指针索引大于右指针
    if (left >= right) {
        return ;
    }
    //进行快速排序
    //1.找到中间值
    int middle = findMiddle(datas,left,right);
    //2.中间值左边进行快速排序
    quickSort(datas,left,middle-1);
    //3.中间值右边进行快速排序
    quickSort(datas,middle+1,right);

}

/**
 * 找到中间值得索引位置
 * @param datas  数据
 * @param left   左指针
 * @param right  右指针
 * @return 索引位置
 */
private static int findMiddle(int[] datas, int left, int right) {
    //定义一个中间点索引
    int middle = -1;
    //以最后一个数据做参照物
    int temp = datas[right];
    //定义左右指针进行排序
    int leftIndex = left;
    int rightIndex = right-1;

    while (true) {
        //1.左指针从左往右找比temp大的数据
        //跳出循环条件:1.leftIndex == right 2.datas[leftIndex] > temp
        while (leftIndex < right && datas[leftIndex] <= temp) {
            leftIndex ++;
        }
        //如果通过leftIndex == right跳出循环
        if (leftIndex == right) {
            middle = leftIndex;
            break;
        }

        //2.右指针从右往左找比temp小的数据
        //跳出循环条件:1.rightIndex >= left 2.datas[rightIndex] >= temp
        while (rightIndex >= left && datas[rightIndex] >= temp) {
            rightIndex--;
        }
        //如果通过rightIndex < left 

        //比较左右指针是否出现交叉
        if (rightIndex > leftIndex) {
            //没有交叉
            //交换左右指针位置的数据
            exchange(datas,rightIndex,leftIndex);
            //继续循环
            continue ;
        } else {
            //交叉
            //交换左指针和参照物的值
            exchange(datas,leftIndex,right);
            //找到中间点(leftIndex),终止整个循环
            middle = leftIndex;
            break;
        }
    }
    return middle;
}

递归

/**
 * 汉诺塔问题
 */
public static void move(int n,char a,char b,char c){
    if (n == 1) {
        System.out.println("盘"+n+"从"+a+"柱子"+"移动到"+c+"柱子");
    }else {
        //把n-1个盘子从a盘借助c盘移动到b盘
        move(n-1,a,c,b);
        //第n个盘子从a盘移动到c盘
        System.out.println("盘"+n+"从"+a+"柱子"+"移动到"+c+"柱子");
        //把n-1个盘子从b盘借助a盘移动到c盘
        move(n-1,b,a,c);
    }

}