嵌入式（c）排序算法

直接插入排序

#include <stdio.h>
/*
直接插入排序：
思想：
    从第二个元素开始，将后一个元素依次跟前面所有的元素进行比较，选择一个合适
    的位置插入，然后再将第三个元素依次跟前面所有的元素进行比较，选择一个合适
    的位置插入，如此循环，最终序列将整体有序。
*/
void InsertSort(int *p,int len)
{
    int temp = 0;
    int j = 0;
    for (int i = 1; i < len; i++)
    {
        temp = p[i];
        for (j = i - 1; j >= 0; j--)
        {
            if (temp < p[j])
            {
                p[j + 1] = p[j];
            }
            else
            {
                break;
            }
        }
        p[j+1] = temp;
    }
    return 0;
}
int main(void)
{
    int arr[10] = { 5,4,6,7,8,2,1,3,9,0 };
    int len = sizeof(arr) / sizeof(arr[0]);
    InsertSort(arr, len);
    for (int i = 0; i < len; i++)
    {
        printf("%d ", arr[i]);
    }
    putchar(10);
    return 0;
}

希尔排序

#include <stdio.h>
/*
希尔排序：
特点：
1.分组排序，避免数据在内存中的大面积移动
2.多组同时进行排序
*/
void ShellSort(int *p,int len)
{
    int temp = 0;
    int j = 0;
    //以h为增量进行分组排序
    for (int h = len / 2; h >= 1; h /= 2)
    {
        //从第一组的第二个元素开始跟前面所有的元素进行比较
        for (int i = h; i < len; i++)
        {
            //将要比较的元素赋值给temp
            temp = p[i];
            //以增量h为间隔，前面组内的元素进行比较
            for (j = i - h; j >= 0; j -= h)
            {
                if (temp < p[j])
                {
                    p[j + h] = p[j];
                }
                else
                {
                    break;
                }
            }
            p[j + h] = temp;
        }

    }
}
int main(void)
{
    int arr[10] = { 5,4,6,7,8,2,1,3,9,0 };
    int len = sizeof(arr) / sizeof(arr[0]);
    ShellSort(arr, len);
    for (int i = 0; i < len; i++)
    {
        printf("%d ", arr[i]);
    }
    putchar(10);
    return 0;
}

冒泡排序

#include <stdio.h>
/*
冒泡排序：
交换排序中的一种:
思路：从第一个元素开始，两两进行比较，以升序
      排序为例，如果前面的元素比后面大，则交换之
      通过一趟排序后，最大值交换至数组的末尾。
      第二趟排序，将次大值交换至数组的倒数第二的位置
      如此循环，则序列将整体有序。
*/
/*
一维数组的传参：
    传指针 + 数组的长度
    因为函数内部无法获取数组的大小
传参格式：
1.传指针：int *p,int length
2.传原型  int p[10],int length
3.传缺省的数组  int p[],int length
*/
//void BubbleSort(int *p,int length)
//void BubbleSort(int p[100], int length)  //此处p相当于一个int*的指针
void BubbleSort(int p[], int length)
{
    //printf("sizeof(p) = %lld\n",sizeof(p));
    for (int i = 0; i < length - 1; i++)
    {
        for (int j = 0; j < length - 1 - i; j++)
        {
            if (p[j] > p[j + 1])
            {
                p[j] = p[j] + p[j + 1];
                p[j+1] = p[j] - p[j + 1];
                p[j] = p[j] - p[j + 1];
            }
        }
    }
}
int main(void)
{
    int arr[10] = { 5,4,6,7,8,2,1,3,9,0 };
    int len = sizeof(arr) / sizeof(arr[0]);
    BubbleSort(arr,len);
    for (int i = 0; i < len; i++)
    {
        printf("%d ",arr[i]);
    }
    putchar(10);
    return 0;

简单选择排序

void SelectSort(int* a, int len)
{
	int temp = a[0];
	int index = 0;
	for (int i = 0; i < len - 1; i++)
	{
		temp = a[i];
		index = i;
		for (int j = i + 1; j < len; j++)
		{
			if (a[j] < temp)
			{
				temp = a[j];
				index=j;
			}
		}
		if (index != i)
		{
			a[index] = a[i];
			a[i] = temp;
		}
	}

}

快速排序

void QuickSort(int* arr, int begin, int end) {
	if (begin > end)
		return;
	int tmp = arr[begin];
	int i = begin;
	int j = end;
	while (i != j) {
		while (arr[j] >= tmp && j > i)
			j--;
		while (arr[i] <= tmp && j > i)
			i++;
		if (j > i) {
			int t = arr[i];
			arr[i] = arr[j];
			arr[j] = t;
		}
	}
	arr[begin] = arr[i];
	arr[i] = tmp;
	Quick_Sort(arr, begin, i - 1);
	Quick_Sort(arr, i + 1, end);
}

排序（大根堆)堆

//调整大顶堆
void AdjustHeapSort(int* a, int root, int last)
{
	int child = 2 * root + 1;
	for (; 2 * root + 1 <= last; root = child)
	{
		child = 2 * root + 1;
		if ((child + 1 <= last) && (a[child] < a[child + 1]))
		{
			child++;

		}
		if (a[child] > a[root])
		{
			a[child] = a[child] ^ a[root];
			a[root] = a[child] ^ a[root];
			a[child]= a[child] ^ a[root];
		}
	}
}
void swap(int* x, int* y)
{
	*x = *x + *y;
	*y = *x - *y;
	*x = *x - *y;
}
void HeapSort(int* a, int length)
{
	//构建大根堆
	for (int i = length / 2 - 1; i >= 0; i--)
	{
		AdjustHeapSort(a, i, length - 1);
	}
	//调整大根堆
	for (int i = length- 1; i >= 0; i--)
	{
		swap(&a[0], &a[i]);
		AdjustHeapSort(a, 0, i - 1);
	}

}

main.c

int main(void)
{
	int arr[10] = { 3,4,6,7,9,8,5,1,0,2 };
	int len = sizeof(arr) / sizeof(arr[0]);
	SelectSort(arr, len);
	for (int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	putchar(10);
	return 0;
}

归并排序

void merge(int* a, int start, int mid, int end)
{
	int Left_len = mid - start + 1;
	int Right_len = end - mid;
	int* L = (int*)malloc(sizeof(int) * Left_len);
	int* R = (int*)malloc(sizeof(int) * Right_len);
	if (NULL == L || NULL == R)
	{
		printf("malloc failure!\n");
		return;
	}
	//左边的数循环放在左边
	int k = start;
	for (int i = 0; i < Left_len; i++, k++)
	{
		L[i] = a[k];
	}
	//右边的数循环放在右边
	for (int j = 0; j < Right_len; j++, k++)
	{
		R[j] = a[k];
	}

	k = start;
	int i = 0, j = 0;
	for (i = 0, j = 0; i < Left_len && j < Right_len; k++)
	{
		if (L[i] < R[j])
		{
			a[k] = L[i++];
		}
		else
		{
			a[k] = R[j++];
		}

	}
	if (i < Left_len)
	{
		for (; i < Left_len; i++, k++)
		{
			a[k] = L[i];
		}
	}
	if (j < Right_len)
	{
		for (; j < Right_len; j++, k++)
		{
			a[k] = R[j];
		}
	}
	free(L);
	free(R);
}
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 RadixSort(int* a, int length)
{
	//第一步找出最大值
	int max = a[0];
	int base = 1;
	for (int i = 0; i < length; i++)
	{
		if (max < a[i])
		{
			max = a[i];
		}
	}
	//用于个十百位=出现的次数以及每个数存放的位置
	int bucket[10] = { 0 };
	int* t = (int*)malloc(sizeof(int) * length);
	if (t == NULL)
	{
		printf("malloc failure!\n");
		return;
	}
	int count = 0;
	while (max / base > 0)
	{
		for (int i = 0; i < length; i++)
		{
			//依次收集个，十，百位等出现的次数
			bucket[(a[i] / base) % 10]++;
		}
		//确定每个元素所存在的位置
		for (int i=1; i < 10; i++)
		{
			bucket[i] += bucket[i - 1];
		}
		for (int i = length - 1; i>=0; i--)
		{
			t[bucket[a[i] / base % 10] - 1] = a[i];
			bucket[a[i] / base % 10]--;
		}
		for (int i = 0; i < length; i++)
		{
			a[i] = t[i];
		}
		base *= 10;
		memset(bucket, 0, sizeof(bucket));
	}
	printf("count=%d\n", count);
	free(t);
}