八种常用的排序算法

来源：互联网发布：铁路定额预算软件编辑：程序博客网时间：2024/05/29 02:36

//1.插入排序
void InsertSort(int* a, int n)//直接插入
{
for (int i =0; i<n-1;i++)
{
int tmp;
int end = i; //关键字位置
tmp = a[end + 1]; //保存后一个元素
while (end>=0)
{
if (a[end]>tmp) //前一个大于后一个
{
a[end + 1] = a[end]; //前一个挪到后面
--end;
} //关键字向前移
else{
break;
}
}
a[end + 1] = tmp;
}}

//希尔排序
void ShellSort(int* a, int n) //gap //希尔
{
int gap = n;
while (gap>1)
{
gap=gap/3+1;
for (int i = 0; i < n-gap;i++)
{
int tmp;
int end = i;
tmp = a[end + gap]; //保存后一个元素
while (end>=0){
if (a[end]>tmp){ //前一个大于后一个
a[end + gap] = a[end]; //前一个挪到后面
--end;
} //关键字向前移
else{
break;
}
}
a[end + gap] = tmp;
}
}
}

//选择排序
void SeleteSort1(int* a, int n)//选择排序
{
int min,i ;
for (i = 0; i < n;i++)
{
min = i;
for (int j = i + 1; j < n;j++)
{
if (a[j]<=a[min])
{
min = j;
}
}
swap(a[min], a[i]);
}
}
void SeleteSort2(int* a, int n) //选择排序的优化算法
{
int max, min, i, j;
for (i =1; i <=n / 2;i++)
{
min = i; max = i; //记录最大值最小值位置
for (j = i + 1; j <=n-i;j++)
{
if (a[j] >a[max])
{
max = j;
}
if (a[j] <a[min])
{
min = j;
}
}
swap(a[i], a[min]);
swap(a[n-i], a[max]);
}
}

//堆排序
void AdjustHeap(int *a, int root, int len)
{
int parent = root;
int child = 2 * parent + 1;
while (child<len)
{
if (child+1<len&&a[child]<a[child+1])
{
++child;
}
if (a[parent]<a[child])
{
swap(a[parent],a[child]);
parent= child;
child = 2 * parent + 1;
}
else
{
break;
}
}
}
void BulidHeap(int * a, int len)
{
for (int i = (len - 1) / 2; i >= 0; i--)
{
AdjustHeap(a, i, len);
}
}
void HeapSort(int* a, int len)
{
BulidHeap(a, len);
for (int i = len - 1; i > 0;i--)
{
int temp = a[i]; a[i] = a[0]; a[0] = temp;
AdjustHeap(a,0, i);
}
}

//冒泡排序
void BubbleSort(int* a,int len)
{
for (int i= 0; i < len;i++)
{
for (int j = 0; j < len - i-1;j++)
{
if (a[j]>a[j+1])
{
swap(a[j],a[j+1]);
}
}
}
}

//快速排序
int GetMidIndex(int* a, int left, int right) //发挥中间坐标
{
int mid = left+(left - right) / 2;
if (a[left]<a[mid])
{
if (a[mid]<a[right])
{
return mid;
}
else if (a[left]>a[right])
{
return left;
}
else
return right;
}
else //left>mid
{
if (a[mid]>a[right])
{
return mid;
}
else if (a[left] < a[right])
{
return left;
}
else
return right;
}
}
int PartSort1(int* a, int left, int right)
{
int mid = GetMidIndex(a, left,right);
swap(a[mid],a[right]);
int key = a[right];
int begin = left;
int end = right;
while (begin < end)
{
while (begin<end&&a[begin]<=key)
{
++begin;
}
while (begin<end&&a[end]>=key)
{
--end;
}
if (begin < end)
swap(a[begin], a[end]);
}
swap(a[begin],a[right]);
return begin;
}
void QuickSort(int* a, int left, int right)
{
assert(a);
if (left >= right)
return;
if (right - left < 5)
{
InsertSort(a + left, right - left + 1);
}
else
{
int div = PartSort1(a, left, right);
QuickSort(a, left, div - 1);
QuickSort(a, div + 1, right);
}
}

//归并排序
void Merge(int* a, int* tmp, int begin1, int end1, int begin2, int end2)
{
int pos = begin1;
int index = begin1;
while (begin1<=end1&&begin2<=end2)
{
if (a[begin1]<a[begin2])
{
tmp[index++] = a[begin1++];
}
else
{
tmp[index++] = a[begin2++];
}
}
while (begin1<=end1)
{
tmp[index++] = a[begin1++];
}
while (begin2<=end2)
{
tmp[index++] = a[begin2++];
}
memcpy(a+pos,tmp+pos,sizeof(int)*(end2-pos+1));
}
void _MergeSort(int* a,int* tmp,int left,int right)
{
if (left>=right)
{
return;
}
int mid = left + (right-left) / 2;
_MergeSort(a,tmp,left,mid);
_MergeSort(a, tmp, mid + 1, right);
Merge(a, tmp, left, mid, mid + 1, right);
}
void MergeSort(int* a, int len)
{
assert(a);
int* tmp = new int[len];
_MergeSort(a,tmp,0,len-1);
delete[] tmp;
}
void RadixSort(int* a, int len,int maxradix)
{
assert(a);
int n=0,lsp=0;
int k = 1, m = 1;
int tmp[10][10] = {0};
while (k<maxradix)
{
for (int i = 0; i < len;i++)
{
if (a[i]<m)
{
tmp[0][n] = a[i];
}
else
{
lsp = (a[i] / 10) % 10;
tmp[lsp][n] = a[i];
}
n++;
}
}
}

//基数排序
int GetNumInPos(int num, int pos)
{
int tmp = 1;
for (int i = 0; i < pos-1;i++)
{
tmp *= 10;
}
return (num / tmp) % 10;
}
void RadixSort(int* a, int len)
{
int* RadixArray[RADIX_10];
for (int i = 0; i < 10;i++)
{
RadixArray[i] = (int *)malloc(sizeof(int)* (len + 1));
RadixArray[i][0] = 0;
}
for (int pos = 1; pos <= KEYNUM_31;pos++)
{
for (int i = 0; i < len;i++)
{
int num = GetNumInPos(a[i], pos);
int index = ++RadixArray[num][0];
RadixArray[num][index] = a[i];
}
for (int j = 0,i=0; i<RADIX_10 ;i++)
{
for (int k = 1; k < RadixArray[i][0];k++)
{
a[j++] = RadixArray[i][k];
RadixArray[i][0] = 0;
}
}
}
}
void Display(int* a, int n)
{
for (int i = 0; i < n;i++) //18392078917
{
cout << a[i] <<" ";
}
cout << endl;
}
void TestInsertSort()
{
int a[] = { 2, 1, 3, 4, 7, 4, 6, 8, 9, 10 };
Display(a, sizeof(a) / sizeof(a[0]));
InsertSort(a, sizeof(a) / sizeof(a[0]));
Display(a, sizeof(a) / sizeof(a[0]));
}
void TestShellSort()
{
int a[] = { 1, 3, 4, 5, 4, 6, 8, 9, 10 };
Display(a, sizeof(a) / sizeof(a[0]));
ShellSort(a, sizeof(a) / sizeof(a[0]));
Display(a, sizeof(a) / sizeof(a[0]));
}
void TestSeleteSort()
{
int a[] = { 11, 3, 30, 5, 4,60, 5, 9, 10 };
Display(a, sizeof(a) / sizeof(a[0]));
SeleteSort1(a, sizeof(a) / sizeof(a[0]));
Display(a, sizeof(a) / sizeof(a[0]));
SeleteSort2(a, sizeof(a) / sizeof(a[0]));
Display(a, sizeof(a) / sizeof(a[0]));
}
void TestHeapSort()
{
int a[] = {3,1,4,2,5,8,6,9,7,10};
Display(a, sizeof(a) / sizeof(a[0]));
int len = sizeof(a) / sizeof(a[0]);
HeapSort(a, len);
Display(a, sizeof(a) / sizeof(a[0]));
}
void TestBubbleSort()
{
int a[] = { 3, 1, 4, 2, 5, 4, 6, 9, 7, 10 };
Display(a, sizeof(a) / sizeof(a[0]));
int len = sizeof(a) / sizeof(a[0]);
BubbleSort(a, len);
Display(a, sizeof(a) / sizeof(a[0]));
}
void TestQuickSort()
{
int a[] = { 3, 1, 4, 2, 5, 4, 6, 9, 7, 10 };
Display(a, sizeof(a) / sizeof(a[0]));
int len = sizeof(a) / sizeof(a[0]);
QuickSort(a, 0, len-1);
Display(a, sizeof(a) / sizeof(a[0]));
}
void TestMergeSort()
{
int a[] = { 3, 1, 4, 2, 5, 4, 6, 9, 7, 10 };
Display(a, sizeof(a) / sizeof(a[0]));
int len = sizeof(a) / sizeof(a[0]);
MergeSort(a, sizeof(a) / sizeof(a[0]));
Display(a, sizeof(a) / sizeof(a[0]));
}
void TestRadixSort()
{
int a[] = { 12, 13, 12, 13, 19, 18, 15, 12, 15, 16, 17 };
int len = sizeof(a) / sizeof(a[0]);
Display(a, len);
RadixSort(a, len);
Display(a, len);
}

阅读全文

0 0