冒泡排序法，两个数组内容的互换，两个变量之间的交换

两个变量之间的交换，通过查阅资料，有如下四种常见方法：

1.利用一个中间变量实现交换

　　int a, b;

　　int temp;

　　temp = a;

　　a = b;

　　b = temp;

　　2.利用+-操作实现

　　int a, b;　　　　//a = 1  b = 2

　　a = a + b;　　　//a = 3 b = 2

　　b = a - b;　　//b = 1 a = 3

　　a = a - b;　　//a = 2 b = 1

　　3.利用乘除操作实现

　　int a, b;

　　a = a * b;

　　b = a / b;

　　a = a / b;

　　4.利用异或操作实现(当a，b相等时，不可用)

　　int a, b;

　　a = a ^ b;

　　b = a ^ b;

 　  a = a ^ b;

 

数组的冒泡排序法：

冒泡排序是最简单的排序方法，理解起来容易。虽然它的计算步骤比较多，不是最快的，但它是最基本的，初学者一定要掌握。

冒泡排序的原理是：从左到右，相邻元素进行比较。每次比较一轮，就会找到序列中最大的一个或最小的一个。这个数就会从序列的最右边冒出来。

以从小到大排序为例，第一轮比较后，所有数中最大的那个数就会浮到最右边；第二轮比较后，所有数中第二大的那个数就会浮到倒数第二个位置……就这样一轮一轮地比较，最后实现从小到大排序。

比如对下面这个序列进行从小到大排序：

90  21  132  -58  34

第一轮：
1) 90 和 21比，90>21，则它们互换位置：

21  90  132  -58  34

2) 90 和 132 比，90<132，则不用交换位置。
3）132 和 –58 比，132>–58，则它们互换位置：

21  90  -58  132  34

4）132 和 34 比，132>34，则它们互换位置：

21  90  -58  34  132

到此第一轮就比较完了。第一轮的结果是找到了序列中最大的那个数，并浮到了最右边。

比较时，每轮中第 n 次比较是新序列中第 n 个元素和第 n+1 个元素的比较（假如 n 从 1 开始）。

第二轮：
1) 21 和 90 比，21<90，则不用交换位置。
2) 90 和 –58 比，90>–58，则它们互换位置：

21  -58  90  34  132

3) 90 和 34 比，90>34，则它们互换位置：

21  -58  34  90  132

到此第二轮就比较完了。第二轮的结果是找到了序列中第二大的那个数，并浮到了最右边第二个位置。

第三轮：
1) 21 和 –58 比，21>–58，则它们互换位置：

-58  21  34  90  132

2) 21 和 34 比，21<34，则不用交换位置。到此第三轮就比较完了。第三轮的结果是找到了序列中第三大的那个数，并浮到了最右边第三个位置。第四轮：1) –58 和 21 比，–58<21，则不用交换位置。至此，整个序列排序完毕。从小到大的序列就是“–58 21 34 90 132”。从这个例子中还可以总结出，如果有 n 个数据，那么只需要比较 n–1 轮。而且除了第一轮之外，每轮都不用全部比较。因为经过前面轮次的比较，已经比较过的轮次已经找到该轮次中最大的数并浮到右边了，所以右边的数不用比较也知道是大的

 拓展：

通过在vs上调试：运用了引用第三变量和异或法分别调试

引入第三变量法：

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int i, j, tem;
    int arr1[] = { 81, 51, 62, 84, 74, 21, 32, 16, 58, 63, 19, 54, 23, 98, 47, 55 };
    for (i = 0; i< 15; i++){
        for (j = 0; j < 15 - i; j++){
            if (arr1[j] < arr1[j + 1]){
                tem = arr1[j];
                arr1[j] = arr1[j + 1];
                arr1[j + 1] = tem;
            }
        }
    }
    for (i = 0; i < 15; i++){
        printf("%d
", arr1[i]);
    }
    system("pause");
    return 0;
} 

 

异或法：

冒泡排序法
#include <stdio.h>
#include <stdlib.h>
int main()
{
    int i, j, k;
    int arr[] = { 8, 6, 7, 86, 9, 3, 69 };
    k = sizeof(arr) / sizeof(arr[0]);
    for (i = 1; i <k ; i++){
        for (j = 0; j < k-i; j++){
            if (arr[j]>arr[j + 1]){
                arr[j + 1] = arr[j+1]^arr[j];
                arr[j] = arr[j + 1]^arr[j];
                arr[j + 1] = arr[j + 1] ^ arr[j];
            }
        }
    }
    for (i = 0; i < k; i++){
        printf("%d
", arr[i]);
    }
    system("pause");
    return 0;
}

 

 

 

程序中，为什么每轮比较的次数是 j<k-i，而不是 j<k–1？

因为冒泡排序有一个特点，这个程序是从大到小排序，所以第一轮排序以后，
最小的数就会浮到最右面；第二轮排序以后，第二小的数会浮到倒数第二个位置；
第三轮排序以后，第三小的数会浮到倒数第三个位置……也就是说，排序多少轮，
就有多少个数字已经按排序要求排好了，它们不需要再比较。写 j<k–1 也可以，
只不过程序在执行时多做了许多无用功

两个数组内容的互换(用第三变量法和加减法)：

 

引用第三变量法：

#include <stdio.h>
int main()
{
    int arr1[] = { 1, 3, 5, 7, 9 };
    int arr2[] = { 3, 4, 5, 6, 7 };
    int tmp;
    int i = 0;
    for (i = 0; i < sizeof(arr1) / sizeof(arr1[0]); i++)
    {
        tmp = arr1[i];
        arr1[i] = arr2[i];
        arr2[i] = tmp;
    }
    for (i = 0; i < sizeof(arr1) / sizeof(arr1[0]); i++)
    {
        printf("%d ", arr1[i]);
    }
    printf("
");
    for (i = 0; i < sizeof(arr1) / sizeof(arr1[0]); i++)
    {
        printf("%d ", arr2[i]);
    }
    printf("
");
    return 0;
}

加减法： 

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int arr1[] = { 2, 3, 5, 6, 4, 7, 8, 9, 11 };
    int arr2[]= {5, 6, 9, 8, 7, 1, 2, 3, 44};
    int i;
    for (i = 0; i < 9; i++){
        arr1[i] = arr1[i] + arr2[i];
        arr2[i] = arr1[i] - arr2[i];
        arr1[i] = arr1[i] - arr2[i];
    }
    for (i = 0; i < 9; i++){
        printf("%d ", arr1[i]);
    }
    printf("
");
    for (i = 0; i < 9; i++){
        printf("%d ", arr2[i]);
    }

    system("pause");
    return 0;
}

异或法：

用异或法互换
#include <stdio.h>
#include <stdlib.h>
int main()
{
    int arr1[] = { 2, 3, 5, 6, 4, 7, 8, 9, 11 };
    int arr2[] = { 5, 6, 9, 8, 7, 1, 2, 3, 44 };
    int i;
    for (i = 0; i < 9; i++){
        arr1[i] = arr1[i] ^ arr2[i];
        arr2[i] = arr1[i] ^ arr2[i];
        arr1[i] = arr1[i] ^ arr2[i];

    }
    for (i = 0; i < 9; i++){
        printf("%d ", arr1[i]);
    }
    printf("
");
    for (i = 0; i < 9; i++){
        printf("%d ", arr2[i]);
    }

    system("pause");
    return 0;
}

运行结果如下：