实现数组的冒泡排序，二分查找，顺序查找，最大值，最小值，数组逆序，数组数字排列等

最新推荐文章于 2022-03-31 12:33:58 发布

QDNBD

最新推荐文章于 2022-03-31 12:33:58 发布

阅读量165

点赞数

CC 4.0 BY-SA版权

分类专栏：算法题

本文链接：https://blog.youkuaiyun.com/QDNBD/article/details/105188124

算法题专栏收录该内容

5 篇文章

订阅专栏

本文介绍了一种使用Java实现的数组操作方法，包括冒泡排序、二分查找、顺序查找、求最大值、最小值、计算平均值、数组逆序等功能。通过具体的代码示例，展示了如何对数组进行有效管理和数据处理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

实现数组的冒泡排序，二分查找，顺序查找，最大值，最小值，数组逆序，数组数字排列等

import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9};
        int[] newArr = Arrays.copyOf(arr, arr.length);
        max(newArr,arr.length);//最大值
        min(newArr,arr.length);//最小值
        ave(newArr,arr.length);//平均值
        fan(newArr,arr.length);//逆置
        bubbleSort(newArr,arr.length);//冒泡排序
        System.out.println("二分查找:" + binarySearch(newArr,5,arr.length));//二分查找
    }
	//最大值查找
    public static void max(int[] array,int se) {
        int tem = array[0];
        for (int i = 0; i <se ; i++) {
            if(array[i] > tem) {
                tem = array[i];
            }
        }
        System.out.println("max:" + tem);
    }
	//最小2值查找
    public static void min(int[] array,int se) {
        int tem = array[0];
        for (int i = 0; i <se ; i++) {
            if(array[i] < tem) {
                tem = array[i];
            }
        }
        System.out.println("min:" + tem);
    }
	//计算平均值
    public static void ave(int[] array,int se) {
        double tem = 0.0;
        for (int i = 0; i <se ; i++) {
            tem += array[i];
        } tem = tem / (double)se;
        System.out.println("ave:" + tem);
    }
	//数组逆置
    public static void fan(int[] array,int se) {
        int[] ret = new int[se];
        for (int i = 0; i <se ; i++) {
            ret[i] = array[se - 1 - i];
        }
        System.out.println("逆置:" + Arrays.toString(ret));

    }
	//实现数组的冒泡排序
    public static void bubbleSort(int[] array,int se) {
        int[] ret = Arrays.copyOf(array, se);
        for (int i = 0; i < se ; i++) {
            boolean flat = true;
            for (int j = 0; j < se - i - 1; j++) {
                if(ret[j] > ret[j+1]) {
                    int max = ret[j];
                    ret[j] = ret[j+1];
                    ret[j+1] = max;
                    flat = false;
                }
            }if (flat){
                break;
            }
        }System.out.println("冒泡排序" + Arrays.toString(ret));

    }
	//实现数组的二分查找
    public static int binarySearch(int[] array,int key,int right) {
        int left = 0;
        if(left > right) {
            return -1;
        }
        int mid = (left+right) >>> 1;
        if(array[mid] == key) {
            return mid;
        }else if (array[mid] < key) {
            return binarySearch(array,key,left = mid+1);
        }else {
            return binarySearch(array,key,right = mid-1);
        }
    }