排序算法个人总结(一)

排序分为内部排序和外部排序，内部排序是待排序的记录数不太多，所有数据都放在了存储器里面，外部排序是待排序的记录数太多，内存容纳不了全部数据，排序中需要对外存进行访问
冒泡排序是我在学习过程中见过的第一个排序算法，
它需要记住：n个数比较n-1趟，每一趟注意都两两比较，如果后面的元素比本元素大（小）就两两数值交换
冒泡排序最好情况下时间复杂度为O(n),最坏为O(n²)
冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法

#include<iostream>
using namespace std;
void bubble_sort(int a[], int n);
void bubble_sort(int a[], int n)
{
    int i, j, temp;
    for (j = 0; j < n - 1; j++)
        for (i = 0; i < n - 1 - j; i++)
        {
            if(a[i] > a[i + 1])//从小到大，如果从大到小就if(a[i]<a[i+1])
            {
                temp = a[i];
                a[i] = a[i + 1];//应该是在栈里面进行的赋值..可是主方法传入的是地址，所以方法调用完毕后
                a[i + 1] = temp;//数值是改变了的,详见《C和指针》..
            }
        }
}
 
int main()
{
    int a[6] = {4, 2, 8, 6, 24, 5};
    int i;
    bubble_sort(a, 6);
    for (i = 0; i < 6; i++)
    {
        cout<<a[i]<<endl;
    }
}

/*
*选择排序
*/
选择排序我感觉是最直观最简单的一种排序算法，就是把一组数字分成两个区域，分别是有序区和无序区，第i趟排序开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区
//效率分析代码。在比较次数上为n*(n-1)/2,时间复杂度为o(n*n)。
//在最好的情况下，数字初始有序则只需要比较即可，不存在交换操作。
//在最差情况下，数字初始逆序。同样时间复杂度为o(n*n)。
//交换次数比冒泡排序少多了，由于交换所需CPU时间比比较所需的CPU时间多，n值较小时，选择排序比冒泡排序快
以下是来自百科的代码：

#include<stdio.h>
#include<stdlib.h>
void swap(int*a,int*b)
{
    int temp;
    temp=*a;
    *a=*b;
    *b=temp;
}
void select_sort(int A[],int n)
{
    register int i,j,min,m;
    for(i=0;i<n-1;i++)
    {
        min=i;//查找最小值
        for(j=i+1;j<n;j++)
        {
            if(A[min]>A[j])
            {
                min=j;
            }
        }
        if(min!=i)
        {
            swap(&A[min],&A[i]);
            printf("第%d趟排序结果为:\n",i+1);
            for(m=0;m<n;m++)
            {
                if(m>0)
                {
                    printf("");
                }
                printf("%d",A[m]);
            }
            printf("\n");
        }
    }
}
int main(void)
{
    int n;
    while(scanf("%d",&n)!=EOF) 
    {
        int i;
        int*A=(int*)malloc(sizeof(int)*n);
        for(i=0;i<n;i++)
        {
            scanf("%d",&A[i]);
        }
        select_sort(A,n);
        printf("最终排序结果为:\n");
        for(i=0;i<n;i++)
        {
            if(i>0){
                printf("");
            }
            printf("%d",A[i]);
        }
        printf("\n");
    }
    return 0;
}

/*
*直接插入排序
*/
直接插入排序据说是一种最简单的排序算法，第i趟直接插入排序的操作为：在含有i-1个记录的有序子序列r[1...i-1]中
插入一个记录r[i]后，变成含有i个记录的有序子序列r[1...i],并且为了在查找插入位置的过程中避免数组下标出界，在r[0]处设置监视哨，监视哨就是一个待插入的元素在自i-1起往前搜索的过程中，同时后移记录，整个排序过程为n-1次插入
插入排序算法的时间复杂度为O(n^2）。因而，插入排序不适合对于数据量比较大的排序应用。如果一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，所以插入排序是稳定的。
下面给出伪代码：

void InsertSort(SqList&L){
	for(i=2;i<=L.length;i++)
		if(LT(L.r[i].key,L.r[i-1].key)){
			L.r[0]=L.r[i];//复制为哨兵
			L.r[i]=L.r[i-1];
			for(j=i-2;LT(L.r[0].key,L.r[j].key);j--)
				L.r[j+1]=L.r[j];//记录后移
			L.r[j+1]=L.r[0];//插入到正确位置
		}
	
}