Javascript检查列表是否在一次交换后排序
我想检查列表是否可以通过执行最多一个交换操作进行排序，如果可以，我想返回true。否则，我想返回false 例如，输入 A=[1,2,3,4,5] 应导致true，因为它已排序 A=[1,2,5,4,3] 结果应为true，因为一次交换（涉及5和3）会对列表进行排序 A=[1,2,5,3,4] 应导致false，因为它需要多个交换进行排序 我的代码如下。如果已排序，则返回true；如果未排序，但可以使用一次交换排序，则返回undefined 有人能帮我找到问题吗Javascript检查列表是否在一次交换后排序,javascript,algorithm,sorting,swap,Javascript,Algorithm,Sorting,Swap,我想检查列表是否可以通过执行最多一个交换操作进行排序，如果可以，我想返回true。否则，我想返回false 例如，输入 A=[1,2,3,4,5] 应导致true，因为它已排序 A=[1,2,5,4,3] 结果应为true，因为一次交换（涉及5和3）会对列表进行排序 A=[1,2,5,3,4] 应导致false，因为它需要多个交换进行排序 我的代码如下。如果已排序，则返回true；如果未排序，但可以使用一次交换排序，则返回undefined 有人能帮我找到问题吗 function sol
function solution(A) {
var count=0;
for(var k=0; k<A.length; k++) //check if sorted
{
if(A[k] <= A[k+1])
count++;
else
break;
}
if (count === A.length - 1) //if already sorted return true
{
return true;
}
for(var i=0; i<A.length; i++) //if not sorted lets check
{
var temp=0;
for(var j=i+1; j<A.length; j++)
{
if(A[i] > A[j]) //swap only if A[i] > A[j]
{
temp = A[i];
A[i] = A[j];
A[j] = temp;
//check if sorted
}
}
}
}
我想检查数组是否在每次交换后排序。如何进行排序？如果不想对数组进行排序，最好计算arr[I]>arr[j]j>I的次数，如果count>=1，则返回 将此用作辅助方法：
function isArraySorted(arr){
for(var i = 0; i < arr.length ; ++i) {
if(arr[i] > arr[i+1])
return false;
}
return true;
}
function solution(A) {
if (isArraySorted(A)) return true;
for (var i = 0; i < A.length; i++) //if not sorted lets check
{
for (var j = i + 1; j < A.length; j++) {
if (A[i] > A[j]) //swap only if A[i] > A[j]
{
var temp = A[i];
A[i] = A[j];
A[j] = temp;
return isArraySorted(A); // after one swap check if it's sorted and return that value.
}
}
}
}
如果不想对数组排序，最好计算arr[i]>arr[j]j>i的次数，如果count>=1则返回 将此用作辅助方法：
function isArraySorted(arr){
for(var i = 0; i < arr.length ; ++i) {
if(arr[i] > arr[i+1])
return false;
}
return true;
}
function solution(A) {
if (isArraySorted(A)) return true;
for (var i = 0; i < A.length; i++) //if not sorted lets check
{
for (var j = i + 1; j < A.length; j++) {
if (A[i] > A[j]) //swap only if A[i] > A[j]
{
var temp = A[i];
A[i] = A[j];
A[j] = temp;
return isArraySorted(A); // after one swap check if it's sorted and return that value.
}
}
}
}
这应该符合您的计划目标
function solution(A) {
// write your code in JavaScript (Node.js 0.12)
var count=0;
for(var k=0; k<A.length; k++) //check if sorted
{
if(A[k] <= A[k+1])
count++;
else
break;
}
if (count === A.length - 1) //if already sorted return true
{
return true;
} else {//swap once where its not in order
for (var l = count+1; l<A.length;l++)
{
//Swap that and a subsequent element.
var temp = A[count];
A[count] = A[l];
A[l] = temp;
c = 0;
for(var k=0; k<A.length; k++) //check if sorted
{
if(A[k] <= A[k+1])
c++;
else
break;
}
if (c === A.length - 1) //if already sorted return true
{
return true;
}
//Swap them back
var temp = A[count];
A[count] = A[l];
A[l] = temp;
}
}
return false;
}
这应该符合您的计划目标
function solution(A) {
// write your code in JavaScript (Node.js 0.12)
var count=0;
for(var k=0; k<A.length; k++) //check if sorted
{
if(A[k] <= A[k+1])
count++;
else
break;
}
if (count === A.length - 1) //if already sorted return true
{
return true;
} else {//swap once where its not in order
for (var l = count+1; l<A.length;l++)
{
//Swap that and a subsequent element.
var temp = A[count];
A[count] = A[l];
A[l] = temp;
c = 0;
for(var k=0; k<A.length; k++) //check if sorted
{
if(A[k] <= A[k+1])
c++;
else
break;
}
if (c === A.length - 1) //if already sorted return true
{
return true;
}
//Swap them back
var temp = A[count];
A[count] = A[l];
A[l] = temp;
}
}
return false;
}
尝试每种可能的交换并检查结果的简单方法需要花费3倍于数组长度的时间。找到第一个无序对并尝试通过在每个后续元素中交换来修复它的更聪明的方法需要花费2倍的时间。排序数组并将其与原始数组进行比较的方法需要logn时间。我们能做得更好吗 是的，我们可以在线性时间内解决这个问题。我们首先寻找一对倒置的相邻元素，这意味着左边的元素比右边的元素大。如果没有这样的对，则数组已排序 否则，我们会找到最左边的一对。让我们取这对中较大的元素，即左边的元素，并称之为x。如果x是相等元素序列中的最后一个，那么我们取最左边的元素，因为当我们用较小的元素y交换x时，我们希望y出现在每个元素等于x之前 现在我们扫描到反转对的右边，寻找最早的元素，它至少和x一样大。一旦我们找到了这样一个元素，我们就把元素放在它前面，并把这个元素叫做y。如果没有这样的元素，则让y作为数组的最后一个元素 如果数组可以在一次交换中进行排序，那么交换x和y是必要的，也是足够的。考虑以下情况： 如果反向对右侧的所有元素都小于x，则必须将x移过所有元素。因此，我们用数组的最后一个元素交换x
否则，考虑X大于X的所有元素。在排序数组中，x必须出现在所有元素之前，但x必须移过小于它的元素。因此，我们发现最早的元素在倒转对的右边，至少和x一样大，我们把x换到它前面的位置
//当且仅当最多可使用一次交换对排序时，返回true。 基本功能{ 对于变量i=1；i} 尝试每种可能的交换并检查结果的简单方法需要花费3倍于数组长度的时间。找到第一个无序对并尝试通过在每个后续元素中交换来修复它的更聪明的方法需要花费2倍的时间。排序数组并将其与原始数组进行比较的方法需要logn时间。我们能做得更好吗
是的，我们可以在线性时间内解决这个问题。我们首先寻找一对倒置的相邻元素，这意味着左边的元素比右边的元素大。如果没有这样的对，则数组已排序
否则，我们会找到最左边的一对。让我们取这对中较大的元素，即左边的元素，并称之为x。如果x是相等元素序列中的最后一个，那么我们取最左边的元素，因为当我们用较小的元素y交换x时，我们希望y出现在每个元素等于x之前 现在我们扫描到反转对的右边，寻找最早的元素，它至少和x一样大。一旦我们找到了这样一个元素，我们就把元素放在它前面，并把这个元素叫做y。如果没有这样的元素，则让y作为数组的最后一个元素 如果数组可以在一次交换中进行排序，那么交换x和y是必要的，也是足够的。考虑以下情况： 如果反向对右侧的所有元素都小于x，则必须将x移过所有元素。因此，我们用数组的最后一个元素交换x否则，考虑X大于X的所有元素。在排序数组中，x必须出现在所有元素之前，但x必须移过小于它的元素。因此，我们发现最早的元素在倒转对的右边，至少和x一样大，我们把x换到它前面的位置
//当且仅当最多可使用一次交换对排序时，返回true。 基本功能{ 对于变量i=1；i}它不就是返回计数==A.length-1 | |计数==A.length-3吗？它不就是返回计数==A.length-1 | |计数==A.length-3吗？明白了。然而，对于这个测试用例[1,5,3,3,7]，它会变为假，并且应该是真的。你认为呢？我已经编辑过了。如果对数组进行了排序，或者一个交换对数组进行了排序，则新编辑将返回true。否则它将返回false。这应该返回true，因为如果我们只进行一次交换，如第二次3和5，它将被排序。所以应该是真的，明白了。然而，对于这个测试用例[1,5,3,3,7]，它会变为假，并且应该是真的。你认为呢？我已经编辑过了。如果对数组进行了排序，或者一个交换对数组进行了排序，则新编辑将返回true。否则它将返回false。这应该返回true，因为如果我们只进行一次交换，如第二次3和5，它将被排序。所以应该返回true..还不如返回count==A.length-1；最后谢谢。它为[1,5,3,3,7]返回false。为什么你这么认为？因为这不能在一个相邻的交换中排序。它可以，第二个3和第五。我不是那个否决它的人，但让我观察一下，这个代码需要二次时间。它尝试交换每个后续元素，并每次扫描整个阵列。因此，一个包含一千个元素的数组可能需要一百万次操作来检查。我的解决方案只需要线性时间，这意味着操作的数量与数组的大小成正比。它检查一个由一千个元素组成的数组，在一个常量因子中只有一千个操作；最后谢谢。它为[1,5,3,3,7]返回false。为什么你这么认为？因为这不能在一个相邻的交换中排序。它可以，第二个3和第五。我不是那个否决它的人，但让我观察一下，这个代码需要二次时间。它尝试交换每个后续元素，并每次扫描整个阵列。因此，一个包含一千个元素的数组可能需要一百万次操作来检查。我的解决方案只需要线性时间，这意味着操作的数量
与阵列的大小成比例。它在一个常数因子中只检查一千个元素的数组，但这并没有给出交换的最小数目。只有当您仅限于相邻的交换（我们不适用于此问题）时，它才为您提供最小交换数。+1适用于有效的解决方案，但这在技术上不是也适用于^2最坏的情况，因为嵌套循环吗？不，因为每个循环最多使用一次。注意每个loop.very smart anwser后面的return语句。感谢向我展示我改进代码的有效方法以及之前的解释。现在，代码只使用一个变量i来扫描数组，我为要交换的元素的索引左右引入变量。这并没有给出交换的最小数量。只有当您仅限于相邻的交换（我们不适用于此问题）时，它才为您提供最小交换数。+1适用于有效的解决方案，但这在技术上不是也适用于^2最坏的情况，因为嵌套循环吗？不，因为每个循环最多使用一次。注意每个loop.very smart anwser后面的return语句。感谢向我展示我改进代码的有效方法以及之前的解释。现在，代码只使用一个变量i来扫描数组，我为要交换的元素的索引左右引入变量。