各类排序算法

//冒泡排序,稳定排序
void BubbleFun(int arr[], int n)
{
    int i,j;
int temp;
     for(i=1; i<n; i++)
    for(j=0; j<n-i; j++)
{
   if(arr[i]<arr[j])
{
       temp = arr[i];
arr[j] = arr[i];
arr[j] =temp;
}
 
}
}


//把字符串'123'转为阿拉伯数123
void fun(char arr[])
{
     int temp = 0;
char c;
c = arr[0];
int i=0;
 
while (arr[i] != '\0')
{
    temp = temp*10 + (arr[i] - '0');
i++;
}
}


//选择排序，不稳定排序
void SelectFun(int arr[], int n)
{
     int temp;
int i, j;
int pos;
 
for(i=0; i<n-1; i++)
{
      pos = i;
  for(j=i+1; j<n; j++)
  {
       if (arr[i]>arr[j])
{
     pos=j;
}
  }
  
  temp = arr[pos];
  arr[pos] = arr[i];
  arr[i] = temp;
}
}


//插入排序，不稳定排序
void insertFun(int arr[],int first, int last)
{
    int i,j;
int temp;

for (i=first+1;  i<last; i++)
{
     j = i-1;
 temp = arr[i];
 while (j>=first && arr[j]>temp)
 {
        arr[j+1]=arr[j];
j--;
 }
 arr[j+1]=temp;
}
}


//快速排序，不稳定排序
//low对应第一个元素的下标,high对应最后一个元素的下标
void quickSort(int a[], int low, int high)
{
if(low<high){
    int i,j,temp;
i = low;
j = high;
         temp = a[low];


while(i<j)
{
while (i<j && a[j]>=temp)
 {
 j--;
 }
 if (i<j)
 {
 a[i] = a[j];
 i++;
 }
 
 while (i<j && a[i]<temp)
 {
 i++;
 }
 if (i<j)
 {
    a[j] = a[i];
j--;
 }
 }
 a[i] = temp;
     quickSort(a, low, i-1);
     quickSort(a, i+1, high);
 }  
}


//归并排序（速度仅次于快速排序，但较稳定）
void merge(int arr[], int first, int last)
{
     if (first>last)
{
     int mid = (first+last)/2;
 merge(arr, first, mid);
 merge(arr, mid+1,last);
 mergeSort(arr, first, mid, last);
}
}


void mergeSort(int arr[], int first, int mid, int last)
{
    int indexA,indexB;
indexA = first;
indexB = mid+1;
int tempArr[] = [last+1];
int tempIndex = 0;

while (indexA<=mid && indexB<=last)
{
     if (arr[indexA]<=arr[indexB])
 {
      tempArr[tempIndex] = arr[indexA];
  indexA++;
 }
 else
 {
       tempArr[tempIndex] = arr[indexB];
indexB++;
 }
 tempIndex++;
}
while (indexA<=mid)
{
      tempArr[tempIndex] = arr[indexA];
  tempIndex++;
  indexA++;
}
while (indexB<=last)
{
      tempArr[tempIndex] = arr[indexB];
  tempIndex++;
  indexB++;
}

for (int i=first; i<last; i++)
{
     arr[i] = tempArr[tempIndex];
 tempIndex++;
}
}


//希尔排序
void shellSort(int arr[], int n)
{
     int k = n/2;
while (k>0)
{
    for (int i = k; i<n; i++)
{
    int temp = arr[i];
int j = i;
while (j>=k && temp<arr[j-k])
{
     arr[j]<arr[j-k];
     j = j-k;
}
arr[j] = temp;
}
k = k/2;
}
}


//基数排序，稳定排序
int maxbit(int data[], int n)
{
int d = 1;
int p = 10;
for (int i=0; i<n; ++i)
{
while (data[i]>=p)
{
p = p*10;
++d;
}
}


return d;
}


void radixSort(int data[], int n)
{
int d = maxbit(data, n);
int *tmp = new int[n];
int *count = new int[10];
int i,j,k;
int radix = 1;


for (i=1; i<=d; i++)
{
for (j=0; j<10; j++)
{
count[j] = 0;
}
for (j=0; j<n; j++)
{
k = (data[j]/radix)%10;
count[k]++;
}
for (j=1; j<10; j++)
{
count[j] = count[j-1]+count[j];
}
for (j=n-1; j>=0; j--)
{
k = (data[j]/radix)%10;
count[k]--;
tmp[count[k]] = data[j];
}
for (j=0; j<n; j++)
{
data[j] = tmp[j];
}
radix = radix*10;
}
delete []tmp;
delete []count;
}