面试题积累篇-简单算法（一）

常见的算法分类几大类，首先说一下第一类交换排序，顾名思义通过待排序的对象进行交换来实现我们的目的。

交换排序分为两种：冒泡排序和快速排序。

冒泡排序思想：

就是小数放前面大数放后面。在代码的角度讲就是第一次内层循环将大数沉底，之后外层循环改变排序次数因为已经找到最大的数下面就要找到倒数第二大一直到倒数第n大（也就是最小的）。由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。代码如下：
 

package com.yang.algorithm.test;

public class BubbleSort {
    public static void main(String[] args) {
        int[] array = {1, 45, 20, 31, 78, 456, 123, 25, 32};
        System.out.println("排序之前：");
        for (int a : array) {
            System.out.print(a + " ");
        }
        bubbleSort(array);
        System.out.println("\n" + "排序之前：");
        for (int a : array) {
            System.out.print(a + " ");
        }
    }

    public static void bubbleSort(int[] array) {
        int length = array.length;
        for (int i = 0; i < length; i++) {
            //外层循环的i可以理解为找到的最大数的个数。 
            // 内层循环的j，-1是因为比较相邻的两个数会出现j+1所以要减1避免越界， 
            // 减i是因为已经找到i个大数了。 
            for (int j = 0; j < length - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
}

运行结果如下：

快速排序思想：
选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

代码如下：

package com.yang.algorithm.test;

public class QuickSort {
    public static void main(String[] args) {
        int[] array = {1, 45, 20, 31, 78, 456, 123, 25, 32};
        System.out.println("排序之前：");
        for (int a : array) {
            System.out.print(a + " ");
        }
        quick(array);
        System.out.println("\n" + "排序之前：");
        for (int a : array) {
            System.out.print(a + " ");
        }
    }

    private static void quick(int[] array) {
        if (array.length > 0) {
            quickSort(array, 0, array.length - 1);
        }
    }

    public static void quickSort(int[] array, int low, int high) {
        if (low < high) {
            //给递归出口。
            int flag = getFlag(array, low, high);
            quickSort(array, 0, flag - 1);
            quickSort(array, flag + 1, high);
        }
    }

    private static int getFlag(int[] array, int low, int high) {
        int temp = array[low];
        //标准元素
        while (low < high) {
            //找到比标准元素小的元素位置
            while (low < high && array[high] >= temp){
                high--;
            }
            //找到位置后，把小的元素赋给标准元素所在的位置。
            array[low] = array[high];
            //从现在的位置找比标准元素大的位置。
            while (low < high && array[low] <= temp) {
                low++;
            }
            //找到后，把这个数赋给之前比标准元素小的位置的那个元素。
            array[high] = array[low];
        }
        //找到标准元素所在位置将其归位。并返回位置索引。
        array[low] = temp;
        return low;
    }
} 

运行结果如下：