《数据结构》代码练习题目【南开大学出版】----排序

插入排序，希尔排序，冒泡排序，选择排序,快速排序，堆排序，归并排序的时间复杂度比较
非常抱歉的是并没有查找的题目了，后续有空的话我会自己写一下模板上传

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>



//直接插入排序
void insertsort(int array[],int n)
//待排序元素用一个数组array[ ] 表示，数组有n个元素
{
    int t,j;
    for(int i=0;i<n;i++)
    {
        t=array[i];
        for(j=i-1;j>=0&&t<array[j];j--)
        {
            array[j+1]=array[j];
        }
    array[j+1]=t;
    }
}

//希尔排序
void  shellsort(int  *array,int n, int  delta)
{
    int t,j;
    for(int i=0;i<n;i++)
    {
        t=array[i];
        for(j=i-delta;j>=0&&t<array[j];j-=delta)
        {
            array[j+delta]=array[j];
        }
    array[j+delta]=t;
    }
}

void  shell(int  *array, int  n)
{
     int i;
    int pdata[9]={50,40,30,20,10,5,3,2,1};
    for(i=0;i<9;i++)
        shellsort(array,1000,pdata[i]);
}

//冒泡排序
void Bubblesort( int array[],int n)
{
    int i,t;
    for(i=1;i<=n;i++)
    {
          for(int j=0;j<n-i;j++)
          {
              if(array[j]>array[j+1])
              {
                  t=array[j];
                  array[j]=array[j+1];
                  array[j+1]=t;
              }
          }
    }
}

//简单选择排序
void Selectsort(int array[],int n)
{
    int i,j,t,min;
    for(i=0;i<n-1;i++)
    {
        min=i;
        for(j=i+1;j<n;j++)
        {
            if(array[j]<array[min])min=j;
        }
        if(j!=min)
        {
            t=array[i];
            array[i]=array[min];
            array[min]=t;
        }
    }
}

//快速排序
void quicksort(int array[],int start , int end)
{
    int i,j,t;
    t=array[start];
    i=start;
    j=end;
    if(start>=end) return;
    while(i<j)
    {
        while(i<j&&array[j]>t)j--;
        if(i<j)array[i++]=array[j];
        while(i<j&&array[i]<t)i++;
        if(i<j)array[j--]=array[i];
    }
    array[i]=t;
    quicksort(array,start,j-1);
    quicksort(array,j+1,end);
    return;
}



//大根堆进行调整
void adjustHeap(int param1, int j, int inNums[])
{
    int temp=inNums[param1];
    for (int k=param1*2+1;k<j;k=k*2+1)
    {
        //如果右边值大于左边值，指向右边
        if (k+1<j && inNums[k]< inNums[k+1])
        {
            k++;
        }
        //如果子节点大于父节点，将子节点值赋给父节点,并以新的子节点作为父节点（不用进行交换）
        if (inNums[k]>temp)
        {
            inNums[param1]=inNums[k];
            param1=k;
        }
        else
            break;
    }
        //put the value in the final position
    inNums[param1]=temp;
}
//堆排序主要算法
void HeapSort(int inNums[],int nums)
{
    //1.构建大顶堆
    for (int i=nums/2-1;i>=0;i--)
    {
                //put the value in the final position
        adjustHeap(i,nums,inNums);
    }
    //2.调整堆结构+交换堆顶元素与末尾元素
    for (int j=nums-1;j>0;j--)
    {
                //堆顶元素和末尾元素进行交换
        int temp=inNums[0];
        inNums[0]=inNums[j];
        inNums[j]=temp;

        adjustHeap(0,j,inNums);//重新对堆进行调整
    }
}

//归并排序
void Merge(int source[],int temp[], int start, int mid, int end)
{
    int i = start, j=mid+1, k = start;
    while(i!=mid+1 && j!=end+1)
    {
        if(source[i] > source[j])
            temp[k++] = source[j++];
        else
            temp[k++] = source[i++];
    }
    while(i != mid+1)
        temp[k++] = source[i++];
    while(j != end+1)
        temp[k++] = source[j++];
    for(i=start; i<=end; i++)
        source[i] = temp[i];
}

//内部使用递归
void MergeSort(int source[], int temp[], int start, int end)
{
    int mid;
    if(start < end)
    {
        mid = (start + end) / 2;
        MergeSort(source, temp, start, mid);
        MergeSort(source, temp, mid+1, end);
        Merge(source, temp, start, mid, end);
    }
}

void fun(int *a,int *b,int n)
{
	for(int i=0;i<n;i++)b[i]=a[i];

}

int main(){
	int a[1000];int x;double time;
    int i;
	LARGE_INTEGER nFreq;
    LARGE_INTEGER nBeginTime;
    LARGE_INTEGER nEndTime;
	int b[1000],c[1000];
	for( i=0;i<1000;i++)//初始化数组
	{
		x=rand()%1000;
		a[i]=x;
	}
	//for(i=0;i<1000;i++)printf("%4d",a[i]);
	QueryPerformanceFrequency(&nFreq);//机器内部定时器的时钟频率
             fun(a,b,1000);


	QueryPerformanceCounter(&nBeginTime);//高精度计时器的值
             insertsort(b,1000);
	QueryPerformanceCounter(&nEndTime);
           time=(double)(nEndTime.QuadPart-nBeginTime.QuadPart)/(double)nFreq.QuadPart;
	printf( "\n直插  \t%0.10f seconds\n", time);

             fun(a,b,1000);
    QueryPerformanceCounter(&nBeginTime);//高精度计时器的值
             shell(b,1000);
	QueryPerformanceCounter(&nEndTime);
           time=(double)(nEndTime.QuadPart-nBeginTime.QuadPart)/(double)nFreq.QuadPart;
	printf( "\n希尔  \t%0.10f seconds\n", time);

            fun(a,b,1000);
    QueryPerformanceCounter(&nBeginTime);//高精度计时器的值
            Bubblesort(b,1000);
	QueryPerformanceCounter(&nEndTime);
           time=(double)(nEndTime.QuadPart-nBeginTime.QuadPart)/(double)nFreq.QuadPart;
	printf( "\n冒泡  \t%0.10f seconds\n", time);


             fun(a,b,1000);
    QueryPerformanceCounter(&nBeginTime);//高精度计时器的值
            Selectsort(b,1000);
	QueryPerformanceCounter(&nEndTime);
           time=(double)(nEndTime.QuadPart-nBeginTime.QuadPart)/(double)nFreq.QuadPart;
    printf( "\n选择  \t%0.10f seconds\n", time);

             fun(a,b,1000);
    QueryPerformanceCounter(&nBeginTime);//高精度计时器的值
            quicksort(b,0,999);
	QueryPerformanceCounter(&nEndTime);
           time=(double)(nEndTime.QuadPart-nBeginTime.QuadPart)/(double)nFreq.QuadPart;
    printf( "\n快排  \t%0.10f seconds\n", time);
	       
           fun(a,b,1000);
    QueryPerformanceCounter(&nBeginTime);//高精度计时器的值
            HeapSort(b,1000);
	QueryPerformanceCounter(&nEndTime);
           time=(double)(nEndTime.QuadPart-nBeginTime.QuadPart)/(double)nFreq.QuadPart;
    printf( "\n堆排序  \t%0.10f seconds\n", time);
	     
           fun(a,b,1000);
    QueryPerformanceCounter(&nBeginTime);//高精度计时器的值
            MergeSort(a,c,0,1000);
	QueryPerformanceCounter(&nEndTime);
           time=(double)(nEndTime.QuadPart-nBeginTime.QuadPart)/(double)nFreq.QuadPart;
	printf( "\n归并  \t%0.10f seconds\n", time);
     for(i=0;i<1000;i++)printf("%4d",c[i]);  
	system("pause");
	return 0;

}```