Java常见算法_常见的查找算法和排序算法——简介及代码演示

        在本文中我将介绍Java中的常见算法，查找算法包括基本查找、二分查找、插值查找和分块查找。排序算法包括冒泡排序、选择排序、插入排序和快速排序

查找算法：

1.基本查找：

代码：

public class BasicSearchDemo {
    public static void main(String[] args) {
        int[] arr = {1,21,31,41,51,61,71,81};
        Scanner sc = new Scanner(System.in);
        String numStr = sc.nextLine();
        int num = Integer.parseInt(numStr);
        boolean result = basicSearch(arr, num);
        System.out.println(result);
    }
    //基本查找方法
    public static boolean basicSearch(int[] arr, int number) {
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == number) {
                return true;
            }
        }
        return false;
    }
}

这是简单的基本查找，通过遍历数组来查看元素是否存在

运行结果：

基本查找小练习：

代码（含题目要求）：

public class BasicSearchTest {
    public static void main(String[] args) {
        /*
        练习1：
        需求：定义一个方法利用基本查找，查询某个元素在数组中的索引
        要求：不需要考虑数组中元素是否重复
         */

        /*
        练习2：
        需求：定义一个方法利用基本查找，查询某个元素在数组中的索引
        要求：需要考虑数组中元素有重复的可能性
        例如：{1，1，1，2，3，4，5，6，1}
        若查找1，则需要返回所有元素1的索引，即0,1,2,8
         */

        //生成一个数组
        int[] arr = {1,11,21,31,41,51,51,61,51,61};

        //键盘录入一个元素
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要查找的元素：");
        String numStr = sc.nextLine();
        int num = Integer.parseInt(numStr);
        System.out.println(getIndex(arr, num));
        System.out.println(getAllIndex(arr, num));
    }

    //练习1
    public static int getIndex(int[] arr, int number) {
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == number) {
                return i;
            }
        }

        return -1;
    }

    //练习2
    public static ArrayList<Integer> getAllIndex(int[] arr, int number) {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == number) {
                list.add(i);
            }
        }

        return list;
    }
}

运行结果：

2.二分查找：

特点：

        二分查找的数据必须是按大小顺序排好的
        二分查找可以很大的提高查找效率

代码：

public class BinarySearchDemo1 {
    public static void main(String[] args) {
        //二分查找的数据必须是按大小顺序排好的
        //二分查找可以很大的提高查找效率

        //定义数组
        int[] arr = {1,21,31,41,51,61,71,81};
        //键盘录入一个要查找的元素
        System.out.println("输入要查找的元素：");
        Scanner sc = new Scanner(System.in);
        String numStr = sc.nextLine();
        int num = Integer.parseInt(numStr);
        System.out.println(binarySearch(arr, num));

    }

    //定义二分查找方法
    public static int binarySearch(int[] arr, int num) {
        //用min和max表示当前查找范围
        int min = 0;
        int max = arr.length - 1;
        while (true) {
            //这种情况说明元素不存在
            if(min > max) {
                return -1;
            }
            //定义中间指针
            int mid = (min + max) / 2;
            //进行判断
            if(arr[mid] < num) {
                //元素在右边
                min = mid + 1;
            } else if(arr[mid] > num) {
                //元素在左边
                max = mid - 1;
            } else {
                //找到了
                return mid;
            }
        }
    }
}

3.插值查找：

        改变mid位置时使用数学公式使其更靠近要查找的元素

特点：

        适用于数据分布较均匀的情况下

代码：

public class InterpolationSearch {
    public static void main(String[] args) {
        //适用于数据分布较均匀的情况下
        int[] arr = {1,2,3,5,6,8,9,10};
        System.out.println("请输入要查找的元素值：");
        Scanner sc = new Scanner(System.in);
        String numStr = sc.nextLine();
        int num = Integer.parseInt(numStr);
        int index = interpolationSearch(arr, num);
        System.out.println(index);

    }

    public static int interpolationSearch(int[] arr, int num) {
        //定义查找范围
        int min = 0;
        int max = arr.length - 1;

        while(true) {
            if(min > max) {
                return -1;
            }
            //mid = min + (key - arr[min]) / (arr[max] - arr[min]) * (max - min)
            int mid = min + (num - arr[min]) / (arr[max] - arr[min]) * (max - min);
            if(arr[mid] > num) {
                max = mid - 1;
            } else if(arr[mid] < num) {
                min = mid + 1;
            } else {
                return mid;
            }
        }
    }
}

4.分块查找：

        对数据先进行分块，通过先确定要查找的元素属于哪个块，再只需对那个块进行遍历

代码：

public class BlockSearch {
    public static void main(String[] args) {
        //注意分块的块数跟元素个数的开方差不多即可
        //前一块所有元素都小于后一块中的任意元素
        int[] arr = {16, 5, 9, 12, 21, 18,
                    32, 23, 37, 26, 45, 34,
                    50, 48, 61, 52, 73, 66};

        //分块
        Block b1 = new Block(21, 0, 5);
        Block b2 = new Block(45, 6, 11);
        Block b3 = new Block(73, 12, 17);

        //用数组存储
        Block[] blockArr = {b1,b2,b3};

        //输入要查找的元素
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要查找的元素");
        String numStr = sc.nextLine();
        int num = Integer.parseInt(numStr);

        int index = getIndex(arr, blockArr, num);
        System.out.println(index);

    }

    private static int getIndex(int[] arr, Block[] blockArr, int num) {
        int blockIndex = getBlock(blockArr, num);
        if(blockIndex == -1) {
            return -1;
        }
        //将范围缩小到这块的开始和结束索引
        int startIndex = blockArr[blockIndex].getStartIndex();
        int endIndex = blockArr[blockIndex].getEndIndex();
        //遍历
        for (int i = startIndex; i <= endIndex; i++) {
            if(arr[i] == num) {
                return i;
            }
        }
        return -1;
    }

    private static int getBlock(Block[] blockArr, int num) {
        for (int i = 0; i < blockArr.length; i++) {
            if(num < blockArr[i].getMax()) {
                return i;
            }
        }

        return -1;
    }

}


    class Block {
    private int max;
    private int startIndex;
    private int endIndex;


    public Block() {
    }

    public Block(int max, int startIndex, int endIndex) {
        this.max = max;
        this.startIndex = startIndex;
        this.endIndex = endIndex;
    }

    /**
     * 获取
     * @return max
     */
    public int getMax() {
        return max;
    }

    /**
     * 设置
     * @param max
     */
    public void setMax(int max) {
        this.max = max;
    }

    /**
     * 获取
     * @return startIndex
     */
    public int getStartIndex() {
        return startIndex;
    }

    /**
     * 设置
     * @param startIndex
     */
    public void setStartIndex(int startIndex) {
        this.startIndex = startIndex;
    }

    /**
     * 获取
     * @return endIndex
     */
    public int getEndIndex() {
        return endIndex;
    }

    /**
     * 设置
     * @param endIndex
     */
    public void setEndIndex(int endIndex) {
        this.endIndex = endIndex;
    }

    public String toString() {
        return "Block{max = " + max + ", startIndex = " + startIndex + ", endIndex = " + endIndex + "}";
    }
}

排序算法：

1.冒泡排序：

特点：

        相邻的元素两两比较，大的放右边，小的放左边（从小到大情况）
        第一轮比较完毕之后，最大值就已经确定，第二轮可以少循环一次，后面以此类推
        如果数组中有n个数据，那总共执行n-1轮代码就可以

代码：

public class BubbleSort {
    public static void main(String[] args) {
        //相邻的元素两两比较，大的放右边，小的放左边（从小到大情况）
        //第一轮比较完毕之后，最大值就已经确定，第二轮可以少循环一次，后面以此类推
        //如果数组中有n个数据，那总共执行n-1轮代码就可以

        //创建一个数组
        int[] arr = {1,4,5,2,3,9,5,6};
        int[] resultArr = bubbleSort(arr);
        for (int i = 0; i < resultArr.length; i++) {
            System.out.println(resultArr[i]);
        }
    }

    private static int[] 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;
                }
            }
        }

        return arr;
    }
}

2.选择排序：

特点：

        从0索引开始，拿着每一个索引上的元素跟后面的元素依次比较
        小的放前面，大的放后面（从小到大情况），以此类推
        第一轮循环结束后，最小的数据已经确定
        第二轮循环从1索引开始，以此类推

代码：

public class SelectionSort {
    public static void main(String[] args) {
        //从0索引开始，拿着每一个索引上的元素跟后面的元素依次比较
        //小的放前面，大的放后面（从小到大情况），以此类推
        //第一轮循环结束后，最小的数据已经确定
        //第二轮循环从1索引开始，以此类推

        //创建数组
        int[] arr = {4,3,9,5,6,8,2,1};
        int[] resultArr = bubbleSort(arr);
        for (int i = 0; i < resultArr.length; i++) {
            System.out.println(resultArr[i]);
        }

    }

    public static int[] bubbleSort(int[] arr) {
        //外循环：表示几轮
        for (int i = 0; i < arr.length - 1; i++) {
            //内循环：i后面的所有数据与i进行比较
            for (int j = i + 1; j < arr.length; j++) {
                if(arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }

        return arr;
    }
}

3.插入排序：

特点：

        将0索引的元素到N索引的元素看做是有序的，把N+1索引的元素到最后一个元素当成是无序的。
        遍历无序的数据，将遍历到的元素插入有序序列中适当的位置，如遇到相同数据，插在后面。

代码：

public class InsertionSort {
    public static void main(String[] args) {
        //将0索引的元素到N索引的元素看做是有序的，把N+1索引的元素到最后一个元素当成是无序的。
        //遍历无序的数据，将遍历到的元素插入有序序列中适当的位置，如遇到相同数据，插在后面。

        //创建数组
        int[] arr = {1,6,5,3,9,7,16,1,22,3};
        int[] resultArr = insertionSort(arr);
        for (int i = 0; i < resultArr.length; i++) {
            System.out.println(resultArr[i]);
        }
    }

    public static int[] insertionSort(int[] arr) {
        //判断有序元素个数
        int index = 0;
        for (int i = 1; i < arr.length; i++) {
            if(arr[index] < arr[index + 1]) {
                index++;
            } else {
                break;
            }
        }
        //index为最后一个有序元素的索引

        //有序元素后面的每个元素要插入有序元素中   插入后有序元素加1   索引也++

        //我的其他思路   复杂了。。
        /*
        for (; index < arr.length - 1; index++) {
            int i = index + 1;
            for(int j = index; j >= 0; j--) {
                if(arr[i] >= arr[j]) {
                    break;
                } else {
                    //有序元素后面的无序元素只要比前面的小就交换位置
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                    i--;
                    continue;
                }
            }
        }
        */

        //从有序数组后的第一个元素到最后一个元素
        for (int i = index + 1; i < arr.length; i++) {
            int j = i;
            while (j > 0 && arr[j] <arr[j - 1]) {
                int temp = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = temp;
                j--;
            }
        }

        return arr;
    }
}

4.快速排序

        这里展示快速排序之前要先学会递归思想，我先来放两个递归思想的小练习

递归练习一 题目及代码：

public class RecursionAlgorithmTest1 {
    public static void main(String[] args) {
        //核心：找出口 找规律
        //方法中再次调用方法时，参数应更接近出口

        //求1~100所有整数的和
        int sum = getSum(100);
        System.out.println(sum);
    }

    //1~100所有整数的和 = 100 + 1~99的和
    //1~99的和 = 99 + 1~98的和
    //…………
    public static int getSum(int num) {
        //出口
        if(num == 1) {
            return 1;
        }
        return num + getSum(num - 1);
    }
}

递归练习二 题目及代码：

public class RecursionAlgorithmTest2 {
    public static void main(String[] args) {
        //需求：用递归求5的阶乘，并把结果在控制台输出
        int factorail = getFactorail(5);
        System.out.println(factorail);
    }

    //5的阶乘 = 5 * 4的阶乘
    //4的阶乘 = 4 * 3的阶乘
    //…………
    public static int getFactorail(int num) {
        //出口
        if(num == 1) {
            return 1;
        }
        return num * getFactorail(num - 1);
    }
}

        接下来开始讲解快速排序：

过程：

//将排序范围中的第一个数字作为基准数，在定义两个变量start，end
//start从前往后找比基准数大的，end从后往前找比基准数小的。
/*找到之后交换start和end指向的元素，并循环这一过程，直到start和end处于同一个位置，
该位置是基准数在数组中应存入的位置，再让基准数归位*/
//归为后的效果：基准数左边的都比基准数小，右边的都比基准数大

代码演示：

public class QuickSort {
    public static void main(String[] args) {
        //创建数组
        int[] arr = {6,2,3,1,7,5,8};
        int start = 0;
        int end = arr.length - 1;
        quickSort(arr, start, end);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

    }

    private static void quickSort(int[] arr, int i, int j) {
        //出口
        if(i >= j) {
            return;
        }
        int start = i;
        int end = j;
        //基准数
        int baseNumber = arr[i];
        while(start != end) {
            //end从右往左开始找比基准数小的数
            while(true) {
                if(end <= start || arr[end] < baseNumber) {
                    break;
                }
                end--;
            }
            //start从左往右开始找比基准数大的数
            while(true) {
                if(end <= start || arr[start] > baseNumber) {
                    break;
                }
                start++;
            }
            //交换位置
            int temp = arr[end];
            arr[end] = arr[start];
            arr[start] = temp;
        }
        //将基准数与当前start和end索引所在位置交换
        int temp = arr[i];
        arr[i] = arr[start];
        arr[start] = temp;
        //基准数左边继续重复刚才所做的事
        quickSort(arr, i, start - 1);
        //基准数右边继续重复刚才所做的事
        quickSort(arr, start + 1, j);


    }
}