排序算法总结-面试

#include<stdio.h>
void Swap(int A[],int i,int j)
{
  int tmp =0;
  tmp = A[i];
  A[i] = A[j];
  A[j] = tmp;
}
//冒泡排序
void maopao_sort(int A[],int n )
{
    for(int i=0 ;i<n; i++)
    {
        for (int j= 0; j< n-1-i; j++ )
        {
            if(A[j] > A[j+1])
            {
            Swap(A,j,j+1);
            }
        }
    }
}
//选择排序
void selection_sort(int A[],int n)
{
    for (int i=0;i<n-1;i++)
    {   //声明一个辅助变量
        int min = i;
        for (int j=i+1; j<n;j++)
        {
            if (A[j] < A[min])
            {
                min =j ;
            }
        }
    if(min !=i)
    {
        Swap(A,min,i);
    }
        
    }
}
//插入排序
void insert_sort(int A[],int n)
{
 for(int i=1;i<n;i++)
 {
    int get = A[i] ;
    int j = i-1 ;
    //这个是移位操作
    while(j>=0 && A[j] > get)
    {
      A[j+1] =A[j] ;
      j--;
    }
  A[j+1] = get;   
 }
}

///////////归并排序/////////

/****合并函数****/
void Merge(int A[],int left,int mid,int right)
{
    int len = right -left +1;
    int *tmp = new int [len];
    int index = 0;
    int i = left; //前一组数据的起始位置
    int j = mid +1 ; //后一组数据的起始位置
    while(i<=mid && j<=right)
    {
        tmp[index++] = A[i]<=A[j]? A[i++] : A[j++] ; //等号保证归并排序的稳定性
    }
    while(i <= mid)
    {
        tmp[index++] = A[i++] ;
    }
    while( j<=right)
    {
        tmp[index++] = A[j++] ;
    }
    for (int k=0;k<len;k++)
    {
     A[left++] = tmp[k];
    }
}
 void merge_sort(int A[],int left,int right)
 {
    //递归实现方式
   if(left == right) 
      return;
    int mid =(left + right) /2 ;
    merge_sort(A,left,mid) ;
    merge_sort(A, mid+1,right) ;
    Merge(A,left,mid,right) ;
 }

//*************堆排序算法**************/

//建堆和堆调整
void heapjust(int A[],int s,int n)
{
    int tmp ;
    int j ; // j是个工作指针
    tmp = A[s] ;
    for( j =2*s ; j<= n ; j*=2)
    {
        if(j<n && A[j]<A[j+1])
        {
            j =j+1 ;
        }
        if (tmp >= A[j])
             break ;
        A[s] = A[j] ;
        s = j ;
    }
    A[s] = tmp ; //这个时候s指针已经改变了
}

void heapsort(int A[],int n)
{   //两个for循环，第一个是建立堆
    for (int i =n/2 ;i>0 ;i--)
    {
        heapjust(A ,i ,n) ;
    }
    //第二个是交换元素后做堆调整
    for (int i =n ;i >0 ;i--)
    {
        Swap(A,1,i);
        heapjust(A,i,n) ;
    }
}

//*************快速排序***************/
/*快速排序有二分的思想，所以时间复杂度比较低*/
int partation(int A[],int low ,int high)
{
    int key = A[low];
    while(low < high)
    {
        while(low<high && A[high]>= key)
        {
            high --;
        }
        Swap(A,low,high);
        while(low<high && A[low] <= key)
        {
            low ++;
        }
        Swap(A,low,high);
    }
   return low ;
}

void quick_sort(int A[],int low ,int high)
{
    int mykey;
    //递归终止的条件
    if (low < high)
    {
        mykey = partation(A,low,high) ;
        quick_sort(A,low,mykey-1);
        quick_sort(A,mykey+1,high);
    }
    
}

int main(){
    
    int A[] = { 6, 5, 3, 1, 8, 7, 2, 4 };    // 从小到大冒泡排序
    int n = sizeof(A) / sizeof(int);
     //insert_sort(A, n);
    //merge_sort(A, 0 ,n-1);
    // heapsort(A,n);
    quick_sort(A,0 ,n-1) ;
    printf("冒泡排序结果：");
    for (int i = 0; i < n; i++)
    {
        printf("%d ", A[i]);
    }
    printf("\n");
    
    return 0;
}

本文参考：http://www.cnblogs.com/eniac12/p/5329396.html

实现了冒泡排序，插入排序，选择排序，归并排序，堆排序，快速排序 六种主要的排序算法