各种排序算法源码(c++)20150913

#include "sort.h"
#include "mytool.h"

void selectSort(int *a, int n) {
int min;
for(int i = 0; i < n; i++){
min = i;
for(int j = i + 1; j < n; j++){
if(a[j] < a[min]){
min = j;
}
}
int temp = a[i];
a[i] = a[min];
a[min] = temp;
}
}

void insertSort(int a[], int n) {
for(int i = 0; i < n; i++) {
int j = i;
while(j > 0 && a[j] < a[j-1]) {
int temp = a[j];
a[j] = a[j-1];
a[j-1] = temp;
j--;
}
}
}

void bubbleSort(int a[], int n) {
for(int i = 0; i < n-1; i++) {
int is_swap = false;
for(int j = n-1; j > i; j--) {
if(a[j] < a[j-1]) {
swap(a[j], a[j-1]);
is_swap = true;
}
}
if(is_swap == false) {
break;
}
}
}

void merge(int a[], int start, int mid, int end) {
int nl=mid-start+1;
int nr=end-mid;
int *b = new int[nl];
int *c = new int[nr];
for(int i = 0; i < nl; i++){
b[i]=a[start + i];
}
for(int i = 0 ; i < nr; i++){
c[i]=a[mid + 1 + i];
}
int i = start;
int il = 0, ir = 0;
while(il != nl && ir != nr) {
if(b[il] < c[ir]){
a[i++] = b[il++];
}else {
a[i++] = c[ir++];
}
}
while(il != nl) {
a[i++] = b[il++];
}
while(ir != nr) {
a[i++] = c[ir++];
}
}

void mergeSort(int a[], int start, int end) {
if(start == end) {
return;
}
int mid = (start + end) / 2;
mergeSort(a, start, mid);
mergeSort(a, mid+1, end);
merge(a, start, mid, end);
}

void mergeSort(int a[], int n) {
mergeSort(a, 0, n-1);
}

void quickSort(int a[], int start, int end) {
if(start >= end){
return;
}
int flag = a[start];
int index_l = start, index_r = end;
while(index_l != index_r) {
while(index_l < index_r && a[index_r] > flag)
index_r--;
a[index_l] = a[index_r];
while(index_l < index_r && a[index_l] < flag)
index_l++;
a[index_r] = a[index_l];
}
a[index_l] = flag;
quickSort(a, start, index_l-1);
quickSort(a, index_l+1, end);
}

void c(int a[], int n) {
quickSort(a, 0, n-1);
}

void maxHeapAdjust(int a[], int i, int n) {
int temp, j;
temp = a[i];
j = 2 * i + 1;
while(j < n) {
if(j + 1 < n && a[j + 1] > a[j])
j++;
if(a[j] <= temp)
break;
a[i] = a[j];
i = j;
j = 2 * i + 1;
}
a[i] = temp;
}

void heapAdjust(int a[], int n) {
for(int i = n / 2; i >= 0; i--) {
maxHeapAdjust(a, i, n);
}
}

void heapSort(int a[], int n) {
heapAdjust(a, n);
swap(a[n-1], a[0]);
for(int i = n-1; i > 0; i--) {
maxHeapAdjust(a, 0, i);
swap(a[i-1], a[0]);
}
}

void countSort(int a[], int n) {
int count[10000] = {0};
int *b = new int
;
for(int i = 0; i != n; i++) {
count[a[i]]++;
}
for(int i = 1; i != 10000; i++) {
count[i] += count[i-1];
}
for(int i = 0; i < n; i++) {
*(b+count[a[i]]-1) = a[i];
count[a[i]]--;
}
for(int i = 0; i < n; i++) {
a[i] = *(b + i);
}
}

int getNum(int a, int l) {
while(l-- > 0) {
a /= 10;
}
return a%10;
}

class Bucket {
public:
int num;
Bucket *next;

Bucket(int num) {
this->num = num;
this->next = 0;
}
};

void radixSort(int a[], int l, int n) {
Bucket *bucket[10] = {0};
int isRe = false;
for(int i = 0; i < n; i++) {
int index = getNum(a[i], l);
Bucket *temp = new Bucket(a[i]);
if(bucket[index] == 0) {
bucket[index] = temp;
}else {
Bucket *last = bucket[index];
while(last->next != 0)
last = last->next;
last->next = temp;
}
if(index != 0){
isRe = true;
}
}
int j = 0;
for(int i =0; i < 10; i++) {
while(bucket[i] != 0) {
a[j++] = bucket[i]->num;
Bucket *temp = bucket[i];
bucket[i] = bucket[i]->next;
delete temp;
}
}
if(isRe) {
radixSort(a, l+1, n);
}
}

void radixSort(int a[], int n) {
radixSort(a, 0, n);
}

void bucketSort(int a[], int n) {
int b[MAX_BUCKET_SIZE] = {0};
for(int i = 0; i < n; i++) {
b[a[i]]++;
}
int index = 0;
for(int i = 0; i < MAX_BUCKET_SIZE; i++) {
while(b[i]-- > 0) {
a[index++] = i;
}
}
}