第一个交换功能有什么问题？

What's wrong with the first swaping function?

本文关键字：问题 什么 交换 功能 第一个      更新时间：2023-10-16

我正在编写一个代码来生成数组元素的排列。我编写了两种不同类型的交换函数，一种使用临时存储工作正常，而另一种不使用任何临时存储的函数不会生成输出。为什么会这样？？

以下代码工作正常 

#include<iostream>
#include<cstdio>
using namespace std;
int tt=0;
void swap1 (int v[], int i, int j) {
    int t;
    t = v[i];
    v[i] = v[j];
    v[j] = t;
}   
void permute(int arr[],int n,int index)
{
     if(index==n)
                {
                for(int i=0;i<n;i++) printf ("%c", arr[i]) ;
                printf("n");
                tt++;
                }
     else
         for(int j=index; j < n ;j++)
         {
           swap1(arr,index,j);
           permute(arr,n,index+1); 
           swap1(arr,j,index);           
         }        
}
int main()
{
    int arr[]={'a','b','c','d'};
    permute(arr,4,0);
    cout<<endl;
    printf("%dn",tt);
    getchar();
}
output:
acbd
acdb
adcb
adbc
bacd
badc
bcad
bcda
bdca
bdac
cbad
cbda
cabd
cadb
cdab
cdba
dbca
dbac
dcba
dcab
dacb
dabc
24

虽然以下代码不输出排列：

#include<iostream>
#include<cstdio>
using namespace std;
int tt=0;
void swap(int v[],int i,int j)
{
     v[i]= v[i] + v[j];
     v[j]= v[i] - v[j];
     v[i]= v[i] - v[j];
}
void permute(int arr[],int n,int index)
{
     if(index==n)
                {
                for(int i=0;i<n;i++) printf ("%c", arr[i]) ;
                printf("n");
                tt++;
                }
     else
         for(int j=index; j < n ;j++)
         {
           swap(arr,index,j);
           permute(arr,n,index+1); 
           swap(arr,j,index);           
         }        
}
int main()
{
    int arr[]={'a','b','c','d'};
    permute(arr,4,0);
    cout<<endl;
    printf("%dn",tt);
    getchar();
}
output:












24

为了你相信（或其他）的任何神灵的爱，请不要使用像你的第二个交换函数（或可怕的异或交换技巧）那样的丑陋黑客。

它们是完全不必要的，并且通常比典型的临时变量解决方案慢。它们还会导致你的代码出现在像The Daily WTF这样的网站上，一代又一代的程序员（他们必须保持这样的笨拙）将在未来几个世纪诅咒你的名字：-）

而且，无论如何，如果您"交换"的两个元素是相同的元素，它们将不起作用，因为当您这样做的那一刻：

v[i]= v[i] + v[j];

如果i和j值相同，则您丢失了其他步骤工作所需的信息。

您可以在下面看到此操作。假设您有两个不同的变量，a = 20 和 b = 30 。完成您的步骤：

a = a + b;  // a <- (20 + 30) = 50, b still = 30.
b = a - b;  // b <- (50 - 30) = 20, a still = 50.
a = a - b;  // a <- (50 - 20) = 30, b still = 20.

它们是交换的，尽管你可能想研究溢出和编码方案的边缘情况，这些方案不是两个补码（无论如何，在 C 中，不确定C++是否允许 1 的补码或符号量级）。

但是，让我们看看当a和b都是同一个变量（不是相同的值，而是实际的相同变量，如引用）时会发生什么。所以它们"都"的值为 20，你会期望它们在交换后仍然是 20，但让我们来看看：

a = a + b;  // a <- (20 + 20) = 40, AND b = 40 as well.
b = a - b;  // b <- (40 - 40) =  0, AND a =  0 as well.
a = a - b;  // a <- ( 0 -  0) =  0, AND b =  0 as well.

这不是你真正期望的结果。

void swap(int v[],int i,int j)
{
     v[i]= v[i] + v[j];
     v[j]= v[i] - v[j];
     v[i]= v[i] - v[j];
}

i == j时不起作用（然后将 v[i] 设置为 0），这是循环中发生的事情

for (int j = index; j < n; ++j) {
    swap(arr, index, j);
相关文章：