【Java】排序算法

目录

冒泡排序

选择排序

二分查找

---

冒泡排序

• 原理

  • 对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面

• 案例

  • // 定义int类型数组

  • // 外层循环控制比较轮数--》n-1轮

  • // 内层循环控制每层比较次数

package com.jcli;

import org.junit.Test;

import java.util.Arrays;

public class Test01_排序算法 {
    public static void main(String[] args) {
        System.out.println("bubbleSort");
        //    定义int类型数组
        int[] arr = {12, 123, 24, 3543, 2343321, 34, 4, 456, 45634, 32};
        // 外层循环控制比较的轮数
        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;
                }
            }
        }
        System.out.println("数组：" + Arrays.toString(arr));
    }


    @Test
    public void bubbleSort() {
        System.out.println("bubbleSort");
        //    定义int类型数组
        int[] arr = {12, 123, 24, 3543, 2343321, 34, 4, 456, 45634, 32};
        // 外层循环控制比较的轮数
        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;
                }
            }
            System.out.println("数组：" + Arrays.toString(arr));
        }
    }
}

水里大的泡泡先出来

选择排序

• 原理

  • 依次从头开始,选中某个位置上的元素,然后与该元素后面所有的元素进行一一比较,较大的数据放在后面

• 案例

  • // 定义int类型数组

  • // 外层循环控制比较轮数--》n-1轮

  • // 内层循环控制每层比较次

@Test
    public void selectionSort() {
        System.out.println("selectionSort");
        // 定义int类型数组
        int[] arr = {12, 123, 24, 3543, 2343321, 34, 4, 456, 45634, 32};
        // 外层循环控制比较轮数--》n-1轮
        for (int i = 0; i < arr.length - 1; 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;
                }
            }
            System.out.println("数组：" + Arrays.toString(arr));
        }
    }

 

还是没看明白， 这不是把最小的放前面，后面大的再算吗！

二分查找

• 原理

  • 获取中间索引对应的元素与要查找的元素进行比较:

  • 如果中间索引对应的元素等于要查找的元素,说明就找到了,直接结束查找

  • 如果中间索引对应的元素大于要查找的元素,说明要找的元素在左侧(忽略右侧数据---->把right=mid-1),依次循环查找

  • 如果中间索引对应的元素小于要查找的元素,说明要找的元素在右侧(忽略左侧数据---->把left=mid+1),依次循环查找

  • 前提: 数组元素有序

• 案例

  • // 定义int类型数组
    //1.定义一个int变量left，记录最左边元素的索引，初始值为0
    //2.定义一个int变量right,记录最右边元素的索引,初始值为数组长度-1
    // 3.循环查找
    // 4.计算中间元素的索引
    // 5.比较中间元素索引的元素与要查找的元素
    // 说明要找的元素在左侧(忽略右侧数据---->把right=mid-1),依次循环查找
    // 说明要找的元素在右侧(忽略左侧数据---->把left=mid+1),依次循环查找
    // 没找到,返回-1作为标识

    @Test
        public void binarySearch() {
            System.out.println("binarySearch");
            // 定义int类型数组
            int[] arr = {4, 12, 24, 32, 34, 123, 456, 3543, 45634, 2343321};
            System.out.println(searchElement(arr, 123));
            System.out.println(searchElement(arr, 111));
        }
    
        public int searchElement(int[] arr, int num) {
            //1.定义一个int变量left，记录最左边元素的索引，初始值为0
            int left = 0;
    
            //2.定义一个int变量right,记录最右边元素的索引,初始值为数组长度-1
            int right = arr.length - 1;
            // 3.循环查找
            while (left <= right) {
                // 4.计算中间元素的索引
                int mid = (left + right) / 2;
                // 5.比较中间元素索引的元素与要查找的元素
                if (arr[mid] == num) {
                    return mid;
                } else if (arr[mid] > num) {
                    // 说明要找的元素在左侧(忽略右侧数据---->把right=mid-1),依次循环查找
                    right = mid - 1;
                } else if (arr[mid] < num) {
                    // 说明要找的元素在右侧(忽略左侧数据---->把left=mid+1),依次循环查找
                    left = mid + 1;
                }
            }
            // 没找到,返回-1作为标识
            return -1;
        }