数据结构与算法（排序算法）_数据结构排序算法论文

引言：我们的数据结构已经学习完基本的知识，但是光有数据结构是不可以的，现在我们将目光放在接下来的内容，基础算法部分。现在我们就开始第一部分的学习——排序算法

一.排序简介

我们最初学习过最经典的三种排序方式，他们分别是起泡排序法，选择排序法，以及插入排序法。这三种排序是最基础的，也是我们应该学会的。现在我们进行下一步的学习，这次我们主要学习三种排序法——快速排序，归并排序，桶排序。让我们一同进入知识的海洋。

二.桶排序

1.定义

桶排序 (Bucket sort)或所谓的箱排序，是一个排序算法，工作的原理是将数组分到有限数量的桶子里。每个桶子再个别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序）。桶排序是鸽巢排序的一种归纳结果。当要被排序的数组内的数值是均匀分配的时候，桶排序使用线性时间（O（n））。但桶排序并不是 比较排序，他不受到 O(n log n) 下限的影响。

2.代码原理

注：因为代码比较简单，所以我们直接进行代码的使用来加深印象。
现在我们给出一组数据——4 4 2 5 5 6 9 10 2 1 3 7，这一共是12个数。现在我们要求将这些数据进行从小到大排序，并去重其中的相关数据，答案应该是——1 2 3 4 5 6 7 9 10

#include <iostream>
using namespace std;
const int N=1e5+3;
int a[N]={0};//定义数组并初始化为0 
int main()
{
	int n=12;
	int m,j,k,l,i;
	for(i=0;i<n;i++)
	{
		cin>>m;
		a[m]++;//使用下表进行加1操作 
	}
	for(i=0;i<N;i++)
	{
		if(a[i]>0)
		{
			cout<<i<<" ";//输出i的值即使所需要的值 
		}
	}
	return 0;
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3.总结

桶排序的平均时间复杂度为线性的O(N+C)，其中C=N(logN-logM)。如果相对于同样的N，桶数量M越大，其效率越高，最好的时间复杂度达到O(N)。当然桶排序的空间复杂度为O(N+M)，如果输入数据非常庞大，而桶的数量也非常多，则空间代价无疑是昂贵的。此外，桶排序是稳定的

三.快速排序

1.定义与原理

定义：速排序（Quicksort）是对冒泡排序的一种改进。 通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。——这样我们得知快速排序是先进行分割在进行递归。
原理：设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选
用数组的第一个数，也可以选择其他）作为关键数据，然后将所有比它小的数都放到它左边，所有比它大的数都放到它右边，这个过程称为一趟快速排序。注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。
一趟快速排序的算法是：
1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；
2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
3）从j开始向前搜索，即由后开始向前搜索(j–)，找到第一个小于key的值A[j]，将A[j]和A[i]的值交换；
4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]的值交换；
5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i++或j–完成的时候，此时令循环结束。

2.代码实现

#include<iostream>
using namespace std;
int n,a[1000001];
void qsort(int l,int r)//快速排序开始
{
    int mid=a[(l+r)/2];//选取任意元素
    int i=l,j=r;
    do//进行循环操作
	{
        while(a[i]<mid) 
		i++;
        while(a[j]>mid) 
		j--;
        if(i<=j)
        {
            swap(a[i],a[j]);
            i++;
            j--;
        }
    }while(i<=j);
    //以下进行递归操作
    if(l<j) 
	qsort(l,j);
    if(i<r) 
	qsort(i,r);
}
int main()
{
	int n,m,j,k,l=0,i;
	cin>>n;
	for(i=1;i<=n;i++)
	{
		cin>>a[i];
	}
	qsort(1,n);
	for(i=1;i<=n;i++)
	{
		cout<<a[i]<<" ";
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

注：这个模板真的是很经典，当年看到它时就觉得这个模板无论如何也要背过，当然，现在我们应该是理解为主。

3.总结

快速排序是一个时间很快的排序，有许多人进行过优化。但是快速排序是一个不稳定的排序，掌握它我们才能进行下一步的学习。

四.归并排序

1.定义与原理

定义：归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。归并排序是一种稳定的排序方法。
原理：
第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置
第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
重复步骤3直到某一指针超出序列尾
将另一序列剩下的所有元素直接复制到合并序列尾

2.代码实现

#include <iostream>
using namespace std;
const int N=1e5+3;
int a[N], tmp[N];
void merge_sort(int q[], int l, int r)
{
    if (l>=r) 
	return;
    int mid=(l+r)>>1;
    merge_sort(q,l,mid);
	merge_sort(q,mid+1,r);
    int k=0,i=l,j=mid+1;
    while(i<=mid&&j<=r)
    {
    	if(q[i]<=q[j])
		 tmp[k++]=q[i++];
        else
		 tmp[k++]=q[j++];
	}
    while(i<=mid) 
	tmp[k++]=q[i++];
    while(j<=r) 
	tmp[k++]=q[j++];
    for(i=l,j=0;i<=r;i++,j++) 
	q[i]=tmp[j];
}
int main()
{
    int n,m,j,k,l,i;
    cin>>n ;
    for(i=0;i<n;i++)
	cin>>a[i];
    merge_sort(a, 0, n - 1);
    for(j=0;j<n;j++)
    cout<<a[j]<<" ";
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

3.总结

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

五.后记

这一次我们介绍三种常用的排序为我们接下来的使用做好基础，这一次的学习就到此结束了，下一次我们是，简单搜索。