算法——冒泡排序原理,数组的二分查找法,Arrays工具类的使用

最新推荐文章于 2024-08-08 22:50:50 发布
最新推荐文章于 2024-08-08 22:50:50 发布
阅读量135 收藏 1
点赞数
文章标签： java 开发语言 后端 java-ee
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55804389/article/details/121183583
版权
本文介绍了冒泡排序算法的工作原理、代码实现及其实用场景，随后探讨了数组的普通查找与二分查找法，包括原理和代码实例。还涵盖了Arrays工具类在排序和查找中的应用，以及自定义工具类MyArrays的实现。
摘要由CSDN通过智能技术生成

第一章 冒泡排序

冒泡排序
1.原理:    
    每次都是从第一个元素开始向后两两进行比较,只要后面的元素小于前面的元素,就交换这两个元素(元素只能按照从小到大的顺序排序)
        
2.总结:
    1.有5个数需要排4趟,有n个数需要n-1趟
    2.每趟排序的次数都比前面一趟少1次

3.规律:
        第一趟                第二趟            第三趟            第四趟
        [0] VS [1]        [0] VS [1]        [0] VS [1]    [0] VS [1]
        [1] VS [2]      [1] VS [2]      [1] VS [2]
        [2] VS [3]      [2] VS [3]
        [3] VS [4]

 

 

1.2 冒泡排序代码实现

public class Demo05BubbleSort {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {7, 6, 5, 4, 3};
        System.out.println("未排序前: " + Arrays.toString(arr));


        //arr.length-1: 能否不写 减 1 呢? 可以的,只是多排了一趟而已
        for (int i = 0; i < arr.length - 1; i++) {//外层for循环: 控制排序的趟数
            for (int j = 0; j < arr.length -1 - i; j++) {//内层循环: 控制每趟排序的次数
                //arr.length - 1 - i: 能否不写减i呢? 可以,只是每趟排序的次数多了一次而已
                //arr.length - 1 - i: 能否不写减1呢? 必然不可以,因为会发生索引越界
                //j<arr.length && j + 1<arr.length ==> j<arr.length-1
                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));
    }
}

第二章 数组的二分查找法

1.1 数组元素的普通查找法

要求:
    在int数组中查找某个元素第一次出现的索引,如果没有该元素,返回-1
    10,20,30,50,80          
    定义方法在int数组中获取一个元素第一次出现的索引值,如果没有返回-1
        三要素:
            1.方法名称: getIndex
            2.参数列表:
                int[] array: 要查找元素的int数组
                int value: 要在数组中查找的元素
            3.返回值类型: int
                
实现步骤:
    1.使用for循环遍历方法参数数组array
    1.1 如果当前元素值 等于 要查找的元素value
    1.2 直接返回当前元素的索引
    2.for循环结束,说明没有找找该元素,直接返回-1

public class Demo04GetIndex {
    public static void main(String[] args) {
        int[] array = {10,20,30,50,80};
        System.out.println(getIndex(array,30));
        System.out.println(getIndex(array,80));
        System.out.println(getIndex(array,100));
    }

    //定义方法在int数组中获取一个元素第一次出现的索引值,如果没有返回-1
    public static int getIndex(int[] array, int value) {
        //1.使用for循环遍历方法参数数组array
        for (int i = 0; i < array.length; i++) {
            //1.1 如果当前元素值 等于 要查找的元素value
            if (array[i] == value) {
                //1.2 直接返回当前元素的索引
                return i;
            }

        }
        //2.for循环结束,说明没有找找该元素,直接返回-1
        return -1;
    }
}

 

1.2 二分查找原理

前提:
    1.数组必须要保证是有序的
    2.数组元素不能重复
    
原理:
    取数组中间的元素和被查找的元素进行比较，如果被查找元素大于数组中间元素，
    就舍去数组元素的一半，对另一半继续进行查找。

 

 

1.3 二分查找代码实现

定义方法在int数组中获取一个元素第一次出现的索引值,如果没有返回-1
三要素:
    1.方法名称: getIndex
    2.参数列表:
        int[] array: 要查找元素的int数组
        int value: 要在数组中查找的元素
    3.返回值类型: int
    
public class Demo05BinarySearch {
    public static void main(String[] args) {
        int[] array = {5, 13, 19, 21, 37, 56, 64, 75, 80, 88, 92};

        System.out.println(binarySearch(array,5));//0
        System.out.println(binarySearch(array,56));//5
        System.out.println(binarySearch(array,92));//10
        System.out.println(binarySearch(array,100));//-1
    }

    //定义方法在int数组中获取一个元素第一次出现的索引值,如果没有返回-1
    public static int binarySearch(int[] array, int value) {
        //定义int变量记录左边的最小索引
        int low = 0;

        //定义int变量记录右边的最大索引
        int high = array.length - 1;

        //定义int变量记录中间索引
        int mid = 0;
        //使用while循环进行二分查找
        while (low <= high) {
            //计算中索引值
            mid = (low + high)/2;
            //判断中间索引对应的元素值和要查找的元素值的大小关系
            if (array[mid] > value) {
                //说明要找的值在中间值的左边
                //修改high的值
                high = mid - 1;
            } else if (array[mid] < value) {
                //说明要找的值在中间值的右边
                //修改low的值
                low = mid + 1;
            } else {
                //说明找到了
                return mid;
            }
        }
        //代码执行到这里说明没找到
        //返回-1
        return -1;
    }
}

第三章 Arrays工具类的使用

3.1 工具类Arrays的用法

java.util.Arrays类: 此类是用来操作数组的工具类
工具类的特点:
    1.所有的成员都是static修饰的,直接用类名调用即可,不需要对象
    2.把构造方法private修饰
常用方法:
    public static void sort(int[] a) 对指定的int数组进行升序排列
    
    public static int binarySearch(int[] a,int key): 
        对数组进行二分查找法，找不到元素返回(-插入点)-1
            
    public static String toString(int[] a) 将数组转成字符串
public class Demo06Arrays {
    public static void main(String[] args) {
        //定义数组
        int[] array = {10,9,3,6,5,1,2};
        System.out.println("排序前: "+Arrays.toString(array));

        //调用方法按照从小到大的顺序排序
        MyArrays.sort(array);

        System.out.println("排序后: "+Arrays.toString(array));

        System.out.println("二分超找1: "+Arrays.binarySearch(array,1));//0
        System.out.println("二分超找6: "+Arrays.binarySearch(array,6));//4
        System.out.println("二分超找10: "+Arrays.binarySearch(array,10));//6
    }
}

3.2 自定义操作数组的工具类MyArrays

/*
    自定义操作数组的工具类
    工具类的特点:
        1.所有的成员都是static修饰的,直接用类名调用即可,不需要对象
        2.把构造方法private修饰
 */
@SuppressWarnings("all")
public class MyArrays {
    //2.把构造方法private修饰
    private MyArrays(){}

    //对int数组按照从小到大的顺序排序的方法
    public static void sort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length -1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }

            }
        }
    }

    //定义方法在int数组中获取一个元素第一次出现的索引值,如果没有返回-1
    public static int binarySearch(int[] array, int value) {
        //定义int变量记录左边的最小索引
        int low = 0;

        //定义int变量记录右边的最大索引
        int high = array.length - 1;

        //定义int变量记录中间索引
        int mid = 0;
        //使用while循环进行二分查找
        while (low <= high) {
            //计算中索引值
            mid = (low + high)/2;
            //判断中间索引对应的元素值和要查找的元素值的大小关系
            if (array[mid] > value) {
                //说明要找的值在中间值的左边
                //修改high的值
                high = mid - 1;
            } else if (array[mid] < value) {
                //说明要找的值在中间值的右边
                //修改low的值
                low = mid + 1;
            } else {
                //说明找到了
                return mid;
            }
        }
        //代码执行到这里说明没找到
        //返回-1
        return -1;
    }

    //获取int数组的字符串表现形式
    //{10,20,30} --> [10, 20, 30]
    //{} --> []
    public static String toString(int[] array) {
        //安全检查
        //数组是null,直接返回字符串null
        if (array == null) {
            return "null";
        }

        //计算数组最大索引
        int maxIndex = array.length - 1;

        //数组没有元素,直接返回字符串"[]"
        if (maxIndex == -1) {
            return "[]";
        }

        //利用StringBuilder对象拼接字符串
        //创建StringBuilder对象,初始化值"["
        StringBuilder sb = new StringBuilder("[");

        //使用for循环遍历数组array
        for (int i = 0; ; i++) {
            //拼接数组元素
            sb.append(array[i]);
            //判断如果上面拼接的是最后一个元素
            if (i == maxIndex) {
                //拼接"]",之后把StringBuilder对象转换成String对象并返回
                return sb.append("]").toString();
            }
            //代码执行到这里,说明前面拼接的不是最后一个元素
            //拼接", "
            sb.append(", ");
        }

    }
}
//测试类
public class Demo05MyArrays {
    public static void main(String[] args) {
        //定义数组
        int[] array = {10,9,3,6,5,1,2};
        System.out.println("排序前: "+MyArrays.toString(array));

        //调用方法按照从小到大的顺序排序
        MyArrays.sort(array);

        System.out.println("排序后: "+MyArrays.toString(array));

        System.out.println("二分超找1: "+MyArrays.binarySearch(array,1));//0
        System.out.println("二分超找6: "+MyArrays.binarySearch(array,6));//4
        System.out.println("二分超找10: "+MyArrays.binarySearch(array,10));//6
    }
}

3.3 转义字符

转义字符 \
1.去掉某些字符上的特殊含义

2.给某些字符添加特殊含义
    \t: 制表符
    \r\n: windows换行

//测试类
public class Demo02ZhuanYi {
    public static void main(String[] args) {
        //以字符串的形式打印"
        System.out.println("\"");

        //以字符的形式打印'
        System.out.println('\'');

        System.out.println("helloworld");
        System.out.println("hello\t\tworld");
        System.out.println("hello\r\nworld");

    }
}

 

张茜茜612
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
创建一个数组，冒泡排序、二分法查找
JustChenxx的博客
09-24 129
//导包 import java.util.Random; import java.util.Scanner; public class DemoMaoPao { public static void main(String[] args) { // 创建Random随机数对象 Random ra = new Random(); // 定义一个整形数组，长度为二十 int[] arr=new int[20]; // 利用fo.
java实现数组冒泡排序、数组选择排序、二分法查找数组元素
weixin_43958958的博客
06-24 253
冒泡排序 冒泡排序 原始数据：3，2，7，6，8 从第一个元素开始，每次和右边相邻的做比较，比出大的那一个放在两者右边，继续拿大的 这个数和后面的做比较，这样第一次循环可以排出最大的数放在最右边 从第二次循环开始，剩下的数据就只有2，3，6，7 public class BubbleSort { public static void main(String[] args) { int[] arr={5,2,7,10,8,1,4}; for (int i = arr.l
Arrays中的二分查找
qq_37347128的博客
09-12 351
#JDK对你最有触动的代码# Arrays中的二分查找方法(以double为例) // 片段1 private static int binarySearch0(double[] a, int fromIndex, int toIndex, double key) { int low = fromIndex; int high = toIndex - 1; while (low <= high) { ...
6.旋转数组的最小数字（java）
gaopan1999的博客
02-23 144
题目描述 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。 解题思路 1.最简单的方法，遍历一遍即可。数字为非递减排序，旋转后，遍历过程中找到第一个比array[0]小...
数组基础及实例应用（冒泡排序、二分法查找数据）
weixin_30273501的博客
06-16 136
强类型语言的特点：（弱类型语言特点正好相反） 1.存储的数据必须是连续的； 2.需要规定长度，即规定最多存多少数据； 3.规定数据类型； 数组的定义方式 1 var arr=new Array(); 2 arr[0]=1; 3 arr[1]=2; 4 arr[2]="hello"; 5 alert(arr[1]); var arr=new Array(1,2,3,4...
在排序数组中找出一个整数第一次出现的位置
shouwangcc的专栏
09-20 1542
对于一个有序数组，我们通常采用二分查找的方式来定位某一元素，请编写二分查找的算法，在数组中查找指定元素。 给定一个整数数组A及它的大小n，同时给定要查找的元素val，请返回它在数组中的位置(从0开始)，若不存在该元素，返回-1。若该元素出现多次，请返回第一次出现的位置。 测试样例： [1,3,5,7,9],5,3 返回：1 int getPos(vector A, int n,
Arrays中的二分查找（折半查找）
2的32次方
04-01 2682
在java.util.Arrays类中提供了对有序（升序排列）数组的二分查找的方法。由于算法的思路都是一致，所以就以int[]数组的binarySearch方法做分析的例子。binarySearch底层是调用binarySearch0方法，以下是Arrays中的代码/** *a是一个升序排列的数组， *fromIndex是二分查找的a的起始索引 *toIndex是二分查找的a的终止索引 *k
Java数据结构和算法之Java数组
03-14
二分查找适用于已排序的数组，查找效率高，但不适用于未排序的数组。二分查找的实现如下： ```java int target = 5; int index = Arrays.binarySearch(numbers, target); ``` 数组的复制也是一个常见操作。`System...
排序算法java描述
05-25
在实际开发中，Java提供了内置的`Arrays.sort()`方法，它使用了一种混合排序算法，结合了快速排序、插入排序和归并排序的特点，能够高效地处理各种大小的数组。此外，如果你需要对对象进行排序，可以自定义比较器...
动力节点老杜Java基础入门学习教程分享——数组
09-16
#### Arrays工具类 - **Arrays.sort()**：用于排序数组。 - 示例代码： ```java int[] nums = {5, 3, 2, 4, 1}; Arrays.sort(nums); ``` - **Arrays.fill()**：用于填充数组。 - 示例代码： ```java int[]...
java实现常见的集中排序算法
04-22
在Java中，我们可以使用ArrayUtils、Collections等工具类进行排序，例如`Arrays.sort()`和`Collections.sort()`，它们内部使用了高效的排序算法，如TimSort，是混合排序算法，结合了插入排序和归并排序的优点，对小...
各种排序算法java实现
03-18
同时，JDK的`Arrays.sort()`方法底层使用的是TimSort算法，一种混合了插入排序和归并排序的稳定排序算法，适用于大多数情况。 标签"源码"提示，这个博客可能提供了上述算法的Java实现代码，这对学习和理解这些算法...
一维数组 冒泡排序 shell 排序 二分查找 C++
Li_zhonglei的博客
07-18 1116
首先是两种排序的算法：冒泡排序与希尔（shell）排序 冒泡排序的平均时间复杂度是O(n^2)，最好的时间复杂度为O(n)，空间复杂度是1； 希尔排序的时间复杂度是O(nlogn），空间复杂度也是1； 时间复杂度大家应该比较清楚，then what is 空间复杂度？ 空间复杂度：如果排序算法所需的辅助空间并不依赖于问题的规模n，则辅助空间为O(1)，也称作就地排序（In-PlaceSor
二分查找（算法）
11-06 1554
如题，二分查找只是针对有序数组中查找特定元素的搜索一种算法！二分查找很好写，却很难写对，下面我来一一介绍下二分查找和二分查找的变种！ 1.原理 在一个有序的数组中，平分数组，取到中间值（x），这时数组已经被这个x分割成两部分left和right，[left,x,right],用值(n)和这个中间（x）做对比！(如果比x大，那目标就缩小到right这部分，然后继续平分right数组，取到中间值（x1），这时数组已经被这个x分割成两部分left1和right1，[left1,x1,right1]，接着比较这个值
用Arrays排列一字符数组，并查找一字符在其中位置。
xszrt的博客
09-06 2220
代码和任务 import java.util.Arrays; /*copyright(c)2015 csdn学院 *All right reserved. *文件名称：test.java *作者；张如田 *完成日期： *版本号： *需求说明：用Arrays排列一字符数组，并查找当中一字符位置。 * */ public class Test2 { /** * @param args
java二分查找法_java算法-二分查找法
weixin_42169674的博客
02-12 324
二分查找法的前提是数据必须是有序排列的数据，如果不是那将失去二分查找法的意义。其中二分查找法有两种实现方式while、递归方法实现。下面我们来看下它的代码。public class maxtest {public static void main(String[] args) {//###################二分查找法start###################//int[] ar...
2020.7.15一维数组的部分算法以及冒泡排序以及Array的应用
m0_49140390的博客
07-15 197
1.从有序数组中，插入一个数: 先扩容，再新建一个比原数组多一个长度的数组，把原数组中的数据对应赋值到新数组中，从倒数第二位开始从后向前遍历，与要插入的数依次比较：不满足原先顺序的，向后移动 满足原先顺序的，再该值后方插入 如果一直没有插入，则插在首位 2.插入排序逻辑 外层循环从首位到末尾-1的位置 内层与插入的逻辑相同 3.选择排序的逻辑 外层循环从首位向后，来控制要确定的位置 内层循环从外层循环的位置下一位开始，向后遍历 外层循环的位置和内层循环的位置的值相互比较 内层循环找出最大的值放到外层循环此时
生成不重复的随机数
yangdan888的专栏
07-15 376
import java.util.Arrays;class T {  public static void main(String[] args) {    int a[] = new int[6];    for (int i = 0; i       a[i] = (int) (Math.random() * 6) + 1;      for (int k = 0; k         i
（javaweb）请求响应postman
最新发布
2301_79144798的博客
08-08 528
1.Tomcat又称为servlet容器前端浏览器发起请求携带http请求数据，web服务器负责请求协议的解析，Tomcat接收请求数据，并对请求数据进行解析。Tomcat将解析后所有的信息封装到一个对象当中：HttpServletRequest（请求对象）---应用程序从中获取请求数据。HttpServletResponse--通过这个对象设置要响应的数据 --响应信息给浏览器浏览器--服务器：：BS架构（通过浏览器能访问到的网站：京东 淘宝 天猫 唯品会都是BS架构）
Java Arrays工具类详解与二分查找应用
"Java基础学习笔记，主要涵盖了Arrays工具类的使用，包括二分查找法和数组复制功能。" 在Java编程中，Arrays工具类是一个非常实用的类，它提供了许多方便的方法来处理数组。本笔记主要介绍了两个关键方法：`binary...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值