JAVA习题

一、将奇数排在偶数前面

public static void func(int[] arr){//传入你要排序的数组
        int left=0;
        int right=arr.length-1;
        while(left<right){//
            while(left < right && arr[left]%2!=0){//当左边有奇数时，碰到奇数往后走，没碰到就不进入该循环
                left++;//下标往后走
            }
            while(left < right && arr[right]%2==0){//当右边有偶数时，碰到偶数往前走，没碰到就不进入该循环
                right--;//下标往前走
            }
            int tmp=arr[left];//当左标碰到偶数、右标碰到奇数时，交换元素
            arr[left]=arr[right];
            arr[right]=tmp;

        }
        System.out.println(Arrays.toString(arr));//打印结果
    }

定义func函数，传入你要排序的数组

定义left放在数组起始位置，定义right放在数组末位置

当arr[left]碰到奇数时，left＋1，指向数组下一位，

当arr[right]碰到偶数时，right-1，指向数组前一位，这两个while分支调换顺序。

arr[left]碰到偶数，arr[right]碰到偶数，就会继续执行在whlie(right)这个循环语句里，不进入交换元素部分；

同理arr[left]碰到奇数，就继续在while里循环，没法进入交换元素部分

二、查找数组中某个元素在哪

二分查找法（折半查找法）

//二分查找法（折半查找法），前提：有序数组
    public static int binarySearch(int[] arr,int val){//假设你传入的数组已经按从小到大排列好
        int left=0;
        int right=arr.length-1;
        while(left<=right){//这里的条件判断看代码外面解释
            int mid=(left+right)/2;
            if(arr[mid]<val){//当中间的元素比你要找的元素小，说明你要找的元素在Mid的右边
                left=mid+1;//把left下边移到Mid+1的位置，重新进入循环
            } else if (arr[mid]>val) {//当中间的元素比你要找的要大，说明你要找的元素在mid的左边
                right=mid-1;//把right移动到mid-1的位置，然后重新进入循环，开始新一轮的mid判断
            }else {//当arr[mid]==val，说明找到了，返回下标Mid告知在数组哪个位置
                return mid;
            }
        }
        return -1;//表示没找到
    }

当你输入的值比数组中最大元素还大，循环程序执行到：

left指向arr[n-1],right也指向arr[n-1]，mid=((n-1)+(n-1))/2=n-1，mid也等于数组下标的最后一个，

此时arr[mid]依然比val小，继续执行left=mid+1，那么left就大于一直没动的right，越界了，不符合循环执行条件，退出循环。

当你输入的值比数组中最小的元素还要小，循环程序执行到：

left指向arr[0],right也指向arr[0],mid=(0+0)/2=0,mid指向数组下表的第一位，

此时arr[mid]依然大于val，继续执行right=mid-1，那么right就小于一直没动的left，越界，不符合循环执行条件，退出循环。

从上述解析可以知道left<=right是判断循环条件的合适表达式

在主函数部分打印出binarySearch（arr,你要查找的值）即可

扩展

java库当中提供了二分查找法的函数，可以不用自己编写

Arrays.binarySearch(数组,data)//你要查询数字的数组，你要查询的数字

java库还提供了从小到大排序的函数

Arrays.sort(数组名)；//从小到大排序

三、数组排序

冒泡排序

public static void bubbleSort(int[] arr){
        for(int i=0;i<arr.length-1;i++){//最外层for控制趟数
            for(int j=0;j<arr.length-1-i;j++){
                    if(arr[j]>arr[j+1]){
                        int tmp=arr[j];
                        arr[j]=arr[j+1];
                        arr[j+1]=tmp;
                    }
            }

        }
    }

优化冒泡排序 

 public static void bubbleSort_01(int[] arr){
        for(int i=0;i<arr.length-1;i++){
            boolean flg=false;
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    int tmp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=tmp;
                    flg=true;
                }
            }
        if(flg==false){/*当上一趟排完，flg重新赋值为false，下一趟走完后没有进入if语句，flg依然是false，
            说明通过该走完的趟，能验证数组已经排好序，不用进行下一趟的比较*/
            break;//就不进入下一部分的交换了
            }
         }
    }

四、求数组中两个数的和为target的下标

定义数组类型的方法

//给你一个数组和一个target，请返回数组中两个数的和为target的两数的下标
    public static int[] fun3(int[] arr,int target){
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length; j++) {
                if (arr[i]+arr[j]==target){
                    return new int[]{i,j};
                }
            }

        }
        return new int[]{-1,-1};//-1不是数组的下标，用来表示数组中没有匹配的两个数
    }

在主函数中打印Arrays.toString(arr)即可输出返回的fun3数组

五、找到数组中只出现一次的元素

"^"异或符号，0^0=0,1^1=0,相同元素异或，结果等于0；

不同元素异或，结果≠0，0异或除0以外的数，结果等于该数，

public static int FindNum(int[] arr){
        int ret=arr[0];
        for (int i = 1; i < arr.length; i++) {
            ret^=arr[i];//ret=ret^arr[i];
        }
        return ret;
    }

六、给你一个数组，判断如果有连续出现3次的奇数，就返回true，否则返回false

//给你一个整数数组arr，请你判断数组中是否存在连续三个元素都是奇数的情况：如果存在，返回true,否则返回false
    public static boolean fun5(int[] arr){
        int count=0;
        for (int i=0;i<arr.length;i++) {
            if (arr[i] % 2 != 0) {//说明为奇数
                System.out.println(arr[i]);
                count++;
                if (count==3)
                    return true;
            } else {
                count = 0;
            }
        }
        return false;
    }