归并排序学习总结，递归法&&插入排序&&冒泡排序&&选择排序&&快速排序

来源：互联网发布：老九门哪个软件编辑：程序博客网时间：2024/05/18 01:49

void gc(int a[],int first,int b[],int end, int temp[])
{
int i, j, m;
i = j = m = 0;
while (i<=first&&j<=end)
{
if (a[i] < b[j])
temp[m++] = a[i++];
else
temp[m++] = b[j++];
}
while (i <= first)
{
temp[m++] = a[i++];
}
while (i <=end)
{
temp[m++] = b[j++];
}

}//这个是整理两个有序的数组，组合成一个有序的数组的方法

#include<iostream>
#include<vector>
#include<algorithm>
#include<set>
using namespace std;
void gc(int a[],int first,int mid,int end, int temp[])//a数组是存放需要排序的数组，temp是临时存放数组
{
int i, j, m,n;
i = first, j = mid+1, m = mid;
n = end;
int k = 0;
while (i<=m&&j<=n)
{
if (a[i] < a[j])
temp[k++] = a[i++];
else
temp[k++] = a[j++];
}//最小值总是被放在temp的考前下标
while (i <= m)
{
temp[k++] = a[i++];
}
while (j <=n)
{
temp[k++] = a[j++];
}//上面两个的作用是把剩下的那个下标未走完的，按顺序给存放到temp数组的最后面
for (int i = 0; i < k; i++)
{
a[first + i] = temp[i];//因为first存放了数组的下标，k统计了已经排序的数字个数
}
}
void fc(int a[],int first ,int end,int temp[])//用到了递归的思想
{
if (end > first)
{
int mid = (first + end) / 2;
fc(a, first, mid, temp);
fc(a, mid + 1, end, temp);
gc(a, first,mid, end, temp);
}
}
int main()
{
int a[] = {2,6,5,9,5,6,3,1,5,8,4},temp[11];
fc(a, 0, 10, temp);
for (int i = 0; i < 11; i++)
{
cout << a[i] << endl;
}
return 0;
}

这样输出的结果是：

1
2
3
4
5
5
5
6
6
8
9

我的参考文献：http://blog.csdn.net/yuehailin/article/details/68961304

他讲的特别好，我只是记录我的学习过程而已。

插入排序

假定第一个元素为已经排好序的，依次对下一个元素进行插入，形成2,3,4,5，6。。。排好序的数组，每个插入进去的数，会导致前面的元素依次往下移动一位。

#include<iostream>

using namespace std;
void gc(int a[],int n)
{
for (int i = 1; i < n; i++)
{
int temp = a[i],j;//这里的temp指的是要插入的那个数
for ( j = i - 1; j >= 0 && a[j] > temp; j--) //for ( j = i - 1; j >= 0 && a[j] > a[i]; j--)这样子是错误的
{
a[j + 1] = a[j];//如果之前已经排好序的数，比要插入的那个数temp要大，那么那些排好序的数，自觉往下移动，直到遇到一个比temp小的，
} //然后跳出循环，然后多执行了依次j--，多以，下面a[j+1]，再给赋值要插入的那个数。
a[j + 1] = temp;
}
}
int main()
{
int a[10] = {2,6,8,9,5,3,6,1,5,4};
gc(a, 10);
for (int i = 0; i < 10; i++)
cout << a[i] << endl;

return 0;
}

最后打印出来，成功的排好序了。

冒泡排序：

时间复杂度是度量算法执行的时间长短，而空间复杂度是度量算法所需存储空间的大小。

算法的时间复杂度记做：T(n)=O(f(n))

在计算时间复杂度的时候，先找出算法的基本操作，然后根据相应的各语句确定它的执行次数，再找出T(n)的同数量级（它的同数量级有以下：1、Log2n、n、nLog2n、n的平方、n的三次方、2的n次方、n!），找出后，f(n)=该数量级，如冒泡排序的时间复杂度为T(n)=O(n*n)。

一、冒泡（Bubble）排序
冒泡排序（BubbleSort）的基本思想是：依次比较相邻的两个数，将小数放在前面，大数放在后面。如此重复下去，直至最终完成排序。
时间复杂度为O(n*n)，适用于排序小列表。

void BubbleSortArray()
{
int i,j,temp;
for(i=1;i<n;i++)
{
for(j=0;i<n-i;j++)
{
if(a[j]>a[j+1]) //比较交换相邻元素
{
temp=a[j]; a[j]=a[j+1]; a[j+1]=temp;
}
}
}
}

个人感觉上面的冒泡排序还不纯，是从上往下，把最大的往下推，下面这个可能会更好些，是从下往上，把小的往上冒

#include <stdio.h>
int main()
{
int array[10] = {15, 225, 34, 42, 52, 6, 7856, 865, 954, 10};
int i, j;
for (i = 0; i < 10; i++)
{
//每一次由底至上地上升
for (j = 9; j > i; j--)
{
if (array[j] < array[j-1])
{
swap(&array[j], &array[j-1]);
}
}
}
for (i = 0; i < 10; i++)
{
printf("%d\n", array[i]);
}
return 0;
}
void swap(int *a, int *b)
{
int temp;
temp = *a;
*a = *b;
*b = temp;
}

选择排序：

选择排序的基本思想是：每一趟从待排序的数据元素中选出最小的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
时间复杂度为O(n*n)，适用于排序小列表。

void SelectSortArray()
{
int i,j,min_index;
for(i=0;i<n-1;i++)
{
min_index=i;
for(j=i+1;j<n;j++) //每次扫描选择最小项
if(arr[j]<arr[min_index]) min_index=j;
if(min_index!=i) //找到最小项交换，将这一项移到列表中的正确位置
{
int temp;
temp=arr[i]; arr[i]=arr[min_index]; arr[min_index]=temp;
}
}
}

//快速排序

void quick_sort(int s[], int l, int r)

{

if (l < r)

{

//Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换参见注1

int i = l, j = r, x = s[l];

while (i < j)

{

while(i < j && s[j] >= x) // 从右向左找第一个小于x的数

j--;

if(i < j)

s[i++] = s[j];

while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数

i++;

if(i < j)

s[j--] = s[i];

}

s[i] = x;

quick_sort(s, l, i - 1); // 递归调用

quick_sort(s, i + 1, r);

}

参考文献：https://www.cnblogs.com/morewindows/archive/2011/08/13/2137415.html

阅读全文

0 0