数据结构与算法 4:排序算法,选择/插入/冒泡/希尔/快速/归并

【本文谢绝转载，原文来自http://990487026.blog.51cto.com】

排序算法平均复杂度

冒泡排序 O(n2)

选择排序 O(n2)

插入排序 O(n2)

希尔排序 O(n1.5)

快速排序 O(N*logN)

归并排序 O(N*logN)

堆排序 O(N*logN)

基数排序 O(d(n+r))

选择排序:

[email protected]://990487026.blog.51cto.com~/sort$ cat main.c 
#include "stdio.h"
#include "stdlib.h"
#include "string.h"

void printArray01(int array[], int len)
{
	int i = 0;
	for(i=0; i<len; i++)
	{
		printf("%d ", array[i]);
	}
	printf("\n");
}

void swap01(int array[], int i, int j)
{
	int temp = array[i];
	array[i] = array[j];
	array[j] = temp;
}

void SelectionSort(int array[], int len) // O(n*n)
{
	int i = 0;
	int j = 0;
	int k = -1;

	for(i=0; i<len; i++)
	{
		k = i; //寻找最小元素的下标
		for(j=i+1; j<len; j++)
		{
			if( array[j] < array[k] ) //开始寻找最小元素的下标
			{
				k = j;
			}
		}
		swap01(array, i, k);
	}
}

int main()
{
	int array[] = {12, 5, 433, 253, 216, 7};
	int len = sizeof(array) / sizeof(*array); 

	printArray01(array, len);
	SelectionSort(array, len);
	printArray01(array, len);
	return 0;
}

[email protected]://990487026.blog.51cto.com~/sort$ gcc main.c -Wall && ./a.out 
12 5 433 253 216 7 
5 7 12 216 253 433 
[email protected]://990487026.blog.51cto.com~/sort$

插入法排序:

[email protected]://990487026.blog.51cto.com~/sort$ cat main.c 
#include <stdio.h>
void insert_sort(int *arr,int len)//时间复杂度 O^2
{
	int i = 0;
	int j = 0;
	int k = 0;
	int t = -1;
	for(i=1;i<len;i++)
	{
		k=i;//待插入位置
		t=arr[k];
		for(j=i-1;(j>=0 && (arr[j]>t));j--)
		{
			arr[j+1]  =arr[j];//元素往后移动
			k = j;		//k  需要插入的位置
		}
		arr[k] = t;	//元素插入
	}
}

void print_arr(int *arr,int len)
{
	int i = 0;
	for(i=0;i<len;i++)
	{
		printf("%d ",*(arr+i));
	}
	printf("\n");
}

int main()
{
	int arr[] = {12,55,66,11,22,1,99,2,7};
	print_arr(arr,sizeof(arr)/sizeof(int));
	insert_sort(arr,sizeof(arr)/sizeof(int));
	print_arr(arr,sizeof(arr)/sizeof(int));

	return 0;
}
[email protected]://990487026.blog.51cto.com~/sort$ gcc main.c -Wall && ./a.out 
12 55 66 11 22 1 99 2 7 
1 2 7 11 12 22 55 66 99 
[email protected]://990487026.blog.51cto.com~/sort$

冒泡排序(增强版):相邻元素比较

[email protected]://990487026.blog.51cto.com~/sort$ cat main.c 
#include "stdio.h"
#include "stdlib.h"
#include "string.h"

void printfArray03(int array[], int len)
{
	int i = 0;

	for(i=0; i<len; i++)
	{
		printf("%d ", array[i]);
	}
	printf("\n");
}

void swap03(int array[], int i, int j)
{
	int temp = array[i];
	array[i] = array[j];
	array[j] = temp;
}

void BubbleSort(int array[], int len) // O^2
{
	int i = 0;
	int j = 0;
	int exchange = 1; //表明数组是否已经排好序 已经排好序为0   1表示没有排好序
	for(i=0; (i<len) && exchange; i++)//只要完全排好了,就直接跳出来
	{
		exchange = 0;//认为已经排序完毕的标签，如果在内部没有改变状态则认为已经排序完成。
		for(j=len-1; j>i; j--)
		{
			if( array[j] < array[j-1] )
			{
				swap03(array, j, j-1);
				exchange = 1;//
			}
		}
	}
}

int main()
{
	int array[] ={8,3,6,1,222,4,778,963,12,45,7,8};
	int len = sizeof(array) / sizeof(*array); 
	printfArray03(array, len);
	BubbleSort(array, len);
	printfArray03(array, len);
	return 0;
}
[email protected]://990487026.blog.51cto.com~/sort$ gcc main.c -Wall && ./a.out 
8 3 6 1 222 4 778 963 12 45 7 8 
1 3 4 6 7 8 8 12 45 222 778 963 
[email protected]://990487026.blog.51cto.com~/sort$

希尔排序(分组技术)

[email protected]://990487026.blog.51cto.com~/sort$ cat main.c 
#include "stdio.h"
#include "stdlib.h"
#include "string.h"

void println(int array[], int len)
{
	int i = 0;

	for(i=0; i<len; i++)
	{
		printf("%d ", array[i]);
	}

	printf("\n");
}
void swap(int array[], int i, int j)
{
	int temp = array[i];
	array[i] = array[j];
	array[j] = temp;
}

void InertionSort_ddddd(int array[], int len) // O(n*n)
{
	int i = 0;
	int j = 0;
	int k = -1;
	int temp = -1;

	//{12, 5, 433, 253, 216, 7};
	for(i=1; i<len; i++)
	{
		k = i; //待插入位置
		temp = array[k];

		for(j=i-1; (j>=0) && (array[j]>temp); j--)
		{ 
			array[j+1] = array[j]; //元素后移
			k = j; //k需要插入的位置
		}

		array[k] = temp;//元素插入
	}
}

//nlogn
void ShellSort(int array[], int len) //
{
	int i = 0;
	int j = 0;
	int k = -1;
	int temp = -1;
	int gap = len;
	do
	{
		 //业界统一实验的 平均最好情况 经过若干次后，收敛为1
		gap = gap / 3 + 1; //gap /2345 2000 都行  //O（n 1.3）

		for(i=gap; i<len; i+=gap)
		{
			k = i;
			temp = array[k];

			for(j=i-gap; (j>=0) && (array[j]>temp); j-=gap)
			{
				array[j+gap] = array[j];
				k = j;
			}

			array[k] = temp;
		}

	}while( gap > 1 );

}

int main()
{
	int array[] = {12, 5, 433, 253, 216, 7,12,4,6,76,88,12,13,4,6};
	int len = sizeof(array) / sizeof(*array); 

	println(array, len);
	ShellSort(array, len);
	println(array, len); 
	return 0;
}

[email protected]://990487026.blog.51cto.com~/sort$ gcc main.c -Wall && ./a.out 
12 5 433 253 216 7 12 4 6 76 88 12 13 4 6 
4 4 5 6 6 7 12 12 12 13 76 88 216 253 433 
[email protected]://990487026.blog.51cto.com~/sort$

快速排序(递归)

[email protected]://990487026.blog.51cto.com~/sort$ cat main.c 
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
void printArray(int array[], int len)
{
	int i = 0;

	for(i=0; i<len; i++)
	{
		printf("%d ", array[i]);
	}

	printf("\n");
}

void swap5(int array[], int i, int j)
{
	int temp = array[i];
	array[i] = array[j];
	array[j] = temp;
}
//划分过程 第一个元素当枢轴，分成2个有效子序列
int partition(int array[], int low, int high)
{
	int pv = array[low];

	while( low < high )
	{
		while( (low < high) && (array[high] >= pv) )
		{
			high--; //比基准大，本来就在右边，所以high前移动
		}
		swap5(array, low, high);
		while( (low < high) && (array[low] <= pv) )
		{
			low++;
		}
		swap5(array, low, high);
	}
	//返回枢轴的位置。。。重要
	return low;
}

//让n个元素 依此减少 减少到1个元素的时候，因为1个元素可以看成一个有序的序列

void QSort2(int array[], int low, int high)
{
	if( low < high )
	{
		int pivot = partition(array, low, high);

		//对子序列1排序
		QSort2(array, low, pivot-1);
		//对子序列2排序
		QSort2(array, pivot+1, high);
	}
}

void QSort(int array[], int low, int high)
{
	if( low < high )
	{
		int pivot = partition(array, low, high);

		//对子序列1排序
		QSort2(array, low, pivot-1);
		//对子序列2排序
		QSort2(array, pivot+1, high);
	}
}

void QuickSort(int array[], int len) // O(n*logn)
{
	QSort(array, 0, len-1);
}

int main()
{
	int array[] = {12, 5, 433, 253, 216, 7};
	//int array[] = {12, 5};
	int len = sizeof(array) / sizeof(*array); 
	printArray(array, len);
	QuickSort(array, len);
	printArray(array, len);
	return 0;
}

[email protected]://990487026.blog.51cto.com~/sort$ gcc main.c -Wall && ./a.out 
12 5 433 253 216 7 
5 7 12 216 253 433 
[email protected]://990487026.blog.51cto.com~/sort$

归并排序:

[email protected]://990487026.blog.51cto.com~/sort$ cat main.c 
#include <stdio.h>
#include <malloc.h>

void printArray06(int array[], int len)
{
	int i = 0;
	for(i=0; i<len; i++)
	{
		printf("%d ", array[i]);
	}
	printf("\n");
}

void swap6(int array[], int i, int j)
{
	int temp = array[i];
	array[i] = array[j];
	array[j] = temp;
}

void Merge(int src[], int des[], int low, int mid, int high)
{
	int i = low;
	int j = mid + 1;
	int k = low;

	while( (i <= mid) && (j <= high) ) //将小的放到目的地中
	{
		if( src[i] < src[j] )
		{
			des[k++] = src[i++];
		}
		else
		{
			des[k++] = src[j++];
		}
	}

	while( i <= mid )  //若还剩几个尾部元素
	{
		des[k++] = src[i++];
	}

	while( j <= high ) //若还剩几个尾部元素
	{
		des[k++] = src[j++];
	}
}

//每次分为两路 当只剩下一个元素时，就不需要在划分
void MSort(int src[], int des[], int low, int high, int max)
{
	if( low == high ) //只有一个元素，不需要归并，结果赋给des[low]
	{
		des[low] = src[low]; 
	}
	else //如果多个元素，进行两路划分
	{
		int mid = (low + high) / 2;
		int* space = (int*)malloc(sizeof(int) * max);

		//递归进行两路，两路的划分 
		//当剩下一个元素的时，递归划分结束，然后开始merge归并操作
		if( space != NULL )
		{
			MSort(src, space, low, mid, max); 
			MSort(src, space, mid+1, high, max);
			Merge(space, des, low, mid, high); //调用归并函数进行归并
		}

		free(space);
	}
}

void MergeSort(int array[], int len) // O(n*logn)
{
	MSort(array, array, 0, len-1, len);
}

int main()
{

	int array[] = {21, 25, 49, 25, 16, 8};
	int len = sizeof(array) / sizeof(*array); 
	printArray06(array, len);
	MergeSort(array, len);
	printArray06(array, len);
	return 0;
}

[email protected]://990487026.blog.51cto.com~/sort$ gcc main.c -Wall && ./a.out 
21 25 49 25 16 8 
8 16 21 25 25 49 
[email protected]://990487026.blog.51cto.com~/sort$

【本文谢绝转载，原文来自http://990487026.blog.51cto.com】

时间： 2024-10-20 03:33:31

数据结构与算法 4:排序算法,选择/插入/冒泡/希尔/快速/归并的相关文章

在Object-C中学习数据结构与算法之排序算法

笔者在学习数据结构与算法时,尝试着将排序算法以动画的形式呈现出来更加方便理解记忆,本文配合Demo 在Object-C中学习数据结构与算法之排序算法阅读更佳. 目录选择排序冒泡排序插入排序快速排序双路快速排序三路快速排序堆排序总结与收获参考与阅读选择排序选择排序是一种简单直观的排序算法,无论什么数据进去都是 O(n2) 的时间复杂度.所以用到它的时候,数据规模越小越好.唯一的好处可能就是不占用额外的内存空间了吧. 1.算法步骤首先在未排序序列中找到最小(大)元素,存放到排

基础算法之排序(2)--选择排序

1 /********************************************************************************************************** 2 * Function : test 3 * Create Date : 2014/03/23 4 * Author : NTSK13 5 * Email : [email protected] 6 * Copyright : 欢迎大家和我一起交流学习,转载请保持源文件的完整性

算法学习-排序算法

数据结构-算法复杂度时间复杂度事件频度一个算法花费的时间与算法种语句的执行次数成正比,哪个算法种语句执行次数多,它花费时间就多. 一个算法中的语句执行次数称为语句频度或时间频度.记为T(n) eg:计算1-100的和方法一:for循环 T(n) = n + 1 方法二:直接计算 T(n) = 1 时间复杂度一般情况下,算法中的基本操作语句的重复执行次数时问题规模n的某个函数,用T(n)表示,若有某个辅助函数f(n),使得当n趋近于无穷大时,T(n) / f(n) 的极限值为不等于0的常

【C/C++学院】0907-象棋五子棋代码分析/寻找算法以及排序算法

象棋五子棋代码分析编译代码报错: 错误 1 error MSB8031: Building an MFC project for a non-Unicode character set is deprecated. You must change the project property to Unicode or download an additional library. See http://go.microsoft.com/fwlink/p/?LinkId=286820 for mo

算法之排序算法总结

算法之排序算法总结 | Carrie博客全部全部博客友链关于 ps:这里的排序都是从小到大进行排列. 冒泡排序算法思想:从第一个数开始,将两个相邻的数进行比较,如果前一个数大于后一个数,则互换位置,否则保持不变.这样比较一趟,可以把最大的数放在末尾(根据循环的趟数决定).依次循环,直到排序完成. 时间复杂度:O(n^2) 大专栏算法之排序算法总结li>空间复杂度:O(1) 选择排序算法思想:从待排序的数字中找出最小的数,放在排序数字的最开始,之后依次在未排序的数字中选出最小的数

STL算法之排序算法

STL排序算法通常复杂度坏于线性,且必须要random-access Iterators. 所以,forward_list, list, associative and unordered contains 不提供随机访问迭代器,这些容器不能用排序算法. 但是,forward_list,list提供了成员函数sort,associative contains 自动排序,unordered contains不能排序. 通常,排序元素一次要比保持元素有序要更快.STL提供了不同的排序算法,根据需求选

c/c++ 通用的（泛型）算法之只读算法，写算法，排序算法

通用的(泛型)算法之只读算法,写算法,排序算法只读算法: 函数名功能描述 accumulate 求容器里元素的和 equal 比较2个容器里的元素写算法函数名功能描述 fill 用给定值,覆盖给定的范围的元素 fill_n 用给定值,覆盖给定开始位置后的,n个元素变 back_inserter 在容器末尾插入元素 copy 把容器1指定范围里的值拷贝给容器2,并返回指向容器2最后一个元素的下个元素 replace 用某个值替换掉给定范围的某个值 replace_copy 用某个值替

链表的排序（选择和冒泡）

无聊写了个单链表排序,不是很难.但是插入写起来很麻烦,都没有,本文全部是将链表中节点值互换,不改变结构,所以很容易写出来 #include<iostream> using namespace std; struct node { int n; struct node* next; }; //创建链表 void swap(int &a,int &b) { int c=a; a=b; b=c; } node* create(int a[],int len) { if(len==0)

js排序算法总结——冒泡，快速，选择，插入，希尔，归并

相信排序是任何一个程序猿都会用到的东西,今天简单总结记录下常见的排序算法. 一.冒泡排序说起冒泡排序,可能每个人都不会陌生,实现思路相当简单明了,就是不停的对数组进行两两比较,将较大(较小)的一项放在前面: 如 var arr = [7, 3, 10, 1, 8, 4, 2, 4, 4, 3] 进行升序排列,排序过程如下第一次 [3, 7, 1, 8, 4, 2, 4, 4, 3, 10] 第二次 [3, 1, 7, 4, 2, 4, 4, 3, 8, 10] 以此类推 .... 结果 [1