Java 为什么'；如果数组按降序排序，二进制搜索方法是否有效？

二进制搜索方法用于从排序后的数组中找出它没有执行的值。我知道这个问题需要按降序排序，但如果有人能帮我解决这个问题，那就行不通了。 降序方法是一种选择排序（如果有帮助的话）。 我认为问题在于该方法只能从升序数组中找到值，但不知道如何使其在降序数组中工作

package project;

import java.io.*;
import java.util.*;
import java.util.Scanner;

public class project {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int Size;//size of the array
        int order; // ascending or descending order
        System.out.println("Put in the amount of expenses you have");
        Size = sc.nextInt();//User input for the amount of expenses
        System.out.println("put in all your expenses");
        int userInput[] = new int[Size];// what the users expenses are
        for (int i = 0; i < userInput.length; i++)//This loop is for if the i value is smaller than user input then put in more values to complete the array
            userInput[i] = sc.nextInt();
        System.out.println("do you want it ascending or descending order. If you want it in ascending press 1 or if you want descending press 2");
        order = sc.nextInt();// select if they wanted it in ascending or descending order
        System.out.print("expenses not sorted : ");
        printExpenses(userInput);
        if (order == 1) {
            expensesAscending(userInput);// If order is equal to one then sort in ascending else if it is equal to 2 then order it descending
        } else if (order == 2) {
            expensedescending(userInput);

        }
        int ans = binarySearch(userInput, 0, Size, 10);
        System.out.println(ans);
        if(ans == -1)
            System.out.println("Key not found");
          else
            System.out.println("Key found at position " + (ans));
    }

    public static void printExpenses(int[] arr) {
        // this is were it is printed
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i] + "$");
        }
    }

    public static void expensedescending(int arr[]) {
        // This is were the selection sort starts
        int N = arr.length;
        for (int i = 0; i < N; i++) {
            int small = arr[i];
            int pos = i;
            for (int j = i + 1; j < N; j++) {
                if (arr[j] > small) {
                    small = arr[j];
                    pos = j;
                }
            }
            int temp = arr[pos];
            arr[pos] = arr[i];
            arr[i] = temp;
            System.out.println(": ");
            // Printing array after pass
            printExpenses(arr);
        }
    }

    public static void expensesAscending(int arr[]) {
        int N = arr.length;
        for (int i = 1; i < N; i++) {
            int j = i - 1;
            int temp = arr[i];
            while (j >= 0 && temp < arr[j]) {
                arr[j + 1] = arr[j];
                j--;
                ;
            }
            arr[j + 1] = temp;
            System.out.println(": ");
            // Printing array after pass
            printExpenses(arr);
        }
    }
    static int binarySearch(int[] array, int left, int right, int key) {
        if (left > right) {
          return -1;
        }

        int mid = (left + right) / 2;

        if (array[mid] == key) {
          return mid;
        }

        if (array[mid] > key) {
          return binarySearch(array, left, mid - 1, key);
        }

        return binarySearch(array, mid + 1, right, key);
      }



}

成套工程；
导入java.io.*；
导入java.util.*；
导入java.util.Scanner；
公共类项目{
公共静态void main（字符串[]args）{
扫描仪sc=新的扫描仪（System.in）；
int Size；//数组的大小
int顺序；//升序或降序
System.out.println（“输入您拥有的费用金额”）；
Size=sc.nextInt（）；//用户输入费用金额
System.out.println（“投入所有费用”）；
int userInput[]=new int[Size]；//用户的费用是多少
for（int i=0；i较小）{
小=arr[j]；
pos=j；
}
}
内部温度=arr[pos]；
arr[pos]=arr[i]；
arr[i]=温度；
System.out.println（“：”）；
//通过后打印阵列
印刷费用（arr）；
}
}
公共静态无效费用结算（国际arr[]{
int N=阵列长度；
对于（int i=1；i=0&&temp右）{
返回-1；
}
int mid=（左+右）/2；
if（数组[mid]==键）{
中途返回；
}
if（数组[mid]>键）{
返回二进制搜索（数组，左，中-1，键）；
}
返回二进制搜索（数组，中间+1，右键，键）；
}
}

问题是，如果键小于中间元素，则需要在上半部分搜索。否则在下半部分搜索

static int binarySearch(int[] array, int left, int right, int key) {
    if (left > right) {
      return -1;
    }

    int mid = (left + right) / 2;

    if (array[mid] == key) {
      return mid;
    }

    if (array[mid] > key) {
      return binarySearch(array, mid + 1, right, key);
    }

    return binarySearch(array, left, mid - 1, key);
  }

---

您正在尝试对降序排序数组中的升序排序数组进行

二进制搜索。更改
方法头和方法体，如下所示：

int ans = binarySearch(userInput, 0, Size, 10,order);  // order you got from user 

现在，此
二进制搜索将对数组的升序和降序都有效：

    static int binarySearch(int[] array, int left, int right, int key,int sorting) 
    {
        if (left > right) 
        {
          return -1;
        }

        int mid = (left + right) / 2;

        if (array[mid] == key) 
        {
          return mid;
        }

        if(sorting == 2)   // if array is sorted in descending order
        {
            if (array[mid] > key) 
            {
              return binarySearch(array, mid+1, right, key,sorting );
            }
            return binarySearch(array, left, mid-1, key,sorting );
        }
        else // if array is sorted in ascnending order
        {
            if (array[mid] > key) 
            {
                return binarySearch(array, left, mid - 1, key,sorting );
            }

            return binarySearch(array, mid + 1, right, key,sorting );
        }
    }