基于指针的冒泡排序函数

基于指针的冒泡排序函数

使用在使用数组排序时，如果我们使用函数，就会面临数据传输的问题：例如其中的交换步骤写成函数，就会存在只在该函数中交换，而无法影响主函数的数值。

如果我们不使用指针，那么要想返回多个值就只能使用函数返回map、数组或是封装一个实体类。

例如如下的java实现冒泡排序：

public class Bubble {
    
    
    public static int[] bubbleArray(int[] arr) {
    
    
        for (int i = 0; i < arr.length - 1; ++i) {
    
    
            for (int j = 0; j < arr.length - i - 1; ++j) {
    
    
                if (arr[j] > arr[j + 1]) {
    
    
                    int t[] = swap2(new int[]{
    
    arr[j], arr[j + 1]});
                    arr[j] = t[0];
                    arr[j + 1] = t[1];
                }
            }
        }
        return arr;
    }

    public static int[] swap2(int[] arr) {
    
    
        arr[0] += arr[1];
        arr[1] = arr[0] - arr[1];
        arr[0] -= arr[1];
        return arr;
    }
}

class Test {
    
    
    public static void main(String[] args) {
    
    
        int[] array = Bubble.bubbleArray(new int[]{
    
    4, 2, 8, 0, 5, 7, 1, 3, 9});
        for (int i : array) {
    
    
            System.out.println(i);
        }
    }
}

在这个java实现中，使用数组传递各个函数之间的值，bubbleArray()函数负责双循环，swap2()函数负责交换数值。当然在这种情况下不如直接实现数值交换，这里我们为了体现使用指针的方便之处还是使用的函数来交换数值。

使用指针的C++版本：

#include<iostream>

using namespace std;
void swap2(int * p1, int *p2)
{
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}

void bubble(int *arr, int len)
{
    for (int i = 0; i < len - 1; ++i) {
        for (int j = 0; j < len-i-1; ++j) {
            if (arr[j] > arr[j+1]){
                swap2(&arr[j], &arr[j + 1]);
            }
        }
    }
}

void priarr( const int *arr, int len)
{
    for (int i = 0; i < len; ++i) {
        cout << arr[i] << " ";
    }
}

int main() {

    int arr[9] = {4, 2, 8, 0, 5, 7, 1, 3, 9};

    int len = sizeof(arr)/sizeof(arr[0]);
    bubble(arr, len);
    priarr(arr, len);

    system("pause");

    return 0;
}

使用指针时，我们直接实现数字对应地址的交换，便可以无序数值传递，直接进行内容修改。将函数中的形参改为指针也可以减少内存空间，而且不会复制出新的副本。