C语言-所有排序实现

头文件Insert.h

#include<stdio.h>
void Swap(int *a, int *b);
void StraightInsert(int *a, int n);
void HalfSearch(int *L, int n);
void BubbleSort(int *L, int n);
void SelectSort(int *L, int n);
int division(int *a, int left, int right);
void quick(int *a, int left, int right);
void threenumber(int *arr, int len);
void oddfront(int *L, int n);
void countsort(int *a, int len);//计数排序
void max_heapify(int *arr, int start, int end);
void heap_sort(int *arr, int len);

测试文件Main.c

#include<stdio.h>
#include"Insert.h"
int main() {
	int arr[] = { 2,3,8,7,1,2,2,2,7,3,9,8,2,1,4,2,4,6,9,2 };
	int len = (sizeof(arr) / sizeof(int));
	//StraightInsert(&L, len);//直接插入排序
	//HalfSearch(&L, len);//折半查找
	//BubbleSort(&L, len);//冒泡排序
    //quick(&L,0,len-1);//快速排序
	//threenumber(&arr, len);//排序结果为:负数  零  正数
    //oddfront(&arr,len);//把奇数排在偶数之前
    //countsort(&arr, len);//计数排序
    heap_sort(&arr,len);//堆排序

	//输出结果
	for (int i = 0; i < len; ++i) {
		printf("%d-->", L[i]);
	}
	printf("\n");
}


	

函数实现Insert.c

#include"Insert.h"
#include<stdio.h>

void Swap(int *a, int *b) {
	int temp = *a;
	*a = *b;
	*b = temp;
}

void StraightInsert(int *L, int n) {
	for (int i = 1; i < n; i++) {
		if (L[i] < L[i - 1])//比较的是它以及它的邻居
		{
			Swap(&L[i], &L[i - 1]);//注意：这里传引用（因为是数组中的某一个值进行交换)
			for (int j = i - 1; j > 0 && L[j] < L[j - 1]; j--) //比较的是它和它之前的
				Swap(&L[j], &L[j - 1]);
		}//if
	}//for
}

void HalfSearch(int *L, int n) {
		int i, j, low, high, mid, key;
		for (i = 1; i < n; i++)
		{
			key = L[i];//把L[i]的值保存在key变量中
			low = 0;
			high = i - 1;
			while (low <= high)//折半查找
			{
				mid = (low + high) / 2;
				if (L[mid] >= key)
					high = mid - 1;//如果大于key值，则查找范围缩小到左子序列
				else
					low = mid + 1;//如果小于key值，则查找范围缩小到右子序列
			}
			for (j = i - 1; j >= high + 1; j--)
				L[j + 1] = L[j];//将high之后的数据整体后移
			L[high + 1] = key;//将key值插入该位置
		}
	}

void BubbleSort(int *L, int n) {
	int i, j;
    int flag=0;//标志位，如果该趟没有交换，则说明此时的序列已经有序了！
	for (i = 0; i <n-1; ++i) {
		for (j = 0; j<n-1-i; ++j) {
			if (L[j] > L[j + 1])
				Swap(&L[j], &L[j + 1]);
		}
         flag=1;
	}
    if(flag==0)
    return 0;
}

void SelectSort(int *L, int n) {
	int i, j, k, temp;
	for (i = 0; i < n; i++)
	{
		k = i;//记录位置
		for (j = i + 1; j < n; j++)//查找后面的最小值
			if (L[k] > L[j])
				k = j;//记录位置
		if (k != i)//交换位置
			Swap(&L[i],&L[k]);
	}
}

int division(int *a, int left, int right)  //分割；
{
	int base = a[left];  //基准元素；
	while (left < right)
	{
		//先从后向前找，再从前向后找
		while (left < right&&a[right] >= base)
			right--;   //从右向左找第一个比基准值小的元素；
		a[left] = a[right];
		while (left < right&&a[left] < base)
			left++;   //从左向右找第一个比基准值大的元素；
		a[right] = a[left];
	}
	a[left] = base;
	return left;
}



void quick(int *a, int left, int right)
{
	if (left < right)
	{
		int i = division(a, left, right);  //分割；
		quick(a, left, i - 1);  //将两部分分别排序；
		quick(a, i + 1, right);
	}
}


	
void threenumber(int *arr, int len) {

		int low = 0, mid = 0, high = len - 1;
		while (mid <= high)
		{
			if (arr[mid] < 0)
			{
				swap(&arr[low++], &arr[mid++]);
			}
			else
				if (arr[mid] == 0)
				{
					mid++;
				}
				else
					swap(&arr[mid], &arr[high--]);
		}
	}

void oddfront(int *L, int n) {
	int i = 0, j = n - 1;
	while (i < j) {
		while (i < j&&L[i] % 2 != 0) i++;
		while (i < j&&L[j] % 2 != 1) j--;
		if (i < j) {
			swap(&L[i], &L[j]);
			i++; j--;
		}
	}
}


void countsort(int *a, int len)
	{
		assert(a);
		int max = a[0], min = a[0];
		for (int i = 0; i < len; i++) {
			if (a[i] > max)
				max = a[i];
			if (a[i] < min)
				min = a[i];
		}
		//b为临时数组
		int range = max - min + 1;
		int *b = (int *)calloc(range, sizeof(int));
		
		for (int i = 0; i < len; i++) {
			
			b[a[i] - min] += 1;//为b数组元素赋值，其值为该数出现的次数
		}
		int j = 0;
	
		for (int i = 0; i < range; i++) {
			while (b[i]--) {
				
				a[j++] = i + min;//按数组b中的次数顺序输出给a数组
			}
		}
		free(b);
		b = NULL;
	}

void max_heapify(int *arr, int start, int end)
	{
		int dad = start;
		int son = dad * 2 + 1;
		while (son <= end)  
		{
			if (son + 1 <= end && arr[son] < arr[son + 1])
				
				son++;
			if (arr[dad] > arr[son]) 
				return;
			else  
			{
				swap(&arr[dad], &arr[son]);
				dad = son;
				son = dad * 2 + 1;
			}
		}
	}

	void heap_sort(int *arr, int len)
	{
		int i;
		for (i = len / 2 - 1; i >= 0; i--)
			max_heapify(arr, i, len - 1);
		for (i = len - 1; i > 0; i--)
		{
			swap(&arr[0], &arr[i]);
			max_heapify(arr, 0, i - 1);
		}
	}