排序 自己总结 自己写代码

第一种 直接用快速排序 

头文件 <algorithm>   sort ( begin,end ),begin,end为地址，

#include<iostream>
#include<algorithm>
using namespace std
int  main()
{
 int a[20]={2,4,1,23,5,76,0,43,24,65},i;
 for(i=0;i<20;i++)
  cout<<a[i]<<endl;
 sort(a,a+20);
 for(i=0;i<20;i++)
 cout<<a[i]<<endl;
 return 0;
}

1、冒泡排序

     

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


void maopao(int a[],int size);             //   冒泡


void insert(int a[],int size);          //    插入

void shell(int a[],int size);           //   希尔

void xuanzi(int a[],int size);          //  选择

void guibing(int a[],int size);        //   归并

void msort(int a[],int tempa[],int L,int Red);   

void merge(int a[],int tempa[],int L,int R,int Red);


void Quicksort(int a[],int size);       //快排

void Quicksort(int a[],int left,int right);

int main()
{
    int a[]={34,8,64,51,32,21,1,76,5,345,4,345};
    int size=sizeof(a)/sizeof(int);
    // maopao(a,size);
    // insert(a,size);
    //shell(a,size);
    //xuanzi(a,size);
    //guibing(a,size);
    Quicksort(a,size);
    int i=0;
    for(i=0;i<size;i++)

        printf("a[%d]=%d\n",i,a[i]);
    return 0;
}



void maopao(int a[],int size)
{
    int i,j,temp;
    int flag=0;
    for(i=0;i<size-1;i++)
    {

        for(j=0;j<size-1-i;j++)
        {
            if(a[j]>a[j+1])
            {
                temp=a[j];
                a[j]=a[j+1];
                a[j+1]=temp;
                flag++;

            }

        }

        //        if(flag==0)
        //            break;
        printf("%d\n",flag);

    }

}

void insert(int a[],int size)
{
    int i,j,temp,flag=0;
    for(i=1;i<size;i++)
    {
        temp=a[i];
        for(j=i;j>0&&a[j-1]>temp;j--)
        {
            a[j]=a[j-1];
            flag++;
        }
        a[j]=temp;
    }
    // printf("%d\n",flag);
}

void shell(int a[],int size)
{
    int d,i,j,temp;
    for(d=size/2;d>0;d/=2)
    {
        for(i=d;i<size;i+=d)
        {
            temp=a[i];
            for(j=i;j>0&&a[j-d]>temp;j-=d)
            {
                a[j]=a[j-d];
            }
            a[j]=temp;
        }
    }
}

void xuanzi(int a[],int size)
{
    int i,j,min,temp,temp1;
    for(i=0;i<size;i++)
    {
        min=a[i];
        for(j=i;j<size;j++)
        {
            if(a[j]<min)
                temp=j;
            min=a[temp];

        }
        temp1=a[i];
        a[i]=a[temp];
        a[temp]=temp1;

    }
}


void guibing(int a[],int size)
{
    int L=0;
    int Red=size-1;
    int* tempa=(int*)malloc(size*sizeof(int));
    msort(a,tempa,L,Red);
}

void msort(int a[],int tempa[],int L,int Red)
{
    int center;
    if(L<Red)
    {
        center=(L+Red)/2;
        msort(a,tempa, L,center);

        msort(a,tempa, center+1,Red);
        merge(a,tempa,L,center+1,Red);
    }

}

void merge(int a[],int tempa[],int L,int R,int Red)            各种排序算法
{
    int Led=R-1;
    int count=L;
    int size=Red-L+1;
    while((L<=Led)&&(R<=Red))
    {
        if(a[L]>a[R])

            tempa[count++]=a[R++];
        else
            tempa[count++]=a[L++];
    }

    while(R<=Red)
        tempa[count++]=a[R++];


    while(L<=Led)
        tempa[count++]=a[L++];

    int i;
    for(i=0;i<size;i++)
    {
        a[Red]=tempa[Red];
        Red--;
        //          a[Red--]=tempa[Red--];                  //  归并排序 容易出现的问题  对同一个index --的时候
        //一定要小心   他们会同时－

    }

}

void Quicksort(int a[],int size)
{
    Quicksort(a,0,size-1);


}

void Quicksort(int a[],int left,int right)
{
    int cur,temp;
    if(left >= right)return;


    cur=a[left];
    int i=left;
    int j=right;
    while(i<j)
    {
        while(i<j&&a[j]>=cur)j--;
        a[i] = a[j];

        while(i<j&&a[i]<=cur)i++;
        a[j] = a[i];

    }
    a[i]=cur;

    Quicksort(a,left,i-1);
    Quicksort(a,i+1,right);

}

堆排序

#include <stdio.h>
//array是待调整的堆数组，i是待调整的数组元素的位置，nlength是数组的长度
//本函数功能是：根据数组array构建大根堆
void HeapAdjust(int array[],int i,int nLength)
{
    int nChild;
    int nTemp;
    for(;2*i+1<nLength;i=nChild)
    {
        //子结点的位置=2*（父结点位置）+1
        nChild=2*i+1;
        //得到子结点中较大的结点
        if(nChild<nLength-1&&array[nChild+1]>array[nChild])++nChild;
        //如果较大的子结点大于父结点那么把较大的子结点往上移动，替换它的父结点
        if(array[i]<array[nChild])
        {
            nTemp=array[i];
            array[i]=array[nChild];
            array[nChild]=nTemp;
        }
        else break; //否则退出循环
    }
}
//堆排序算法
void HeapSort(int array[],int length)
{
    int i;
    //调整序列的前半部分元素，调整完之后第一个元素是序列的最大的元素
    //length/2-1是最后一个非叶节点，此处"/"为整除
    for(i=length/2-1;i>=0;--i)
    HeapAdjust(array,i,length);
    //从最后一个元素开始对序列进行调整，不断的缩小调整的范围直到第一个元素
    for(i=length-1;i>0;--i)
    {
        //把第一个元素和当前的最后一个元素交换，
        //保证当前的最后一个位置的元素都是在现在的这个序列之中最大的
        array[i]=array[0]^array[i];
        array[0]=array[0]^array[i];
        array[i]=array[0]^array[i];
        //不断缩小调整heap的范围，每一次调整完毕保证第一个元素是当前序列的最大值
        HeapAdjust(array,0,i);
    }
}
int main()
{
    int i;
    int num[]={9,15,7,65,5,76,3,2,1,0};
    HeapSort(num,sizeof(num)/sizeof(int));
    for(i=0;i<sizeof(num)/sizeof(int);i++)
    {
        printf("%d ",num[i]);
    }
    printf("\nok\n");
    return 0;
}