我正在编写一个简单的程序，如果数组排序为 false，则返回 true，并且我在 eclipse 中不断收到异常，但我不知道为什么。我想知道是否有人可以查看我的代码并解释为什么我得到一个数组越界异常。
public static boolean isSorted(int[] a)
{
int i;
for(i = 0; i < a.length; i ++);{
if (a[i] < a[i+1]) {
return true;
} else {
return false;
}
}
}
public static void main(String[] args)
{
int ar[] = {3,5,6,7};
System.out.println(isSorted(ar));
}
让我们看一下您构建的循环的更简洁版本：
for (i = 0; i < a.length; i++); {
if (a[i] < a[i + 1]) {
return true;
}
else {
return false;
}
}
我应该首先指出原始循环中的语法错误。也就是说，在开始循环体的;花括号 ( ) 之前有一个分号 ( )。{应该删除该分号。另请注意，我重新格式化了代码的空白以使其更具可读性。
现在让我们讨论一下循环内部发生了什么。循环迭代器i从 开始0并结束于a.length - 1。由于i用作数组的索引，因此指出它a[0]是数组的第一个元素和a[a.length - 1]最后一个元素是有意义的。然而，在你的循环体中，你也写了一个索引i + 1。这意味着如果i等于a.length - 1，则您的索引等于a.length数组边界之外的索引。
该函数isSorted也有相当大的问题，因为它第一次返回 true 而第一次不返回a[i] < a[i+1]false；因此，它实际上并不检查数组是否已排序！相反，它只检查前两个条目是否已排序。
具有类似逻辑但检查数组是否确实已排序的函数是
public static boolean isSorted(int[] a) {
// Our strategy will be to compare every element to its successor.
// The array is considered unsorted
// if a successor has a greater value than its predecessor.
// If we reach the end of the loop without finding that the array is unsorted,
// then it must be sorted instead.
// Note that we are always comparing an element to its successor.
// Because of this, we can end the loop after comparing
// the second-last element to the last one.
// This means the loop iterator will end as an index of the second-last
// element of the array instead of the last one.
for (int i = 0; i < a.length - 1; i++) {
if (a[i] > a[i + 1]) {
return false; // It is proven that the array is not sorted.
}
}
return true; // If this part has been reached, the array must be sorted.
}
对于使用 Java 8 及更高版本的任何人，这里有一个简单的单行：
public static boolean isSorted(int[] array) {
return IntStream.range(0, array.length - 1).noneMatch(i -> array[i] > array[i + 1]);
}
或逻辑等效的替代方案：
public static boolean isSorted(int[] array) {
return IntStream.range(0, array.length - 1).allMatch(i -> array[i] <= array[i + 1]);
}
使用此表达式，a[i+1]您将跑出数组的末尾。
如果必须与下一个元素进行比较，请尽早停止迭代 1 元素（并消除分号，Java 会将其解释为for循环体）：
// stop one loop early ---v v--- Remove semicolon here
for(i = 0; i < a.length - 1; i ++){
int i;
for(i = 0; i < a.length - 1 && a[i] < a[i+1]; i++){}
return (i == a.length - 1);
要检查数组是否已排序，我们可以比较数组中的相邻元素。
检查null&的边界条件a.length == 0
public static boolean isSorted(int[] a){
if(a == null) {
//Depends on what you have to return for null condition
return false;
}
else if(a.length == 0) {
return true;
}
//If we find any element which is greater then its next element we return false.
for (int i = 0; i < a.length-1; i++) {
if(a[i] > a[i+1]) {
return false;
}
}
//If array is finished processing then return true as all elements passed the test.
return true;
}
a[i+1]什么时候i == a.length会给你这个错误。
例如，在长度为 10 的数组中，您有 0 到 9 个元素。
a[i+1]当i为 9 时，将显示a[10]，这是超出范围的。
修理：
for(i=0; i < a.length-1;i++)
此外，您的代码不会检查整个数组，只要调用 return，检查循环就会终止。您只是检查第一个值，并且只检查第一个值。
并且，您的 for 循环声明后有一个分号，这也会导致问题
您不应该使用a[i+1]，因为该值可能会或可能不会离开数组。
例如：
A = {1, 2, 3}
// A.length is 3.
for(i = 0; i < a.length; i ++) // A goes up to 3, so A[i+1] = A[4]
要解决此问题，只需提前停止循环。
int i;
for(i = 0; i < a.length - 1; i ++);{
if (a[i] < a[i+1]) {
return true;
}else{
return false;
}
}
如果要检查数组是按 DESC 还是 ASC 排序的：
boolean IsSorted(float [] temp)
{
boolean result=true,result2=true;
for (int i = 0; i < temp.length-1; i++)
if (temp[i]< temp[i + 1])
result= false;
for (int i = 0; i < temp.length-1; i++)
if (temp[i] > temp[i + 1])
result2= false;
return result||result2;
}
bool checkSorted(int a[], int n) {
for (int i = 1; i < n-1; i++) {
if (a[i] > a[i-1]) {
return false;
}
}
return true;
}
降序数组也被排序。为了同时考虑升序和降序数组，我使用以下内容：
public static boolean isSorted(int[] a){
boolean isSorted = true;
boolean isAscending = a[1] > a[0];
if(isAscending) {
for (int i = 0; i < a.length-1; i++) {
if(a[i] > a[i+1]) {
isSorted = false;
break;
}
}
} else {//descending
for (int i = 0; i < a.length-1; i++) {
if(a[i] < a[i+1]) {
isSorted = false;
break;
}
}
}
return isSorted;
}
public static boolean isSorted(int[] a)
{
int i,count=0;
for(i = 0; i < a.length-1; i++);{
if (a[i] < a[i+1]) {
count=count+1;
}
}
if(count==a.length-1)
return true;
else
return false;
}
public static void main(String[] args)
{
int ar[] = {3,5,6,7};
System.out.println(isSorted(ar));
}
在这里，这是检查数组是否排序的代码，如果已排序，则返回 true，否则返回 false。希望您理解该方法。
如果一个数组不是按升序或降序排列的，那么它就不会被排序。
我将检查相邻元素是否已排序。如果任何元素小于其前一个元素，则它不按升序排序。
public static boolean isAscendingOrder(int[] a)
{
for ( int i = 0; i < a.length - 1 ; i++ ) {
if ( a[i] > a[i+1] )
return false;
}
return true;
}
// Same with Desending order
public static boolean isDescendingOrder(int[] a)
{
for ( int i = 0; i < a.length - 1 ; i++ ) {
if ( a[i] < a[i+1] )
return false;
}
return true;
}
public static boolean isSorted(int[] a)
{
return isAscendingOrder(a) || isDescendingOrder(a);
}
此函数检查数组是否处于排序顺序，无论其顺序如何，即升序或降序。
boolean checkElements(int arr[], int first, int last) {
while(arr.length > first) {
if(arr[i] > arr[last-1]) {
if(arr[i] > arr[i+1])
return checkElements(arr, first+1, first+2);;
return false;
}else {
if(arr[i] < arr[i+1])
return checkElements(arr, first+1, first+2);
return false;
}
}
return true;
}
every()方法测试数组中的所有元素是否通过提供的函数实现的测试。
arr.every(function (a, b) {
return a > b;
});
var arr = [1,2,3] // true
var arr = [3,2,1] // false