冒泡排序+选择排序+插入排序+二分查找

ANnianStriver

已于 2023-06-30 15:58:48 修改

阅读量224

点赞数

分类专栏：算法文章标签：排序算法算法数据结构

于 2023-01-05 11:57:59 首次发布

本文链接：https://blog.csdn.net/AN_NI_112/article/details/128558063

版权

算法专栏收录该内容

7 篇文章 0 订阅

订阅专栏

冒泡排序：🤞🤞

冒泡排序就是从序列中的第一个元素开始，依次对相邻的两个元素进行比较，如果前一个元素大于后一个元素则交换它们的位置。如果前一个元素小于或等于后一个元素，则不交换它们；这一比较和交换的操作一直持续到最后一个还未排好序的元素为止。

当这样的一趟操作完成时，序列中最大的未排序元素就被放置到了所有未排序的元素中最后的位置上，它就像水中的石块一样沉到了水底。而其它较小的元素则被移动到了序列的前面，就像水中的气泡冒到了水面一样。这就是为什么该算法被叫做冒泡排序的原因。

冒泡排序算法是常见面试基础算法之·
心法: N个数字来排队,两两相比小靠前; 外层循环N-1,内层循环N-1-i

public class Test {
    public static void main(String[] args) {
        int[] nums = {16,42,10,65,90,56};
        int temp;
        for (int i = 0; i < nums.length - 1; i++) {
            for (int j = 0; j<nums.length - 1 -i; j++){
                if (nums[j]>nums[j+1]){
                    temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                }
            }
        }
        for (int i = 0; i < nums.length; i++) {
            System.out.println(nums[i]);
        }
    }
}

选择排序： 🤞🤞

选择排序是一种简单直观的排序算法，无论什么数据进去都是O(n²)的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间

算法步骤：

首先在未排序序列中找到最小（大），存放到排序序列的起始位置。再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。重复第二步，直到所有元素均排序完毕。

---------------------------------------------------------------------------------------------------------------------------------

class Test2{
    public static void main(String[] args) {
        int[] nums = {16,42,10,65,90,56};
        int minIndex = 0; // 用于记录每次比较的最小值下标
        for (int i = 0; i < nums.length - 1; i++) {
            minIndex = i;// 每轮假设一个最小值下标
            for (int j = i+1; j < nums.length; j++) {
                if (nums[minIndex] > nums[j]){
                    minIndex = j;
                }
            }
            // 判断需要交换的下标是否为自己
            if (minIndex != i){
                nums[minIndex] = nums[minIndex] + nums[i];
                nums[i] = nums[minIndex] - nums[i];
                nums[minIndex] = nums[minIndex] - nums[i];
            }
        }
        for (int i = 0; i < nums.length; i++) {
            System.out.println(nums[i]);
        }
    }
}

插入排序：🤞🤞

直接插入排序算法(从后向前找到合适位置后插入)

基本思想:每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的字序列的合适位置(从后向前找到合适位置后)，直到全部插入排序完为止。

直接插入排序算法

动态图：-------------------------------------------------

class QiTa2{
    public static void main(String[] args) {
        int[] nums = {16,42,10,65,90,56};
        // 控制比较的轮数
        for (int i = 1; i < nums.length; i++) {
            int temp = nums[i]; // 记录操作数
            int j = 0;
            for (j = i -1; j >= 0; j--){
                if (nums[j] > temp){
                    nums[j+1] = nums[j];
                }else {
                    break;
                }
            }
            if (nums[j+1] != temp){
                nums[j+1] = temp;
            }
        }
        // 输出结果
        for (int num : nums){
            System.out.println(num);
        }
    }
}

二分查找：🤞🤞

二分查找【仅适用于有序的顺序表】

二分法查找(折半查找): 前提是在已经排好序的数组中，通过将待查找的元素与中间索引值对应的元素进行比较，若大于中间索引值对应的元素，去右半部分查找，开始下标为中间下标+1。否则，去左半部分查找，结束下标为中间下标-1. 依此类摇。直到找到为止:找不到返回一个负数。

class BinarySearch{
    public static void main(String[] args) {
        int[] nums = {16,42,10,65,90,56};

    }
    public static int Search(int[] nums,int key){
        int start = 0; // 定义开始下标
        int end = nums.length - 1; // 定义结束下标
        int middle; // 定义中间索引值
        while (start <= end){
            middle = (start + end)/2; // 对半赋值中间索引值 >>>1(无符号右移)
            if (nums[middle] > key){
                end = middle - 1; // 大于中间索引值对应的元素，去右半部分查找
            }else if (nums[middle] < key){
                start = middle + 1; // 去左半部分查找
            }else {
                return middle; // 返回查找数据的索引值
            }
        }
        return -1;
    }
}

完整代码✊ 👊✊ 👊

package Test.test2;

/**
 * 简单算法
 * 冒泡排序  +   选择排序    +   插入排序    +  二分查找
 *
 * @author 杨振华
 * @date 2023/01/05
 */
//============================================================================================
/**
 * 冒泡排序
 * 冒泡排序就是从序列中的第一个元素开始，依次对相邻的两个元素进行比较，
 *         如果前一个元素大于后一个元素则交换它们的位置。如果前一个元素小于或等于后一个元素，则不交换它们；
 *         这一比较和交换的操作一直持续到最后一个还未排好序的元素为止。
 *         当这样的一趟操作完成时，序列中最大的未排序元素就被放置到了所有未排序的元素中最后的位置上，
 *         它就像水中的石块一样沉到了水底。而其它较小的元素则被移动到了序列的前面，就像水中的气泡冒到了水面一样。
 *         这就是为什么该算法被叫做冒泡排序的原因。
 *
 * @author 杨振华
 * @date 2023/01/05
 */
class BubbleSort {
    public static void main(String[] args) {
        /*
        冒泡排序算法是常见面试基础算法之·
        心法: N个数字来排队,两两相比小靠前; 外层循环N-1,内层循环N-1-i
         */
        int[] nums = {16,42,10,65,90,56};
        int temp;
        for (int i = 0; i < nums.length - 1; i++) {
            for (int j = 0; j<nums.length - 1 -i; j++){
                if (nums[j]>nums[j+1]){
                    temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                }
            }
        }
        for (int i = 0; i < nums.length; i++) {
            System.out.println(nums[i]);
        }
    }
}
/**
 * 选择排序
 *
 * 选择排序是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。
 * 所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。
 *
 * 1. 算法步骤
 * 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
 * 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
 * 重复第二步，直到所有元素均排序完毕。
 *
 * @author 杨振华
 * @date 2023/01/05
 */
class SelectSort{
    public static void main(String[] args) {
        int[] nums = {16,42,10,65,90,56};
        int minIndex = 0; // 用于记录每次比较的最小值下标
        for (int i = 0; i < nums.length - 1; i++) {
            minIndex = i;// 每轮假设一个最小值下标
            for (int j = i+1; j < nums.length; j++) {
                if (nums[minIndex] > nums[j]){
                    minIndex = j;
                }
            }
            // 判断需要交换的下标是否为自己
            if (minIndex != i){
                nums[minIndex] = nums[minIndex] + nums[i];
                nums[i] = nums[minIndex] - nums[i];
                nums[minIndex] = nums[minIndex] - nums[i];
            }
        }
        for (int i = 0; i < nums.length; i++) {
            System.out.println(nums[i]);
        }
    }
}
/*
class SelectionSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        // 总共要经过 N-1 轮比较
        for (int i = 0; i < arr.length - 1; i++) {
            int min = i;

            // 每轮需要比较的次数 N-i
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[min]) {
                    // 记录目前能找到的最小值元素的下标
                    min = j;
                }
            }

            // 将找到的最小值和i位置所在的值进行交换
            if (i != min) {
                int tmp = arr[i];
                arr[i] = arr[min];
                arr[min] = tmp;
            }

        }
        return arr;
    }
}
*/


/**
 * 插入排序
 * 直接插入排序算法(从后向前找到合适位置后插入)基本思想:
 *     每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的字序列的合适位置(从后向前找到合适位置后)，
 *     直到全部插入排序完为止。
 * @author 杨振华
 * @date 2023/01/05
 */
class InsertSort{
    public static void main(String[] args) {
        int[] nums = {16,42,10,65,90,56};
        // 控制比较的轮数
        for (int i = 1; i < nums.length; i++) {
            int temp = nums[i]; // 记录操作数
            int j = 0;
            for (j = i -1; j >= 0; j--){
                // 如果前一个数更大，则将这个数覆盖为前一个数
                if (nums[j] > temp){
                    nums[j+1] = nums[j];
                }else {
                    break;
                }
            }
            // 将前一个的较大数替换为temp记录的较小数
            if (nums[j+1] != temp){
                nums[j+1] = temp;
            }
        }
        // 输出结果
        for (int num : nums){
            System.out.println(num);
        }
    }
}

/**
 * 二分查找 【仅适用于有序的顺序表】
 * 二分法查找(折半查找):
 *      前提是在已经排好序的数组中，通过将待查找的元素与中间索引值对应的元素进行比较，
 *      若大于中间索引值对应的元素，去右半部分查找，开始下标为中间下标+1。
 *      否则，去左半部分查找，结束下标为中间下标-1.
 *      依此类摇。直到找到为止:找不到返回一个负数。
 * @author 杨振华
 * @date 2023/01/05
 */
class BinarySearch{
    public static void main(String[] args) {
        int[] nums = {16,42,10,65,90,56};

    }
    public static int Search(int[] nums,int key){
        int start = 0; // 定义开始下标
        int end = nums.length - 1; // 定义结束下标
        int middle; // 定义中间索引值
        while (start <= end){
            middle = (start + end)/2; // 对半赋值中间索引值 >>>1(无符号右移)
            if (nums[middle] > key){
                end = middle - 1; // 大于中间索引值对应的元素，去右半部分查找
            }else if (nums[middle] < key){
                start = middle + 1; // 去左半部分查找
            }else {
                return middle; // 返回查找数据的索引值
            }
        }
        return -1;
    }
}