选择排序和冒泡排序

【选择排序和冒泡排序】

【算法】

蛮力法

选择排序，第一次扫描整个数组，找到最小元素，然后和第一个元素交换。第二次从第二个元素开始扫描数组，找到剩下的元素中最小的与第二个元素交换位置，直到最后。

|  89  45  68  90  29  34  17

  17 | 45  68  90  29  34  89

  17  29 | 68  90  45  34  89

  17  29  34 | 90  45  68  89

  17  29  34  45 | 90  68  89

  17  29  34  45  68 | 90  89

  17  29  34  45  68  89 | 90

冒泡排序，比较数组中的相邻元素，第一轮比较将最大元素沉到数组的最后一个位置。第二轮将第二大的元素沉到倒数第二的位置，直到最后。

 89  45  68  90  29  34  17

 45  89

        68  89

                     29  90

                            34  90

                                    17  | 90

 45 68  89  29  34  17  | 90

          .....   

【时间复杂度】

O(n)=n平方

【代码】

#include <stdio.h>
#include <stdlib.h>

void swap(int *a, int *b)
{
	int tmp;
	tmp = *a;
	*a = *b;
	*b = tmp;
}

void SelectionSort(int *a, int n)
{
	int i, j;
	int min;
	for(i = 0; i <= n - 2; i++)
	{
		min = i;
		for(j = i + 1; j <= n - 1; j++)
			if(a[j] < a[min])
				min = j;
		if( i != min)
			swap(&a[i], &a[min]);
	}
}

void BubbleSort(int a[], int n)
{
	bool flag;
	for(int i = 0; i <= n - 2; i++)
	{
		flag = true;
		for(int j = 0; j <= n - 2 - i; j++)
			if(a[j] > a[j + 1])
			{
				flag = false;
				swap(&a[j], &a[j + 1]);
			}
			if(flag)
				break;
	}
}

int main(void)
{
	int a[] = {3, 5, 7, 9, 2, 1};
	int len;
	len = sizeof(a) / sizeof(int);
	printf("%d\n", len);
	//SelectionSort(a, len);
	BubbleSort(a, len);
	for(int i = 0; i < len; i++)
		printf("%d ",a[i]);
	return 0;
}