经典排序算法

1.插入排序

思想：从第二个数开始将待排序的数插入到前面已经排好序的相应位置直到最后一个数插入完毕

2.希尔排序

思想 ： 又称缩小增量排序，将待排序的数分为间距为gap(gap=size/2)的若干组，并将相同间距上的数进行插入排序，然后将gap缩小，直到gap=1时结束

3.选择排序

思想：每次在待排序的序列中找到最小的元素放在序列的起始位置，直到待排序的序列已经全部排好序

4.堆排序

思想：建立一个大根堆，通过最后一个和第一个交换和向下调整，使得最大的数被换到最后面

5.冒泡排序

思想：经过比较和交换，每趟将最大的冒在最后，经过n-1趟将整个序列排好

6.快速排序

思想：找到一个基准值，通过一趟排序，将排序的序列分割成独立的两部分，一部分所有元素均比另一部分的元素小，然后对这两部分分别继续排序，直到排序完成

7. 归并排序

思想：分治，将两个排好序的序列组合成一个排好序的序列
两个有序的数组通过一个一个比较将最终的序列存放到新数组中
.h

#include <iostream>
#include <malloc.h>
#include <string.h>
#include <cstdio>

void print(int *,int );//╢Рс║
void _swap(int *,int *);//╫╩╩╩
// ╡ЕхКеепР
void InsertSort(int* , int );
// оё╤ШеепР
void ShellSort(int* , int );
// я║тЯеепР
void SelectSort(int* , int );
// ц╟ещеепР
void BubbleSort(int* , int );
//©ЛкыеепР
void QuickSort(int* a, int , int );

//归并排序
void MergeSort(int *,int ,int,int * );
void adjustdown(int *arr,int root,int n);
void heapsort(int *arr,int root,int n);

.c

#include <iostream>
#include "paixu.h"
using namespace std;

void print(int *arr,int n)
{
    int i=0;
    while(i<n)
    {
       cout<<arr[i]<<" ";
        i++;
    }
}
void _swap(int *a,int *b)
{
    int temp=*a;
    *a=*b;
    *b=temp;
}
// 插入排序
void InsertSort(int* arr, int n)
{
    int i=1;int k=0;
    while(--n)//控制循环的次数
    {
        //控制交换，当要插入的比前一个元素小时，进行交换，
        //直到遇到大于等于前一个元素才停止交换
        k=i;
        while(i>0&&arr[i]<arr[i-1])
        {

            _swap(&arr[i],&arr[i-1]);
            //交换了之后继续迭代着走
            --i;

        }
        //前i+1个已经排好序，继续插入下一个
        i=k+1;

    }
}
// 希尔排序
void ShellSort(int* arr, int n)
{
    //同等间距上的数值进行插入排序，逐渐使间距变小
    int gap=n/2;int i=0,k=0;
   for(;gap>0;gap=gap/2)
   {

           //将gap间距上的数进行插入排序

      for(int j=0;j<gap;j++)
      {
        //  间距相等的组合进行排序

       for(i=gap+j;(i)<n;i=i+gap)
       {
             k=i;
             while(k>=gap&&arr[k]<arr[k-gap])
           {

            _swap(&arr[k],&arr[k-gap]);
            //交换了之后继续迭代着走
            k=k-gap;

           }
       }

      }
    }

}
// 选择排序
void SelectSort(int* arr, int n)
{
    //从第一个开始找到最小的放在第一个，然后从第二个开始找到最小的放在第二个位置
    //a[i]~a[n-1]中的最小的与arr[i]交换
 int len=n-1;//最后一个元素的下标
 int _min;//最小元素的小标
 int i=0,k=0;
    while(--n)
    {
        //寻找i~len最小的
        //如果arr[_min]>arr[k],则最小下标此时为k
        k=i+1; _min=i;
        while(k<=len)
        {
            if(arr[_min]>arr[k])
            {
                _min=k;
            }
           ++k;
        }
        //找到最小的并交换
        if(i!=_min)
            _swap(&arr[i],&arr[_min]);
        ++i;
    }


}
// 冒泡排序
void BubbleSort(int* arr, int n)
{
    int i,j;//i控制要下浮的次数，j用来比较
    //从第一个到n-i个进行比较将最大的放在后面
    for(i=0;i<n-1;i++)
    {
        for(j=0;j<n-i-1;j++)
        {
            if(arr[j]>arr[j+1])
            _swap(&arr[j],&arr[j+1]);
        }

    }
}
//快速排序
void QuickSort(int* arr, int left, int right)
{
    //先找到一个key 作为基准点从左往右找到比key大的，从右往左找比key小的，
    //然后互换
    int key=arr[(left+right)/2];
    int i=left;int j=right;
    while(i<=j)
    {
        //找大于等于基准点key的
        while(arr[i]<key)
        {
            ++i;
        }
        //找小于等于基准点key的
        while(arr[j]>key)
        {
            --j;
        }

    if(i<=j)
    { //0,2,3,1

            _swap(&arr[i],&arr[j]);
           --j;++i;
    }


        //将数组分成了两半，left~j的比arr[key]小i~right比key大
        //递归

    }
    if(left<=j)
    {
        QuickSort(arr,left,j);//基准点左边的
    }

    if(right>=i)
    {
          QuickSort(arr,i,right);//基准点左边的
    }


}
 int sum_count = 0;

 void  Merge_Sort(int *arr,int left,int mid,int right,int *arr1)
 {


    int i=left,j=mid+1;int k=left; k=i;int m=0;
    //开辟新数组，将左右两个数组的值进行比较，小的放前面
    while(j<=right&&i<=mid)
    {
        if(arr[i]<arr[j])
        {
            arr1[k]=arr[i];
            ++i;

        }
        else
        {
               m=j;
            arr1[k]=arr[m];
            ++j;if(j<=right)++m;
        }
        ++k;
    }

  if(j>right)
  {
      //说明前面数组有剩余，则将i当前位置到mid的数据加到后面

       while(i<=mid)
      {
          arr1[k]=arr[i];
          ++i;++k;
      }
  }
  else
  {  //说明后面数组有剩余，则将j当前位置到right的数据加到后面
     while(j<=right)
      {
         m=j;
          arr1[k]=arr[m];
            ++j;if(j<=right)++m;
        ++k;
      }
  }

  i=left;
  for(;i<=right;i++)
  {
      m=i;
      arr[i]=arr1[m];
      if(m<=right)++m;
  }

 }
//归并排序
void MergeSort(int *arr,int left,int right ,int *arr1)
{


    //将数组分成两半，left-mid  mid+1-right
    //先将左边的排好序 再将右边的排好序  ，再整体排序

    if(left<right)
    {
        //数组的分割
         int mid=(left+right)/2;
        MergeSort(arr,left,mid,arr1);
        MergeSort(arr,mid+1,right,arr1);
        //将分割好的两个有序数组进行合并
        Merge_Sort(arr,left,mid,right,arr1);
    }


}
//建立大根堆
void adjustdown(int *arr,int root,int n)
{
   int child=root*2+1;
   while(child<n)
   {
       if((child+1)<n&&arr[child]<arr[child+1])
       {

           child++;
       }
       if((child)<n&&arr[child]>arr[root])
       {
           _swap(&arr[child],&arr[root]);
             root=child;
            child=2*root+1;
       }
       else
        break;


   }
}
void heapsort(int*brr, int n)//堆排序
{
	//建立一个大堆
	for (int i = (n - 2)/ 2; i >= 0;i--)
	{
		adjustdown(brr, i,n);
	}
	int end =n - 1;
	while (end)//每次将堆顶的值放在最后，再继续向下调整，继续互换
	{
		_swap(&brr[0], &brr[end]);
		adjustdown(brr, 0, end);
		end--;
	}


}


int main()
{
    int arr[]={5,2,3,1};
    int n=sizeof(arr)/sizeof(int);
   //InsertSort( arr,  n);
  // ShellSort(arr, n);
   //SelectSort(arr, n);
   //BubbleSort(arr,  n);
   //QuickSort(arr, 0,n-1);
 // int *arr1= (int *)malloc(sizeof(int *)*sizeof(arr)/sizeof(int));
 //   MergeSort(arr, 0,n-1,arr1);
  heapsort(arr,n);
     print(arr,n);
   // free(arr1);
    return 0;
}