练习友元函数，有元类，快排和全排列问题

写了一小段代码：

• 练习一下友元类和友元函数的声明和使用；
• 练习一下最简单的快排算法；
• 练习一下递归的方法处理全排列问题。

代码：

#include <stdlib.h>
#include <string>

class Something;

// 友元函数可以提前在类外定义，也可以不这么做
int get_data(Something& sth);

class Otherthing;
class Something
{
private:
    int data;

    // 友元类定义的位置在private,public,protected都可以
    // 友元类实现的位置在类内和类外都可以
    friend Otherthing;

    // 友元函数定义的位置在private,public,protected都可以
    // 友元函数实现的位置在类内和类外都可以
    // 即使在类内定义，也是全局可访问
    friend int get_data(Something& sth)
    {
        return sth.data;
    }
public:
    void set_data(int v)
    {
        data = v;
    }
};

class Otherthing
{
public:
    int get_data(Something& sth)
    {
        return sth.data;
    }
};

// 交换
void swap(int* p, int* q)
{
    if(p == q)
        return;
    int tmp = *p;
    *p = *q;
    *q = tmp;
}

// 打印
void print_array(int* begin, int* end)
{
    while(begin < end)
        printf("%d ", *begin++);
    printf("
");
}

// 快排
void quick_sort(int* begin, int* end)
{
    if(end - begin <= 1)
        return;

    // 定义两个迭代器
    int* p = begin+1, * q = end-1;

    // 采用最常规的，选第一个元素作为中枢点的方法
    while(p < q)
    {
        while(p < q && *p <= *begin)    // 后移p
            p++;
        while(p < q && *q > *begin)        // 前移q
            q--;
        swap(p, q);                        // 交换p,q
    }

    // 比较中枢位置的元素和第一个元素，若逆序，则交换
    if(*p < *begin)
        swap(p, begin);

    // 递归调用
    quick_sort(begin, p);
    quick_sort(p, end);
}

void full_permutation(const char* str, char* aux, int* num, int cur, const int n)
{
    if(n == cur)
    {
        printf("%s
", aux);
    }
    for(int i = 0; i < n; i++)
    {
        if(0 == num[i])            // 如果第i个字符还没有被用过
        {
            num[i] = 1;            // 标志设为1，表示该字符不能在 “后面的递归中” 再次被使用
            aux[cur] = str[i];    // 在cur位置使用第i个字符
            full_permutation(str, aux, num, cur+1, n);
            num[i] = 0;            // 清空标志，使该字符在 “迭代之后的递归中” 可以被使用
        }
    }
}

void full_permutation_aux(const char* str)
{
    int n = strlen(str);
    char* aux = new char[n+1];
    memset(aux, 0, (n+1)*sizeof(char));
    int* num = new int[n];
    memset(num, 0, n*sizeof(int));
    full_permutation(str, aux, num, 0, n);
}

int _tmain(int argc, _TCHAR* argv[])
{
    // 练习友元函数和有元类
    Something sth;
    sth.set_data(10);
    printf("%d
", get_data(sth));
    Otherthing oth;
    printf("%d
", oth.get_data(sth));

    // 练习快排
    int array[] = {6, 12, 45, 12, 78, 3, 9, 1, 89, 12, 34, 8, 18, 15};
    int len = sizeof(array)/sizeof(int);
    int* begin = array;
    int* end = array + len;
    quick_sort(begin, end);    
    print_array(begin, end);

    // 练习全排列
    const char* str = "ABCD";
    full_permutation_aux(str);

    system("pause");
    return 0;
}

输出结果：

10
10
1 3 6 8 9 12 12 12 15 18 34 45 78 89
ABCD
ABDC
ACBD
ACDB
ADBC
ADCB
BACD
BADC
BCAD
BCDA
BDAC
BDCA
CABD
CADB
CBAD
CBDA
CDAB
CDBA
DABC
DACB
DBAC
DBCA
DCAB
DCBA
请按任意键继续. . .