插入排序，希尔排序，冒泡排序，堆排序，快排，选择排序，归并排序七种排序算法

转载其他博客，对博客进行了一处错误修改以及添加了计算排序时间与随机数产生数组

具体排序过程可参考其他博客

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

void printArray(int arr[], int n)
{
    int i;
    for(i = 0; i < n; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

//选择排序
void selectSort(int arr[], int n)
{
    int i, j , minValue, tmp;
    for(i = 0; i < n-1; i++)
    {
        minValue = i;
        for(j = i + 1; j < n; j++)
        {
            if(arr[minValue] > arr[j])
            {
                minValue = j;
            }
        }
        if(minValue != i)
        {
            tmp = arr[i];
            arr[i] = arr[minValue];
            arr[minValue] = tmp;
        }
    }
}


//冒泡排序
void bubbleSort(int arr[], int n)
{
    int i, j, tmp;

    for(i = 0; i < n - 1; i++)
    {
        for(j = 1; j < n; j++)
        {
            if(arr[j] < arr[j - 1])
            {
                tmp = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = tmp;
            }
        }
    }
}


//插入排序 
void insertSort(int arr[], int n)
{
    int i, j, tmp;

    for(i = 1; i < n; i++)
    {
        for(j = i; j > 0; j--)
        {
            if(arr[j] < arr[j-1])
            {
                tmp = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = tmp;
            }
            else
            {
                break;
            }
        }
    }

    return;
}


 
//希尔排序
void shellSort(int arr[], int n)
{
    int i, j, elem;
    int k = n/2;

    while(k>=1)
    {
        for(i = k; i < n; i ++)
        {
            elem = arr[i];
            for(j = i; j >= k; j-=k)
            {
                if(elem < arr[j-k])
                {
                    arr[j] = arr[j-k];
                }
                else
                {
                    break;
                }
            }
            arr[j] = elem;
        }
        k = k/2;
    }
}


//归并排序
void merge(int arr[], int l, int mid, int r)
{
    int len,i, pl, pr;
    int *tmp = NULL;

    len = r - l + 1;
    tmp = (int*)malloc(len * sizeof(int));  //申请存放完整序列内存
    memset(tmp, 0x0, len * sizeof(int));

    pl = l;
    pr = mid + 1;
    i  = 0;
    while(pl <= mid && pr <= r)  //两个子序列都有值，比较最小值
    {
        if(arr[pl] < arr[pr])
        {

            tmp[i++] = arr[pl++];
        }
        else
        {
            tmp[i++] = arr[pr++];
        }
    }
    while(pl <= mid)        //左边子序列还有值，直接拷贝到新序列中
    {
        tmp[i++] = arr[pl++];
    }
    while(pr <= r)      //右边子序列还有值
    {
        tmp[i++] = arr[pr++];
    }

    for(i = 0; i < len; i++)
    {
        arr[i+l] = tmp[i];
    }

    free(tmp);
    return;

}

void mergeSort(int arr[], int l, int r)
{
    if(l >= r)
    {
        return;
    }

    int mid = (l + r)/2;
    mergeSort(arr, l, mid);
    mergeSort(arr, mid+1, r);
    merge(arr, l, mid, r);
    return;
}


//堆排序
/*parent(i) = (i-1)/2
  left child  (i) = 2*i + 1
  right child (i) = 2*i + 2
*/

void swap(int *a, int *b)
{
    int tmp;

    tmp = *a;
    *a  = *b;
    *b  = tmp;
    return;
}
void shiftUp(int arr[], int n, int k)
{
    while((k - 1)/2 >= 0 && arr[k] > arr[(k - 1)/2])
    {
        swap(&arr[k], &arr[(k-1)/2]);
        k = (k - 1)/2;
    }
    return;
}
void shiftDown(int arr[], int n, int k)
{
    int j = 0 ;

     while(2*k + 1 < n)
     {
        j = 2 *k + 1;    //标记两个子节点较大的节点，初始为左节点
        if (j + 1 < n && arr[j] < arr[j+1])
        {
            j ++;   
        }

        if(arr[k] < arr[j])
        {
            swap(&arr[k], &arr[j]);
            k = j;
        }
        else
        {
            break;
        }
     }

     return;
}
void heapSort(int arr[], int n)
{
    int i = 0;
    for(i = (n - 1 -1)/2; i >=0; i--)
    {
        shiftDown(arr, n, i);
    }

    for(i = n - 1; i > 0; i--)
    {
        swap(&arr[0], &arr[i]);
        shiftDown(arr, i, 0);
    }
    return;
}
 

//快速排序法  挖坑法
static int partition(int arr[], int l, int r)
{
    int i, j;
    i = l + 1;
    j = l;

    while(i <= r)
    {
        if(arr[i] > arr[l])
        {
            i++;
        }
        else
        {
            swap(&arr[j + 1], &arr[i]);
            i++;
            j++;
        }
    }
    swap(&arr[l], &arr[j]);
    return j;
}

static void _quickSort(int arr[], int l, int r)
{
    int key;
    if(l >= r)
    {
        return;
    }
    key = partition(arr, l, r);
    _quickSort(arr, l, key - 1);
    _quickSort(arr, key + 1, r);
}

void quickSort(int arr[], int n)
{
    _quickSort(arr, 0, n - 1);
    return;
}



int main()
{
	clock_t start, end;
    double time;
	int arr[10];
	int i,choose;
	for(i=0;i<10;i++)
	{
		arr[i]=150+rand()%120;
	}
	while (1)
	{
		printf("*****************************排序选择*****************************\n");
		printf("*****************************1.输出*******************************\n");
		printf("*****************************2.选择排序***************************\n");
		printf("*****************************3.冒泡排序***************************\n");
		printf("*****************************4.插入排序 **************************\n");
		printf("*****************************5.希尔排序***************************\n");
		printf("*****************************6.归并排序 **************************\n");
		printf("*****************************7.堆排序 ****************************\n");
		printf("*****************************8.快速排序***************************\n");
		printf("*****************************9.退出exit***************************\n");
		printf("******************************************************************\n");
		printf("请输入你的选择：");
		scanf("%d", &choose);
		if (choose == 9)
		{
			printf("程序退出》》》");
			break;
		}
		switch (choose)
		{
			case 1:
				printArray(arr, 10);
				break;
			case 2:
				start = clock();
				selectSort(arr, 10);
				end = clock();
				time = (double)(end - start) * 1000.0 / (CLOCKS_PER_SEC);
				printf("排序需要%fms\n", time);
				break;
			case 3:
				start = clock();
				bubbleSort(arr, 10);
				end = clock();
				time = (double)(end - start) * 1000.0 / (CLOCKS_PER_SEC);
				printf("排序需要%fms\n", time);
				break;
			case 4:
				start = clock();
				insertSort(arr, 10);
				end = clock();
				time = (double)(end - start) * 1000.0 / (CLOCKS_PER_SEC);
				printf("排序需要%fms\n", time);
				break;
			case 5:
				start = clock();
				shellSort(arr, 10);
				end = clock();
				time = (double)(end - start) * 1000.0 / (CLOCKS_PER_SEC);
				printf("排序需要%fms\n", time);
				break;
		    case 6:
		    	start = clock();
				mergeSort(arr,0,9);
				end = clock();
				time = (double)(end - start) * 1000.0 / (CLOCKS_PER_SEC);
				printf("排序需要%fms\n", time);
				break;
			case 7:
				start = clock();
				heapSort(arr, 10);
				end = clock();
				time = (double)(end - start) * 1000.0 / (CLOCKS_PER_SEC);
				printf("排序需要%fms\n", time);
				break;
			case 8:
				start = clock();
			    quickSort(arr, 10);
			    end = clock();
			    time = (double)(end - start) * 1000.0 / (CLOCKS_PER_SEC);
			    printf("排序需要%fms\n", time);
				break;
			default:
				printf("error!\a\n");
				break;
		}
	}
    return 0;
}