void printarray(int* a, int n)
{
for (int i = 0; i < n; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
void swap(int* p1, int* p2)
{
int tem = *p1;
*p1 = *p2;
*p2=tem;
}
//插入排序
void insertsort(int* a, int n)
{
for (int i = 0; i < n - 1; i++)
{
int end = i;
int tem = a[i + 1];
while(end>=0)
{
if (tem < a[end])
{
a[end + 1] = a[end];
end--;
}
else
{
break;
}
}
a[end + 1] = tem;
}
}
//希尔排序
void shelltsort(int* a, int n)
{
int gap = n;
while(gap>1)
{
gap = gap/ 3 + 1;
for (int j = 0; j < gap; j++)
{
for (int i = j; i < n -gap; i+= gap)
{
int end = i;
int tem = a[i + gap];
while (end >= 0)
{
if (tem < a[end])
{
a[end + gap] = a[end];
end -= gap;
}
else
{
break;
}
}
a[end + gap] = tem;
}
}
}
}
int getminindex(int* a, int left, int right)
{
int min = (left + right) / 2;
if (a[left] < a[min])
{
if (a[min] < a[left])
{
return min;
}
else if (a[left] < a[right])
{
return right;
}
else
{
return left;
}
}
else //a[left] > a[min]
{
if (a[min] > a[right])
{
return min;
}
else if (a[left] < a[right])
{
return left;
}
else
{
return right;
}
}
}
//hoare版本
int partsort1(int* a, int left, int right)
{
int min = getminindex(a, left, right);
swap(&a[min], &a[left]);
int keyi = left;
while(left<right)
{
while(left < right && a[right] >= a[keyi])
{
right--;
}
while (left < right && a[left] <= a[keyi])
{
left++;
}
swap(&a[left], &a[right]);
}
swap(&a[left], &a[keyi]);
return left;
}
//挖坑法
int partsort2(int* a, int left, int right)
{
int min = getminindex(a, left, right);
swap(&a[min], &a[left]);
int hole = left;
int key = a[left];
while(left<right)
{
while(left < right&&a[left] < key)
{
left++;
}
a[hole] = a[left];
hole = left;
while(left < right & a[right] > key)
{
right--;
}
a[hole] = a[right];
hole = right;
}
a[hole] = key;
return hole;
}
//前后指针法
int partsort3(int* a, int left, int right)
{
int min = getminindex(a, left, right);
swap(&a[min], &a[left]);
int prev = left;
int cur = left+1;
int keyi= left;
while(cur<=right)
{
if (a[cur] <a[keyi])
{
prev++;
swap(&a[cur], &a[prev]);
}
cur++;
}
swap(&a[keyi], &a[prev]);
keyi = prev;
return keyi;
}
void quicksort1(int* a, int begin, int end)
{
if (begin >= end)
{
return;
}
int keyi = partsort1(a, begin, end);
quicksort1(a, begin, keyi - 1);
quicksort1(a, keyi + 1, end);
}
void quicksort2(int* a, int begin, int end)
{
if (begin >= end)
{
return;
}
int keyi = partsort2(a, begin, end);
quicksort2(a, begin, keyi - 1);
quicksort2(a, keyi + 1, end );
}
void quicksort3(int* a,int begin,int end)
{
if (begin >= end)
{
return;
}
int keyi=partsort3(a, begin, end);
quicksort3(a, begin, keyi-1);
quicksort3(a, keyi+1, end );
}
//三路法
void quicksort4(int* a, int begin, int end)
{
if (begin >= end)
{
return;
}
int left = begin;
int right = end;
int cur = left + 1;
int min = getminindex(a, left, right);
swap(&a[min], &a[left]);
int key = a[left];
while (cur <= right)
{
if (a[cur] < key)
{
swap(&a[cur], &a[left]);
cur++;
left++;
}
else if (a[cur] > key)
{
swap(&a[cur], &a[right]);
right--;
}
else
{
cur++;
}
}
quicksort4(a, begin, left-1);
quicksort4(a, right+1, end);
}
void quicksortnonr(int* a, int begin, int end)
{
Stack p;
Stackinit(&p);
Stackpush(&p, end);
Stackpush(&p, begin);
while (!isempty(&p))
{
int left= Stacktop(&p);
Stackpop(&p);
int right= Stacktop(&p);
Stackpop(&p);
int keyi = partsort1(a, left, right);
//[left,keyi-1][keyi+1,right]
if(keyi+1<right)
{
Stackpush(&p, right);
Stackpush(&p, keyi+1);
}
if(left<keyi-1)
{
Stackpush(&p, keyi - 1);
Stackpush(&p, left);
}
}
Stackdestroy(&p);
}
//选择排序
void selectsort(int* a, int n)
{
int begin = 0;
int end = n -1;
while (begin < end)
{
int mini = begin;
int maxi = begin;
for (int i = begin; i <=end; i++)
{
if (a[i] > a[maxi])
{
maxi = i;
}
if (a[i] < a[mini])
{
mini = i;
}
}
swap(&a[mini], &a[begin]);
// 如果maxi和begin重叠,修正一下即可
if (maxi == begin)
{
maxi = mini;
}
swap(&a[maxi], &a[end]);
begin++;
end--;
}
}
//归并排序
void _mergesort(int* a, int begin, int end, int*tem )
{
if (begin==end)
{
return;
}
//小区间优化
if (end - begin+1 < 10)
{
insertsort(a, end - begin + 1);
return;
}
int min = (begin + end) / 2;
_mergesort(a, begin, min, tem);
_mergesort(a, min+1,end, tem);
int begin1 = begin; int end1 = min;
int begin2 = min + 1; int end2 = end;
int i = begin;
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] <= a[begin2])
{
tem[i++] = a[begin1++];
}
else
{
tem[i++] = a[begin2++];
}
}
while (begin1 <= end1)
{
tem[i++] = a[begin1++];
}
while (begin2 <= end2)
{
tem[i++] = a[begin2++];
}
memcpy(a + begin, tem + begin, sizeof(int)*(end - begin + 1));
}
void mergesort(int* a, int n)
{
int* tem = (int*)malloc(sizeof(int) * n);
_mergesort(a, 0, n - 1, tem);
free(tem);
}
//归并排序非递归--有缺陷
//void mergesortnonr(int* a, int n)
//{
// int* tem = (int*)malloc(sizeof(int) * n);
//
// int gap = 1;
// while (gap < n)
// {
// int k = 0;
// for (int i = 0; i < n; i += 2 * gap)
// {
// int begin1 = i; int end1 =i+gap-1;
// int begin2 = i+gap; int end2 = i+2*gap-1;
//
// while (begin1 <= end1 && begin2 <= end2)
// {
// if (a[begin1] <= a[begin2])
// {
// tem[k++] = a[begin1++];
// }
// else
// {
// tem[k++] = a[begin2++];
// }
// }
//
// while (begin1 <= end1)
// {
// tem[k++] = a[begin1++];
// }
//
// while (begin2 <= end2)
// {
// tem[k++] = a[begin2++];
// }
// }
// memcpy(a, tem, sizeof(int) * n);
// gap *= 2;
// }
// free(tem);
//}
解决方法1
//void mergesortnonr(int* a, int n)
//{
// int* tem = (int*)malloc(sizeof(int) * n);
//
// int gap = 1;
// while (gap < n)
// {
// int k = 0;
// for (int i = 0; i < n; i += 2 * gap)
// {
// int begin1 = i; int end1 = i + gap - 1;
// int begin2 = i + gap; int end2 = i + 2 * gap - 1;
//
//
// if (begin2 >= n && end1 < n)
// {
// begin2 = n;
// end2 = n - 1;
// }
// if (end1 >= n && begin1 < n)
// {
// end1 = n - 1;
// begin2 = n;
// end2 = n - 1;
// }
// if (begin2 < n&&end2>=n)
// {
// end2 = n - 1;
// }
//
// /*if (end1 >= n)
// {
// end1 = n - 1;
// begin2 = n;
// end2 = n - 1;
// }
// else if (begin2 >= n)
// {
// begin2 = n;
// end2 = n - 1;
// }
// else if(end2 >= n)
// {
// end2 = n - 1;
// }*/
//
// while (begin1 <= end1 && begin2 <= end2)
// {
// if (a[begin1] <= a[begin2])
// {
// tem[k++] = a[begin1++];
// }
// else
// {
// tem[k++] = a[begin2++];
// }
// }
//
// while (begin1 <= end1)
// {
// tem[k++] = a[begin1++];
// }
//
// while (begin2 <= end2)
// {
// tem[k++] = a[begin2++];
// }
// }
// memcpy(a, tem, sizeof(int) * n);
// gap *= 2;
// }
// free(tem);
//}
//解决方法2
void mergesortnonr(int* a, int n)
{
int* tem = (int*)malloc(sizeof(int) * n);
int gap = 1;
while (gap < n)
{
int k = 0;
for (int i = 0; i < n; i += 2 * gap)
{
int begin1 = i; int end1 = i + gap - 1;
int begin2 = i + gap; int end2 = i + 2 * gap - 1;
if (end1 >= n || begin2 >= n)
{
break;
}
if (begin2 < n && end2 >= n)
{
end2 = n - 1;
}
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] <= a[begin2])
{
tem[k++] = a[begin1++];
}
else
{
tem[k++] = a[begin2++];
}
}
while (begin1 <= end1)
{
tem[k++] = a[begin1++];
}
while (begin2 <= end2)
{
tem[k++] = a[begin2++];
}
memcpy(a + i, tem + i, sizeof(int) * (end2 - i + 1));
}
gap *= 2;
}
free(tem);
}
//计数排序
void countsort(int* a, int n)
{
int maxi = 0;
int mini = 0;
for (int i = 0; i < n; i++)
{
if (a[i] > a[maxi])
{
maxi = i;
}
if (a[i] < a[mini])
{
mini = i;
}
}
int tmpsize = (a[maxi] - a[mini])+1;
int* tmp = (int*)malloc(sizeof(int) * tmpsize);
memset(tmp, 0, sizeof(int) * tmpsize);
int k = 0;
while (k < n)
{
tmp[a[k++] - a[mini]]++;
}
/*for (int i = 0; i < n; i++)
{
tmp[a[i] - a[mini]]++;
}*/
int j = 0;
for (int i = 0; i < tmpsize; i++)
{
while (tmp[i]--)
{
a[j++] = i+a[mini];
}
}
}
void adjuctdown(int* h, int n, int parent)
{
assert(h);
int child = parent * 2 + 1;
while (child < n)
{
if ((child + 1) < n && h[child] <h[child + 1])
{
child++;
}
if (h[parent] < h[child])
{
swap(&h[parent], &h[child]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
//堆排序
void heapsort(int* a, int n)
{
for (int i = (n - 1 - 1) / 2; i >= 0; i--)
{
adjuctdown(a, n,i);
}
int end = n - 1;
while(end)
{
swap(&a[end], &a[0]);
adjuctdown(a, end--, 0);
}
}
//冒泡排序
void bubblesort(int* a, int n)
{
for (int j = 0; j < n; j++)
{
for (int i = 0; i < n - 1 - j; i++)
{
if (a[i] > a[i+1])
{
swap(&a[i], &a[i+1]);
}
}
}
}
排序排序啦
于 2024-02-22 10:30:03 首次发布