#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
typedef int bool;
#define true 1
#define false 0
void bubbleSort(int arr[], int n);
void bubbleSort2(int arr[] , int n);
void bubbleSort3(int arr[], int n);
void insertionSort(int arr[], int n);
void shellSort(int arr[], int n);
void selectionSort(int arr[], int n);
void mergeSort_iteration(int arr[], int n);
void mergeSort_recursion(int arr[], int n);
void heapSort(int arr[], int n);
void quickSort(int arr[], int n);
void countSort(int arr[], int n);
void bucketSort(int arr[], int n);
void radixSort_LSD(int arr[], int n);
int main(int argc, const char * argv[]) {
int arr[] = {20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0};
int num = sizeof(arr)/sizeof(arr[0]);
printf("Before Sorting:");
for (int i = 0; i<num; i++) {
printf("%d ",arr[i]);
}
printf("\n");
radixSort_LSD(arr, num);
printf("After Sorting:");
for (int i = 0; i<num; i++) {
printf("%d ",arr[i]);
}
printf("\n");
return 0;
}
void swap(int *a, int *b){
int temp = *a;
*a = *b;
*b = temp;
}
void bubbleSort(int arr[], int n){
for (int i = 0; i<n; i++) {
for (int j = 0; j<n-i-1; j++) {
if (arr[j] > arr[j+1]) {
swap(&arr[j], &arr[j+1]);
}
}
}
}
void bubbleSort2(int arr[], int n){
for (int i = 0; i<n; i++) {
bool isOrdered = true;
for (int j = 0; j<n-i-1; j++) {
if (arr[j] > arr[j+1]) {
swap(&arr[j], &arr[j+1]);
isOrdered = false;
}
}
if (isOrdered) {
break;
}
}
}
void bubbleSort3(int arr[], int n){
int k = n;
int tag = k;
while (tag) {
k = tag;
tag = 0;
for (int i = 0; i<k-1; i++) {
if (arr[i] > arr[i+1]) {
swap(&arr[i], &arr[i+1]);
tag = i+1;
}
}
}
}
void insertionSort(int arr[], int n){
for (int i = 1; i<n; i++) {
int k = i;
while (k && arr[k]<arr[k-1]) {
swap(&arr[k], &arr[k-1]);
k--;
}
}
}
void shellInsertionSort(int arr[], int n, int inc){
for (int i = 0; i<inc; i++) {
for (int j = 0; j<n; j+=inc) {
int k = j;
while (k-i && arr[k] < arr[k-inc]) {
swap(&arr[k], &arr[k-inc]);
k -= inc;
}
}
}
}
void shellSort(int arr[], int n){
int inc = n/2;
while (inc) {
shellInsertionSort(arr, n, inc);
inc /= 2;
}
}
void selectionSort(int arr[], int n){
for (int i = 0; i<n; i++) {
int minIndex = i;
for (int j = i; j<n; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
if (minIndex != i) {
swap(&arr[minIndex], &arr[i]);
}
}
}
void merge_iteration(int arr[], int *temArray, int n){
int inc = 1;
while (inc<n) {
for (int i = 0; i<n; i+=inc*2) {
int lBegin = i;
int lEnd = i+inc-1;
int rEnd = (i+inc*2-1)>n-1?n-1:(i+inc*2-1);
int lHalfIndex = lBegin;
int rHalfIndex = lEnd+1;
int temIndex = lBegin;
while (lHalfIndex<=lEnd && rHalfIndex<=rEnd) {
if (arr[lHalfIndex]<=arr[rHalfIndex]) {
temArray[temIndex++] = arr[lHalfIndex++];
}else{
temArray[temIndex++] = arr[rHalfIndex++];
}
}
while (lHalfIndex<=lEnd) {
temArray[temIndex++] = arr[lHalfIndex++];
}
while (rHalfIndex<rEnd) {
temArray[temIndex++] = arr[rHalfIndex++];
}
for (int i = temIndex-1; i>=lBegin; i--) {
arr[i] = temArray[i];
}
}
inc *= 2;
}
}
void mergeSort_iteration(int arr[], int n){
int *temArray;
temArray = (int *)malloc(sizeof(int)*n);
if (temArray == NULL) {
printf("error to alloc memory!");
exit(1);
}
merge_iteration(arr, temArray, n);
free(temArray);
}
void merge_recursion(int arr[], int temArr[], int lBegin, int lEnd, int rEnd){
if (lBegin < rEnd) {
merge_recursion(arr, temArr, lBegin, (lBegin+lEnd)/2, lEnd);
merge_recursion(arr, temArr, lEnd+1, (lEnd+1+rEnd)/2, rEnd);
int lHalfIndex = lBegin;
int rHalfIndex = lEnd+1;
int temIndex = lBegin;
while (lHalfIndex <= lEnd && rHalfIndex <= rEnd) {
if (arr[lHalfIndex] <= arr[rHalfIndex]) {
temArr[temIndex++] = arr[lHalfIndex++];
}else{
temArr[temIndex++] = arr[rHalfIndex++];
}
}
while (lHalfIndex <= lEnd) {
temArr[temIndex++] = arr[lHalfIndex++];
}
while (rHalfIndex <= rEnd) {
temArr[temIndex++] = arr[rHalfIndex++];
}
for (int i = temIndex-1; i>=lBegin; i--) {
arr[i] = temArr[i];
}
}
}
void mergeSort_recursion(int arr[], int n){
int *temArray;
temArray = (int *)malloc(n * sizeof(int));
if (temArray == NULL) {
printf("error to alloc memory!");
exit(1);
}
int centerIndex = (n-1)/2;
merge_recursion(arr, temArray, 0, centerIndex, n-1);
free(temArray);
}
void adjustHeap(int arr[],int n,int nodeIndex){
int leftIndex = 2*nodeIndex+1;
while (leftIndex < n) {
int minIndex;
if ((leftIndex+1) <= (n-1)) {
minIndex = arr[leftIndex]<arr[leftIndex+1]?leftIndex:leftIndex+1;
}else{
minIndex = leftIndex;
}
if (arr[nodeIndex] < arr[minIndex]) {
break;
}
int temp = arr[nodeIndex];
arr[nodeIndex] = arr[minIndex];
arr[minIndex] = temp;
nodeIndex = minIndex;
leftIndex = nodeIndex*2+1;
}
}
void constructHeap(int arr[], int n){
if (n>1) {
int nodeIndex = (n-1-1)/2;
for (int i = nodeIndex; i>=0; i--) {
adjustHeap(arr,n,i);
}
}
}
void heapSort(int arr[], int n){
constructHeap(arr, n);
int *tempArray = (int *)malloc(sizeof(int)*n);
tempArray[0] = arr[0];
arr[0] = arr[n-1];
for (int i = n-2; i>=0; i--) {
adjustHeap(arr,i+1,0);
tempArray[n-i-1] = arr[0];
arr[0] = arr[i];
}
for (int i = 0; i<n; i++) {
arr[i] = tempArray[i];
}
free(tempArray);
}
int adjustSequence(int arr[], int n, int left, int right){
int sign = 0;
while (left != right) {
if (sign == 0) {
if (arr[left] <= arr[right]) {
right--;
}else{
swap(&arr[left], &arr[right]);
left++;
sign = 1;
}
}else{
if (arr[right] >= arr[left]) {
left++;
}else{
swap(&arr[left], &arr[right]);
right--;
sign = 0;
}
}
}
return left;
}
void qSort(int arr[], int n, int left, int right){
if (left < right) {
int loc = adjustSequence(arr, n, left, right);
qSort(arr, n, left, loc-1);
qSort(arr, n, loc+1, right);
}
}
void quickSort(int arr[], int n){
qSort(arr, n, 0, n-1);
}
void countSort(int arr[], int n){
int max = arr[0];
int min = arr[0];
for (int i = 1; i<n; i++) {
if (max < arr[i]) {
max = arr[i];
}
if (min > arr[i]) {
min = arr[i];
}
}
int k = max-min+1;
int *tempArray = (int *)malloc(sizeof(int)*k);
if (tempArray == NULL) {
printf("fail to alloc memory!");
exit(1);
}
memset(tempArray, 0, sizeof(int)*k);
for (int i = 0; i<n; i++) {
tempArray[arr[i]-min] += 1;
}
int index = 0;
for (int i = 0; i<k; i++) {
if (tempArray[i] != 0) {
for (int j = 0; j<tempArray[i]; j++) {
arr[index] = i+min;
index++;
}
}
}
free(tempArray);
}
#define bucketNum 10
typedef struct node{
int data;
struct node *next;
}*Node;
void bucketSort(int arr[], int n){
Node bucket[bucketNum];
for (int i = 0; i<bucketNum; i++) {
bucket[i] = (Node)malloc(sizeof(Node));
bucket[i]->data = 0;
bucket[i]->next = NULL;
}
int max = arr[0];
int min = arr[0];
for (int i = 1; i<n; i++) {
if (arr[i] > max) {
max = arr[i];
}
if (arr[i] < min) {
min = arr[i];
}
}
int interval = max-min+1;
int bucketSpace = (int)ceil(interval/(float)bucketNum);
printf("元素映射:\n");
for (int i = 0; i<n; i++) {
int key = (arr[i]-min)/bucketSpace;
printf("%d:%d\n",arr[i],key);
Node item = (Node)malloc(sizeof(Node));
item->data = arr[i];
Node temp = bucket[key];
if (!temp->next) {
temp->next = item;
item->next = NULL;
bucket[key]->data++;
}else{
while (temp->next && temp->next->data<item->data) {
temp = temp->next;
}
item->next = temp->next;
temp->next = item;
bucket[key]->data++;
}
}
printf("映射完毕:\n");
int index = 0;
Node temp;
for (int i = 0; i<bucketNum; i++) {
printf("%d:",i);
if (bucket[i]->data) {
temp = bucket[i];
while (temp->next) {
arr[index] = temp->next->data;
printf("%d ",temp->next->data);
temp = temp->next;
index++;
}
}
printf("\n");
}
for (int i = 0; i<bucketNum; i++) {
temp = bucket[i];
while (temp->next) {
temp = temp->next;
bucket[i]->next = temp->next;
free(temp);
}
free(bucket[i]);
}
}
void radixSort_LSD(int arr[], int n){
Node bucket[10];
Node tail[10];
memset(bucket, 0, sizeof(bucket));
memset(tail, 0, sizeof(tail));
int max = arr[0];
for (int i = 0; i<n; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
int maxDigit = 1;
while (max >= (int)pow(10, maxDigit)) {
maxDigit++;
}
for (int digit = 0; digit<maxDigit; digit++) {
for (int i = 0; i<n; i++) {
Node node = (Node)malloc(sizeof(Node));
node->data = arr[i];
int key = arr[i]/(int)pow(10, digit)%10;
if (bucket[key] == NULL) {
bucket[key] = node;
tail[key] = node;
}else{
tail[key]->next = node;
tail[key] = node;
}
}
int index = 0;
Node temp;
for (int key = 0; key<10; key++) {
temp = bucket[key];
while (temp != NULL) {
arr[index] = temp->data;
bucket[key] = bucket[key]->next;
free(temp);
temp = bucket[key];
index++;
}
}
printf("digit %d:",digit);
for (int i = 0; i<n; i++) {
printf("%d ",arr[i]);
}
printf("\n");
}
}