关闭

东子说算法

标签: 排序算法
75人阅读 评论(0) 收藏 举报
分类:

激励我写博文有很大的原因是,在校电面的时候,被问到了很多基础算法问题。当时瞬间懵哔了。痛定思痛。决定好好复习下常用的基础算法。

一).常见的排序算法。

1).简单选择排序。

基本思想:每一趟在后面n-1个待排的数据中选出一个最小(大)的数据作为有序序列的第i个元素。之后依次循环遍历。

简单选择排序是稳定排序,平均时间复杂度为O(n²),最坏时间复杂度为O(n²),空间复杂度O(1);

static void swap(int a[], int i, int j)
{
	int tmp = 0;
	tmp = a[i];
	a[i] = a[j];
	a[j] = tmp;
}
void SelectSort(int a[], int n)
{
	if (!a && n < 0) return;
	int i = 0, j = 0;
	int k = -1;
	for (; i < n; i++)
	{
		k = i;
		for (j = i + 1; j < n; j++)
		{
			if (a[j] < a[k])
				k = j;
		}
		swap(a, i, k);
	}
}

2).冒泡排序算法

  基本思想:将序列中第一个元素与第二个元素进行比较,若为逆序(升序)a[2] > a[1](a[2] < a[1])则交换,然后再比较第二个元素与第三个元素,依次进行,每趟选出一个最大(小)值。冒泡排序已选择排序的区别:选择排序是每趟与最小(大)值交换,冒泡排序是每趟移动相邻的位置。

  小技巧: 可以在冒泡排序中定义一个变量,用于表示冒泡排序受否排列好了。如果要有一个已经基本有序的序列,则可以减少循环次数。

  冒泡排序属于交换排序,是稳定排序。平均时间复杂度为O(n²),最坏时间复杂度为O(n²),空间复杂度O(1);

void BubbleSort(int a[], int len)
{
	if (!a && len < 0) return;
	int i = 0, j = 0;
	int exchange = 1;
	for (; (i < len - 1) && exchange; i++)
	{
		exchange = 0;
		for (j = 0; j < len - 1 - i; j++)
		{
			if (a[j + 1] < a[j])
			{
				swap(a, j, j + 1);
				exchange = 1;
			}
		}
	}
}

3).快速排序

  基本思想:通过一趟排序将序列分割成独立的两部分,其中一部分的所有数据要比另一部分的所有数据小。基准数据排在两个部分的中间。依次快排两个模块。现在这个算法分为两个过程,一个是根据基准数据划分模块,一个是递归的划分模块及排列数据。

  快速排序也属于交换排序,不稳定排序。平均时间复杂度为O(nlog2n), 最坏时间复杂度为O(n²),空间复杂度为O(nlog2n);

int partion(int a[], int low, int high)
{
	if (!a) return -1;
	int privot = a[low];
	while (low < high)
	{
		while ((low < high) && (a[high] > privot))
			high--;
		swap(a, low, high);
		while ((low < high) && (a[low] <= privot))
			low++;
		swap(a, low, high);
	}
	return low;
}

void Qsort(int a[], int low, int high)
{
	int privot = 0;
	if (low < high)
	{
		privot = partion(a, low, high);
		Qsort(a, low, privot - 1);
		Qsort(a, privot + 1, high);
	}
}
void Quicksort(int a[], int len)
{
	Qsort(a, 0, len - 1);
}

4).归并排序

  基本思想:与快速排序相反,选择排序是先排序再分组,归并排序是先分组再进行排序。归并过程为:比较a[i]和a[j]的大小,若a[i]≤a[j],则将第一个有序表中的元素a[i]复制到r[k]中,并令i和k分别加上1;否则将第二个有序表中的元素a[j]复制到r[k]中,并令j和k分别加上1,如此循环下去,直到其中一个有序表取完,然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。

  归并排序是稳定排序。平均时间复杂度为O(nlog2n), 最坏时间复杂度为O(nlog2n),空间复杂度为O(n);

//对划分的序列进行排序,并放入新的序列中
void Merge(int a[], int des[], int low, int mid, int high)
{
	int i = low;
	int j = mid + 1;
	int k = low;
	while ((i < mid) && (j < high))
	{
		if (a[i] < a[j])
			des[k++] = a[i++];
		else
			des[k++] = a[j++];
	}
	while (i <= mid)               ////一个有序表取完,将有序表中剩余的元素复制到剩下的单元。
		des[k++] = a[i++];
	while (j <= high)
		des[k++] = a[j++];
}
//递归的划分序列,直到总序列中只有一个元素及low = high
void Msort(int a[], int des[], int low, int high, int max)
{
	if (!a) return;
	int mid = 0;
	if (low == high)
	{
		des[low] = a[low];
	}
	else
	{
		mid = (low + high) / 2;
		int *space = malloc(sizeof(int)* max);
		if (!space)
			return;
		else
		{
			Msort(a, space, low, mid, max);
			Msort(a, space, mid + 1, high, max);
			Merge(space, des, low, mid, high);
		}
		free(space);
	}
}

5).插入排序

  基本思想:每步将一个待排序的记录,按照其大小插入到前面的已经排序好的序列中,直到数据全部插入为止。

  插入排序是稳定排序,平均时间复杂度为O(n²),最坏时间复杂度为O(n²),空间复杂度为O(1);

void InsertSort(int a[], int len)
{
	if (!a) return;
	int i = 0, j = 0;
	int k = 0;
	int tmp = 0;
	for (i = 1; i < len; i++)
	{
		k = i;
		tmp = a[k];
		for (j = i - 1; (j >= 0) && (a[j] > tmp); j--)
		{
			a[j + 1] = a[j];
			k = j;
		}
		a[k] = tmp;
	}
}







0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:78次
    • 积分:10
    • 等级:
    • 排名:千里之外
    • 原创:1篇
    • 转载:0篇
    • 译文:0篇
    • 评论:0条
    文章存档
    阅读排行
    评论排行