Algorithm 我正在努力为我的家庭作业找到有效的解决办法。冒泡排序还是插入排序？

大家好，我有个问题。下面是我的任务：

设A[]是长度为N的自然数数组，它是部分排序的，即存在这样的索引i（0 对于这个问题，哪种方法更好？冒泡排序还是插入排序？还是有更有效的解决方案？对于这项任务，我更喜欢气泡排序，但我愿意接受其他意见

static void bubbleSort(int arr[], int n) 
{ 
    int i, j, temp; 
    boolean swapped; 
    for (i = 0; i < n - 1; i++)  
    { 
        swapped = false; 
        for (j = 0; j < n - i - 1; j++)
        { 
            if (arr[j] > arr[j + 1])  
            { 
                // swap arr[j] and arr[j+1] 
                temp = arr[j]; 
                arr[j] = arr[j + 1]; 
                arr[j + 1] = temp; 
                swapped = true; 
            } 
        } 


        if (swapped == false) 
            break; 
    } 
} 

static void printArray(int arr[], int size) 
{ 
    int i; 
    for (i = 0; i < size; i++) 
        System.out.print(arr[i] + " "); 
    System.out.println(); 
}


 public static void main(String args[]) 
{ 
    int arr[] = { 1, 8, 45, 12, 22, 11, 90 }; 
    int n = arr.length; 
    bubbleSort(arr, n); 
    System.out.println("Sorted array: "); 
    printArray(arr, n); 
} 

static void bubbleSort（int-arr[]，int-n）
{ 
int i，j，温度；
布尔交换；
对于（i=0；iarr[j+1]）
{ 
//交换arr[j]和arr[j+1]
温度=arr[j]；
arr[j]=arr[j+1]；
arr[j+1]=温度；
交换=真；
} 
} 
如果（交换==false）
打破
} 
} 
静态void打印数组（int arr[]，int size）
{ 
int i；
对于（i=0；i

---

}气泡排序算法的复杂度为O（n^2）。即使使用

if（swaped==false）中断这无助于降低复杂性（尝试{2,3,4,5,1}，您会发现）

由于存在这样的索引
i（0
，子数组
A[0]，…，A[i]
被递增排序，子数组
A[i+1]，…，A[N]
也被递增排序。这个问题可以在O（N）运行时复杂性中解决。如果我们可以找到索引
i
，其中
A[0:i]和A[i+1:n]被排序
，那么我们可以认为这个问题是将两个排序的数组合并成一个数组，可以在O（n）时间内完成。算法如下所示：

void sortPartialSortedArray(int arr[], int n) 
{
    int pos = 0; 
    // find the position for which arr[0:pos] and arr[pos+1:n] is sorted
    for(int i=0; i+1<n; i++) {
        if(arr[i]>arr[i+1]) {
            pos = i; 
        }
    }

    int i = pos, j= n-1;

    // sort it from last position
    while(i>=0 && j>=0) {
        if(arr[i] > arr[j]) {
            swap(arr[i],arr[j]);
        }
        j--;
        if(i==j) {
            i--;
        }
    }
}

void sortPartialSortDarray（int arr[]，int n）
{
int pos=0；
//查找对arr[0:pos]和arr[pos+1:n]进行排序的位置
对于（int i=0；i+1arr[i+1]）{
pos=i；
}
}
int i=pos，j=n-1；
//从最后一个位置排序
而（i>=0&&j>=0）{
if（arr[i]>arr[j]）{
掉期（arr[i]，arr[j]）；
}
j--；
如果（i==j）{
我--；
}
}
}
欢迎来到StackOverflow！由于这听起来像是一个家庭作业问题，我建议尝试使用示例数据并调试代码，或者使用调试器，或者在代码中使用print语句，并查看执行顺序以及执行的操作数。在这里要求回答对你没有（有效）帮助。请同时阅读感谢您的回答。是的，你们是对的，这是一个家庭作业问题，但重点是我正在努力准确地理解。我不是在问答案。我选择冒泡排序，因为数组已经部分排序，我必须对所有数组进行排序，然后冒泡排序将提供最短的排序时间。插入排序将花费最长的时间，因为冒泡排序似乎是一个更好的选择。你可以说对，但假设“让a[]是长度为N的自然数数组”，那么你会选择哪种算法，为什么？我听不懂这部分。编辑：经过小搜索后，我完全理解了你的意思，但我仍然有疑问，如果我们有更多的元素，那么冒泡排序就不会更有用了？两种算法都有最坏的情况：O（n2）和最佳情况：O（n）空间复杂度也是一样的：O（1）@RamazanAçıkgöz如果我会生气，我会克制自己不回答：）别担心，我只是想帮你把你的问题弄清楚，让人们更容易理解。很好的解决方案现在我明白你的意思了。找到被排序的位置后，开始从那里排序，然后将两个排序的数组合并为一个数组！我没有从这个角度思考。我只想对数组进行排序，最小复杂度为O（n2），这就足够了。但真的很感谢你的解释，你打开了我的心扉。很高兴我能帮上忙@RamazanAçıkgöz在stackoverflow中表达感谢的方式是放弃投票。