字符串全排列

输入一个字符串，打印出该字符串中字符的所有排列。

例如输入字符串abc，则输出由字符a、b、c 所能排列出来的所有字符串

abc、acb、bac、bca、cab 和 cba。

#include <stdio.h>
#include <stdlib.h>

void swap(char *string, int a, int b) {
	char temp = string[a];
	string[a] = string[b];
	string[b] = temp;
}

int partition(char arr[], int low, int high) {
	char temp = arr[low];
	int left = low;
	int right = high;
	while (left != right) {
		while (temp <= arr[right] && left < right) {
			right--;
		}
		while (temp >= arr[left] && left < right) {
			left++;
		}
		if (left < right) {
			swap(arr, left, right);
		}
	}
	return left;
}
void quicksort(char arr[], int low, int high) {
	if (low >= high) {
		return;
	}
	char temp = arr[low];

	int pivot = partition(arr, low, high);

	arr[low] = arr[pivot];
	arr[pivot] = temp;

	quicksort(arr, low, pivot - 1);
	quicksort(arr, pivot + 1, high);
}

/*begin,end间出现与end相等的值,
 * 其排列与相等点出现的排列相同,
 * 故 不需要进行*/
int isSwap(char* str, int begin, int end) {
	int i = begin;
	while (i < end) {
		if (str[i++] == str[end]) {
			return 0;
		}
	}
	return 1;
}

void reverse(char* str, int begin, int end) {
	if (!str) {
		return;
	}
	while (begin < end) {
		int temp = str[begin];
		str[begin++] = str[end];
		str[end--] = temp;
	}
}

//递归实现:全排列
void CalcAllPermutation(char* str, int begin, int end) {
	if (begin == end) {
		puts(str);
	} else {
		int i;
		for (i = begin; i < end; i++) {
			if (isSwap(str, begin, i)) {
				swap(str, begin, i);
				CalcAllPermutation(str, begin + 1, end);
				swap(str, begin, i);
			}
		}
	}
}

//非递归实现:全排列
int CalcAllPermutation1(char* str, int begin, int end) {
	if (begin == end) {
		return 0;
	}

	int rear, prev = end - 1;
	while (begin < prev) {
		rear = prev--;
		if (str[prev] < str[rear]) {
			int pFind = end - 1;
			while (str[prev] >= str[pFind]) {
				pFind--;
			}
			swap(str, prev, pFind);
			reverse(str, rear, end - 1);
			return 1;
		}
	}
	//最大，无下一个排列
	if (prev == 0) {
		reverse((*str), begin, end - 1);
	}

	return 0;
}
int main(void) {
	char string[] = "122";
	//递归实现
		CalcAllPermutation(string, 0, strlen(string));

//非递归实现
//先降序快排
	/*quicksort(string, 0, strlen(string) - 1);
	do {
		puts(string);
	} while (CalcAllPermutation1(&string, 0, strlen(string)));
	*/return EXIT_SUCCESS;
}