程序员成长之旅——C语言优化冒泡排序

冒泡排序（未优化）

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
void  swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
void bub_sort(int* arr, int sz)
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		for (int j = 0; j < sz - 1 - i; j++)
		{
			if (arr[j] > arr[j+1])
			{
				swap(&arr[j], &arr[j+1]);
			}
		}
	}
}
void bub_print(int* array, int size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		printf("%d ", array[i]);
	}
	printf("\n");
}
int main()
{
	int array[] = { 2,6,5,8,7,4,9 };
	int size = sizeof(array) / sizeof(int);
	bub_print(array, size);
	bub_sort(array,size);
	bub_print(array, size);
	system("pause");
	return 0;
}

优化一

这种优化适合接近有序的数组，就是做一个标记，如果标记变了继续循环，如果标记没变，证明已经有序，那就结束循环，比普通排序效率能好一点。

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
void  swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
void bub_sort(int* arr, int sz)
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int flag = 0; //每次比较完后都将flag重置为0
		for (int j = 0; j < sz - 1 - i; j++)
		{
			if (arr[j] > arr[j+1])
			{
				swap(&arr[j], &arr[j+1]);
				flag++;
			}
		}
		if (flag == 0)//如果flag没变化的话证明已经有序，则跳出循环
			break;
	}
}
void bub_print(int* array, int size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		printf("%d ", array[i]);
	}
	printf("\n");
}
int main()
{
	int array[] = { 1,2,3,4,5,6,7 };
	int size = sizeof(array) / sizeof(int);
	bub_print(array, size);
	bub_sort(array,size);
	bub_print(array, size);
	system("pause");
	return 0;
}

优化二

假设一串数组前面无序，后面有序，那么优化一效率就不算高了，这时候我们可以想一个办法，就是可以记住最后一次交换的位置，这样的话，我们每次比较就会少后面一部分，效率也会相应提高一点

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
void  swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
void bub_sort(int* arr, int sz)
{
	int i = 0;
	int k = sz - 1;
	int pos = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int num = 0;
		for (int j = 0; j < k; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				swap(&arr[j], &arr[j + 1]);
				num++;
				pos = j ;//记录最后一次交换的位置
			}
		}
		if (num == 0)
			break;
		else
		{
			k = pos;
		}
	}
}
void bub_print(int* array, int size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		printf("%d ", array[i]);
	}
	printf("\n");
}
int main()
{
	int array[] = { 1,2,5,3,4,8,7,9,1 };
	int size = sizeof(array) / sizeof(int);
	bub_print(array, size);
	bub_sort(array, size);
	bub_print(array, size);
	system("pause");
	return 0;
}

优化三

优化二相对比优化一效率提高了一些，但是还可以再此基础上在优化，那就是我们可以正向排最大的，反向找最小的，同时进行，也就是一次性找到最大和最小的，这样效率会更高。比如（1 ,2，3, 4，5, 0)排序用优化二效率就没那么好了，但用优化三效率就会很高。

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
void  swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
void bub_sort(int* arr, int sz)
{
	int i = 0;
	int k = sz - 1;
	int pos = 0;
	int n = 0;
	int jdp = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int num = 0;
		for (int j = 0; j < k; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				swap(&arr[j], &arr[j + 1]);
				num++;
				pos = j;//记录最后一次交换的位置
			}
		}
		if (num == 0)
			break;
		else
		{
			k = pos;
			num = 0;
			for (int p = k; p > n; p--)
			{
				if (arr[p] < arr[p - 1])
				{
					swap(&arr[p], &arr[p - 1]);
					num++;
					jdp = p;
				}
			}
			n = jdp;
			if (num == 0)
				return;
		}
	}
}
void bub_print(int* array, int size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		printf("%d ", array[i]);
	}
	printf("\n");
}
int main()
{
	int array[] = { 1,2,3,4,5,6,8,7,0 };
	int size = sizeof(array) / sizeof(int);
	bub_sort(array, size);
	bub_print(array, size);
	system("pause");
	return 0;
}