数据结构之排序算法

最新推荐文章于 2023-08-09 18:16:03 发布
最新推荐文章于 2023-08-09 18:16:03 发布
阅读量3.5k 收藏 20
点赞数 1
分类专栏： 数据结构&算法
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/fantasy_wxe/article/details/8712955
版权

排序算法

1.冒泡排序（Bubble Sort）

1)算法伪代码

for i = 1 : n
	swapped = false
	for j = n : i + 1
		if a[j] < a[j - 1]
			交换a[j]和a[j - 1]
			swapped = true
	排好序的数列：a[1...i]
	break if not swapped
end


2)算法原理过程

初始数列：5, 3, 2, 4, 1
i = 1
[
	5, 3, 2, 1, 4
	5, 3, 1, 2, 4
	5, 1, 3, 2, 4
	1, 5, 3, 2, 4
]

i = 2
[
	1, 5, 3, 2, 4
	1, 5, 2, 3, 4
	1, 2, 5, 3, 4
]

i = 3
[
	1, 2, 5, 3, 4
	1, 2, 3, 5, 4
]

i = 4
[
	1, 2, 3, 4, 5
]

3)代码实现

代码实现一：

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

void bubble_sort(int arr[], int length)
{
	int i, j;
	int temp;

	for(i = 0; i < length - 1; ++i)
	{
		for(j = length - 1; j > i; --j)
		{
			if(arr[j] < arr[j - 1])
			{
				temp = arr[j - 1];
				arr[j - 1] = arr[j];
				arr[j] = temp;
			}
		}
	}
}

void print_array(int arr[], int length)
{
	int i = 0;

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

int main(void)
{
	int arr[] = {4, 3, 6, 1, 7, 2, 10, 5, 8, 9};
	int length = 10;

	printf("Before sorting, the array is:");
	print_array(arr, length);

	printf("After Bubble Sorting, the ordered array is:");
	bubble_sort(arr, length);
	print_array(arr, length);

	return 0;
}


对于上述代码可以进行如下优化（swapped变量的作用是：当初始要排序的数列已经是有序的时候，只遍历一遍数列，就退出遍历循环）

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

void bubble_sort(int arr[], int length)
{
	int i, j;
	int temp;

	int swapped = 1;

	for(i = 0; swapped && i < length - 1; ++i)
	{
		swapped = 0;
		for(j = length - 1; j > i; --j)
		{
			if(arr[j] < arr[j - 1])
			{
				temp = arr[j - 1];
				arr[j - 1] = arr[j];
				arr[j] = temp;
				swapped = 1;
			}
		}
	}
}

void print_array(int arr[], int length)
{
	int i = 0;

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

int main(void)
{
	int arr[] = {4, 3, 6, 1, 7, 2, 10, 5, 8, 9};
	int length = 10;

	printf("Before sorting, the array is:");
	print_array(arr, length);

	printf("After Bubble Sorting, the ordered array is:");
	bubble_sort(arr, length);
	print_array(arr, length);

	return 0;
}

4)复杂度分析

稳定的
空间复杂度O(1)
时间复杂度:比较和交换的操作次数，O(n^2)

冒泡排序和插入排序有很多相似的地方。但是比插入排序有稍多的开销。

2.插入排序（Insert Sort）

 1)伪代码实现

for i = 2 : n
    for(k = i; k > 1 and a[k] < a[k - 1]; k--)
        swap a[k, k-1]
    ->排好序的前i个元素：a[1...i]
end

2)算法原理过程

初始无序元素：5, 3, 4, 9, 7, 2, 1, 6, 8

k = 2
   3, 5, 4, 9, 7, 2, 1, 6, 8

k = 3
   3, 4, 5, 9, 7, 2, 1, 6, 8

k = 4
   3, 4, 5, 9, 7, 2, 1, 6, 8

k = 5
   3, 4, 5, 7, 9, 2, 1, 6, 8

k = 6
   3, 4, 5, 7, 2, 9, 1, 6, 8
   3, 4, 5, 2, 7, 9, 1, 6, 8
   3, 4, 2, 5, 7, 9, 1, 6, 8
   3, 2, 4, 5, 7, 9, 1, 6, 8
   2, 3, 4, 5, 7, 9, 1, 6, 8

k = 7
   2, 3, 4, 5, 7, 1, 9, 6, 8
   2, 3, 4, 5, 1, 7, 9, 6, 8
   2, 3, 4, 1, 5, 7, 9, 6, 8
   2, 3, 1, 4, 5, 7, 9, 6, 8
   2, 1, 3, 4, 5, 7, 9, 6, 8
   1, 2, 3, 4, 5, 7, 9, 6, 8

k = 8
   1, 2, 3, 4, 5, 7, 6, 9, 8
   1, 2, 3, 4, 5, 6, 7, 9, 8

k = 9
   1, 2, 3, 4, 5, 6, 7, 8, 9

 

 

3)代码实现

#include <stdio.h>

void insert_sort(int arr[], int length)
{
	int i, j;
	int temp;

	for(i = 1; i < length; ++i)
		for(j = i; j > 0 && arr[j] < arr[j - 1]; --j)
		{
			temp = arr[j - 1];
			arr[j - 1] = arr[j];
			arr[j] = temp;
		}
}

void print_array(int arr[], int length)
{
	int i;
	for(i = 0;  i < length; ++i)
	{
		printf("%d ", arr[i]);
	}
	printf("\n\n");
}

int main(void)
{
	int arr[] = {4, 3, 6, 1, 7, 2, 10, 5, 8, 9};
	int length = 10;

	printf("Before sorting, the array is:");
	print_array(arr, length);

	printf("After Insert Sorting, the ordered array is:");
	insert_sort(arr, length);
	print_array(arr, length);

	return 0;
}

4)算法复杂度分析

时间复杂度：
最好情况为O(n)：即序列已经是升序排列，只需要进行比较操作n-1即可
最坏情况为O(n^2):即序列原来是降序排列，在进行升序排序时，需要n(n-1)/2次的比较，赋值操作是比较操作的次数加上(n-1)次，平均来说插入排序算法的时间复杂度为O(n^2)

空间复杂度：
额外空间O(1）

 

 该算法是排序算法中非常基础的算法，在最坏情况下，算法复杂度为O(n^2),
当数据量比较小，或已接近排好序的情况，该算法是个比较好的选择

3 选择排序（Select Sort）

1)伪代码

for i = 1 : n
      k = i
      for  j = i + 1 : n, 
             if a[j] < a[k]
                  k = j
       ->a[k]是a[i...n]中最小的元素
       交换a[i], a[k]
      -> 排好序的元素：a[1...i]
end

2）算法原理过程

初始无序数列：5, 2, 3, 1, 4
i = 1
[
    k = 1
    j = 2
   因为 a[j] < a[k]
   所以 k = j

 

   k = 2
   j = 3
   因为 a[j] > a[k]
   所以 k不变

 

   k = 2
   j = 4
   因为 a[j] < a[k]
   所以 k = j

 

   k = 4
   j = 5
   因为 a[j] > a[k]
   所以k不变
]
a[i]与 a[k]交换
最后结果为：1, 2, 3, 5, 4

i =  2
[
   过程和上面类似
]

3)代码实现 

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

void select_sort(int arr[], int length)
{
	int i, j, k;
	int temp;

	for(i = 0; i < length - 1; ++i)
	{
		k = i;
		for(j = i + 1; j < length; ++j)
		{
			if(arr[j] < arr[k])
				k = j;
		}
		temp = arr[i];
		arr[i] = arr[k];
		arr[k] = temp;
	}
}

void print_array(int arr[], int length)
{
	int i;
	for(i = 0;  i < length; ++i)
	{
		printf("%d ", arr[i]);
	}
	printf("\n\n");
}

int main(void)
{
	int arr[] = {4, 3, 6, 1, 7, 2, 10, 5, 8, 9};
	int length = 10;

	printf("Before sorting, the array is:");
	print_array(arr, length);

	printf("After Insert Sorting, the ordered array is:");
	select_sort(arr, length);
	print_array(arr, length);

	return 0;
}

4)算法复杂度分析

非稳定的，
空间复杂度：O(1)
时间复杂度：比较的次数,O(n^2)；交换的次数O(n)


选择排序算法的优点是交换的次数是最小的，因此对于交换的操作复杂度非常高的情况下，可以选择使用选择排序算法。

 4 快速排序（Quick Sort）

1)算法原理

初始数列：A[0],A[1],......,A[N-1]

首先任意选取一个数据（通常选用第一个数据）作为关键数据(key)，
然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。


值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。 　　
1）设置两个变量I、J，排序开始的时候：I=0，J=N-1； 　　
2）以第一个数组元素作为关键数据，赋值给key，即 key=A[0]； 　　
3）从J开始向前搜索，即由后开始向前搜索（J=J-1即J--），找到第一个小于key的值A[j]，A[j]与A[i]交换； 　　
4）从I开始向后搜索，即由前开始向后搜索（I=I+1即I++），找到第一个大于key的A[i]，A[i]与A[j]交换； 　　
5）重复第3、4、5步，直到 I=J； (3,4步是在程序中没找到时候j=j-1，i=i+1，直至找到为止。找到并交换的时候i， j指针位置不变。
另外当i=j这过程一定正好是i+或j-完成的最后令循环结束。

一趟快速排序的算法是： 　　

2)算法实现过程

待排序的数组A的值分别是：49 38 65 97 76 13 27 


（初始关键数据：key=49） 注意关键key永远不变，永远是和key进行比较，无论在什么位置，最后的目的就是把key放在中间，小的放前面大的放后面。 　
　A[0] A[1] A[2] A[3] A[4] A[5] A[6] 
  49   38   65    97   76   13   27 
　进行第一次交换后：27 38 65 97 76 13 27 　　( 按照算法的第三步从后面开始找，此时：J=6，A[i] = A[j]) 　　

  进行第二次交换后：27 38 65 97 76 13 65 　　( 按照算法的第四步从前面开始找>key的值，65>49,两者交换，此时：I=2 ,A[j] = A[i]) 　　

  进行第三次交换后：27 38 13 97 76 13 65 　　( 按照算法的第五步将又一次执行算法的第三步从后开始找,此时:J=5,A[i] = A[j]) 　　

  进行第四次交换后：27 38 13 97 76 97 65 　　( 按照算法的第四步从前面开始找大于key的值，97>49，两者交换，此时：I=3,J=5, A[j] = A[i] ) 　　
  此时再执行第三步的时候就发现I=J=4，从而结束一趟快速排序，然后把A[i] = key后:27 38 13 49 76 97 65
  那么经过一趟快速排序之后的结果是：27 38 13 49 76 97 65，即所有大于key=49的数全部在49的后面，所有小于key=49的数全部在49的前面。

3)代码实现

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

int partition(int arr[], int low, int high)
{
    int key = arr[low];

    while(low < high)
    {
        while(low < high && arr[high] >= key)
        {
            high--;
        }
        arr[low] = arr[high];

        while(low < high && arr[low] <= key)
        {
            low++;
        }
        arr[high] = arr[low];
    }

    arr[low] = key;
    return low;
}

void __quick_sort(int arr[], int low, int high)
{
    int mid = partition(arr, low, high);

    if(mid - 1 > low)
    {
        __quick_sort(arr, low, mid - 1);
    }
    if(mid + 1 < high)
    {
        __quick_sort(arr, mid + 1, high);
    }
}

void quick_sort(int arr[], int length)
{
    __quick_sort(arr, 0, length - 1);
}

void print_array(int arr[], int length)
{
	int i;

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

int main()
{
	int arr[] = {49 ,38, 65, 97, 76, 13, 27};
	int length = 7;

	printf("Before sorting, the array is:");
	print_array(arr, length);

	printf("After Quick Sorting, the ordered array is:");
	quick_sort(arr, length);
	print_array(arr, length);

	return 0;
}

4)算法复杂度分析

非稳定的算法

空间复杂度：O(lg(n))

时间复杂度：O(n.lg(n))


归并排序（Merge Sort）

1)算法原理

归并排序就是将两个（或者两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的，

然后再把有序的子序列合并为整体有序序列。

初始数列为：A[0],A[1],...,A[n-1]
算法实现的步骤如下：
1) 把0~n-1的数组分为左数组A[0,...,n/2]和右数组A[n/2 + 1,..., n-1];
2) 对左数组和右数组进行迭代排序
3) 将排好序的左数组和右数组进行合并，那么最后的整个数组就是有序的数组序列。

2)算法实现过程

算法实现过程示意图如下：


3)代码实现

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

void merge(int arr[], int low, int mid, int high)
{
	int length = high - low + 1;

	int *pData = NULL;
	int left = low;
	int right = mid + 1;

	int all = 0;

	//分配空间给pData；
	pData = (int*)malloc(sizeof(int) * length);
//	assert(NULL != pData);
	memset(pData, 0, length);

	//把排好序的左数组和右数组合并后放入pData中；
	while(left <= mid && right <= high)
	{
		if(arr[left] <= arr[right])
		{
			pData[all] = arr[left];
			left++;
			all++;
		}
		else
		{
			pData[all] = arr[right];
			right++;
			all++;
		}
	}

	//移动剩下的数据
	if(left <= mid)
	{
		memmove(&pData[all], &arr[left], sizeof(int) * (mid - left + 1));
	}

	if(right <= high)
	{
		memmove(&pData[all], &arr[right], sizeof(int) * (high - right + 1));
	}

	//把排好序的数列移动到原始数组中
	memmove(&arr[low], pData, sizeof(int) * (high - low + 1));

	free(pData);
}


void __merge_sort(int arr[], int low, int high)
{
	int mid = 0;

	if(low < high)
	{
		mid = low + (high -low) / 2;
		__merge_sort(arr, low, mid);
		__merge_sort(arr, mid + 1, high);
		merge(arr, low, mid, high);
	}
}

void merge_sort(int arr[], int length)
{
	__merge_sort(arr, 0, length - 1);
}

void print_array(int arr[], int length)
{
    int i;

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

int main(void)
{
	int arr[] = {49 ,38, 65, 97, 76, 13, 27};
	int length = 7;

	printf("Before sorting, the array is:");
	print_array(arr, length);

	printf("After Merge Sorting, the ordered array is:");
	merge_sort(arr, length);
	print_array(arr, length);

	return 0;
}

4)算法复杂度分析

归并排序算法可选择用于各种场合，

稳定的排序。即相等的元素的顺序不会改变


时间复杂度为O(nlogn) 这是该算法中最好、最坏和平均的时间性能。 　　

空间复杂度为 O(n) 。
比较操作的次数介于(nlogn) / 2和nlogn - n + 1。 　
赋值操作的次数是(2nlogn)

归并排序比较占用内存，但却效率高且稳定的算法。

引自http://baike.baidu.com/view/19000.htm


C语言冒泡排序（升序）
qq_53862369的博客
06-10 1354
代码实现：
数据结构之排序算法，使用Java实现，包括冒泡排序、选择排序、插入排序、
最新发布
09-26
数据结构之排序算法，使用Java实现，包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序_Data-Structure-Sort-Algorithm
数据结构基础理论--冒泡排序，快速排序...代码实现
我可能只是个小白
02-15 331
数据结构基础理论—查找与排序问题 查找算法 在一堆东西中，找到一个东西 最基本写法： 从头到尾依次寻找，如果找到，就反馈，最后循环完成后，反馈失败 def find_value(data, val): for i,x in enumrate(data): if x == val: return i return -1 监视哨 ...
冒泡排序算法 c++书写升序和降序排序
zhang2039的博客
06-21 4474
冒泡排序是非常经典的排序算法 比如有8个随机的数字，现在把他们升序排列（有小到大排列出来）。当然想到的就是两个比较。这样会有好多轮比较。 第一轮：从左往右开始，左边的和右边的比较，左边 > 右边，交换他们，然后接着向后比较。最后得到的就是这个最大值。 第二轮：剩余的七个数在进行比较，最后又得出一个最大值 . . . 最后一轮 剩余两个数 比较一次叫好了 得到一个最大值 看到上面的比较经过，我们发现有两个重要的参数 、排序 需要比较的轮数 = 元素的个...
C/C++|进行升序排序——冒泡排序法
wacanda的博客
08-09 1193
因为在传值的时候传递了指针变量，在第N次循环的过程中，第N+1项不存在，所以，指针就会乱指，编译器就会报错，于此同时，在运行框内就会发现结果里面多出了一个乱码的结果。冒泡排序的原理是：从左到右，相邻元素进行比较。每次比较一轮，就会找到序列中最大的一个或最小的一个。进行排序时，因为进行的是升序排序，所以进行排序时，会把该数组当中的最大值进行冒泡排序到最后一个下标的位置处（如下所示），通过。因为冒泡排序法已经把除第一项以外的数值排序完毕，所以总共只循环N-1次即可。但是，仅仅排序一次是不够的，所以需要。
数据结构之冒泡排序
LSMSMD0526的博客
09-07 267
文章目录冒泡排序（稳定） 冒泡排序（稳定） 算法思想（默认升序）：每一趟排序均从未排序元素开始，将未排序元素与其后边相邻的元素两两比较，若不符合排序要求则两两交换再进行下一个元素与其相邻元素的比较，那么在第一趟排序结束后最大的数到了数组的最后一个元素处，第二趟排序结束后，未排序元素中的最大数来到了倒数第二个元素处。重复以上过程，直到排序结束。 时间复杂度： 最好情况（待排序数组有序）：O（n） ...
c语言 数据结构 快速排序算法
04-28
c语言版本的数据结构的快速排序算法，适用于新手学习
数据结构学习笔记排序算法：基数排序
09-17
数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数...
数据结构课设排序算法的可视化演示（QT+C++）
12-06
数据结构是计算机科学中的核心课程...总的来说，"数据结构课设排序算法的可视化演示（QT+C++）"是一个综合性的项目，它涵盖了数据结构、算法、编程和可视化等多个方面，对于提升计算机科学学生的综合素质具有重要意义。
数据结构值排序算法.zip
01-15
排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法，分支限界...
排序算法实现代码与伪代码
06-11
本压缩包中包含了各种冒泡算法的代码实现与伪代码实现，附有对排序算法思想的解释，方便读者快速掌握排序算法。
C语言：冒泡排序（升序）
m0_47179741的博客
09-02 1814
C语言实现冒泡排序（升序）
数据结构——冒泡排序
m0_63020222的博客
03-27 4311
八大排序算法之冒泡排序的实现及改进。
数据结构算法总结（伪代码）
热门推荐
耿谊静的博客
06-03 1万+
一：线性表 1. 顺序表 存取方式：顺序访问, 可以随机存取 类型定义：   # define ListSize 100      //最大允许长度      typedef   struct {               ElemType * data;      //存储空间基址                 int   length;     ...
【C语言】冒泡排序（代码解析）
weixin_64714035的博客
03-19 153
【代码】【C语言】冒泡排序（代码解析）
数学结构学习之冒泡排序（含C++代码）
过客璇璇的博客
09-13 882
1.数学结构学习之冒泡排序（含C++代码） 1.1 原理 对于一个未排序的序列，从前向后依次检查每一对相邻元素，一旦发现逆序即交换二者的位置。对于长度为n的序列，共需做n - 1 次比较和不超过n - 1次交换。交换过程的原理如下图： 多数的 这类交换操作，都会使得越小（大）的元素朝上（下）方移动，直至它们抵达各 自应处的位置。 排序过程中，所有元素朝各自最终...
排序算法伪码模板
小菜鸟博客
05-12 2630
排序伪代码模板
伪代码实现三种O(nlogn)排序算法（主要用于理解和记忆）
可乐薯片编程小课堂
03-26 1522
归并排序public class MergeSort { //驱动程序 public int[] mergeSort(参数) { //调用分治程序 sort(A, 0, n-1); return A; } //分治程序 sort(int[] data, int left, int right) { i
数据结构-排序(C语言与伪代码)
qhu1600417010的博客
05-02 5516
这里写目录标题1冒泡排序伪代码原理代码实现2插入排序伪代码原理代码实现3时间复杂度下届4希尔排序伪代码代码实现Hibbard序列5选择排序选择排序原理伪代码代码实现6堆排序堆排序算法1 1冒泡排序 1.待排序数据在数组和链表均可 2.当严格不等的时候，才交换，就是说当等于的时候，不交换这说明算法是稳定的 伪代码 void Bubble_Sort(ElementType A[], int N) { for (p = N - 1; p > 0; p--) { flag = 0; for (i
Java实现数据结构与排序算法精要
"本书以Java语言为背景，深入讲解数据结构和排序算法，内容精炼，适合学习或复习。书中涵盖了线性表、栈、队列以及多种排序算法，如选择排序、堆排序、冒泡排序、快速排序、插入排序、Shell排序、归并排序、桶式排序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值