排序

 

#include<stdio.h>

int a[8] = {1,3,5,4,0,2,9,8};

/*
void Insertsort(int *a,int len)  // 直接插入排序
{
    int i,j,tmp;
    for(i = 1; i < len; i++)
    {
        tmp = a[i];
        for(j = i-1; j >= 0; j--)
        {
            if(tmp > a[j])
            {
                a[j+1] = a[j];
            }
            else
            {
                break;
            }
        }
        a[j+1] = tmp;
    }
}

int Shellsort(int a[],int len)    // 希尔排序
{
    int i,j,h,tmp;
    for(h = len / 2; h > 0; h /= 2)
    {
        for(i = h; i < len; i += h)
        {
            tmp = a[i];
            for(j = i; j >= 0; j -= h)
            {
                if(tmp < a[j])
                {
                    a[j+h] = a[j];
                }
                else
                {
                    break;
                }
            }
            a[j+h] = tmp;
        }
    }
}

void Quick(int left,int right)        // 快速排序
{
    int i,j,tmp;
    i = left;
    j = right;
    tmp = a[i];

    if(left >= right)
    {
        return ;
    }
    while(i < j)
    {
        while(tmp <= a[j] && i < j)
        {
            j--;
        }
        if(i < j)
        {
            a[i++] = a[j];
        }
        while(a[i] < tmp && i < j)
        {
            i++;
        }
        if(i < j)
        {
            a[j--] = a[i];
         }
    }
    a[i] = tmp;
    Quick(left,i - 1);
    Quick(i + 1,right);
}

void SelectSort(int *a, int n)    // 简单选择排序
{
	int i, j;
	int temp = 0;
	int flag = 0;

	for (i = 0; i < n - 1; i++)
	{
		temp = a[i];
		flag = i;
		for (j = i + 1; j < n; j++)
		{
			if (a[j] < temp)
			{
				temp = a[j];
				flag = j;
			}
		}
		if (flag != i)
		{
			a[flag] = a[i];
			a[i] = temp;
		}
	}
}

void AdjustMinHeap(int *a, int pos, int len)    // 调整堆
{
	int temp;
	int child;

	for (temp = a[pos]; 2 * pos + 1 <= len; pos = child)
	{
		child = 2 * pos + 1;     
		if (child < len && a[child] > a[child + 1])
		{
			child++;
		}
		if (a[child] < temp)
		{
			a[pos] = a[child];
		}
		else
		{
			break;
		}
	}
	a[pos] = temp;
}

void Swap(int *a, int *b)  // 交换堆数据
{
	int temp;
	temp = *a;
	*a = *b;
	*b = temp;
}

void HeapSort(int *array, int len)  // 堆排序
{
	int i;。

	for (i = len / 2 - 1; i >= 0; i--)  
	{
		AdjustMinHeap(array, i, len - 1);   
	}
	for (i = len -1; i >= 0; i--)
	{
		Swap(&array[0], &array[i]);
		AdjustMinHeap(array, 0, i - 1);
	}
}

void Merge(int array[], int start, int middle, int end)    // 合并
{
	int i, j, k, n1, n2;
	
	n1 = middle - start + 1;              
	n2 = end - middle; 

	int *L = (int *)malloc(n1 * sizeof(int));
	int *R = (int *)malloc(n2 * sizeof(int));

	for (i = 0, k = start; i < n1; i++, k++)
	{
		L[i] = array[k];
	}

	for (i = 0, k = middle + 1; i < n2; i++, k++)
	{
		R[i] = array[k];
	}

	for (k = start, i = 0, j = 0; i < n1 && j < n2; k++)  // 比较后选择放入数据
	{
		if (L[i] < R[j])
		{
			array[k] = L[i];
			i++;
		}
		else
		{
			array[k] = R[j];
			j++;
		}
	}

	if (i < n1)       //  前面数据多于后面数据
	{
		for (j = i; j < n1; j++, k++)
		{
			array[k] = L[j];
		}
	}

	if (j < n2)           //  后面数据多于前面数据
	{
		for (i = j; i < n2; i++, k++)
		{
			array[k] = R[i];
		}
	}
}

void MergeSort(int array[], int start, int end)   // 归并排序
{
	int middle;
	int i;

	if (start < end)
	{
		middle = (start + end) / 2;
		
		MergeSort(array, start, middle);       // 前段
		MergeSort(array, middle + 1, end);     // 后段
		Merge(array, start, middle, end);      // 合并
	}
}
*/
int RadixCountSort(int *index, int *a, int len)    //收集 
{  
	int *count = (int *)malloc(sizeof(int) * 10);
	int i;

    for (i = 0; i < len; ++i)  
    {  
        count[i] = 0;  
    }

    for (i = 0; i < len; ++i)
	{  
        ++count[index[i]];  
    }  
  
	for (i = 1; i < 10; ++i)
	{  
        count[i] += count[i - 1];  
    }  
  
    int *sort = (int *)malloc(sizeof(int) * len);
 
	for (i = len - 1; i >= 0; --i)  
	{  
		--count[index[i]];          
        sort[cqdex[i]]] = a[i];  
    }  
  
    for (i = 0; i < len; ++i)
    {  
        a[i] = sort[i];  
    }
	
    free(sort);    // 释放空间
    free(count);   // 释放空间
    sort = count = NULL; // 防止变成野指针

    return 1;  
}  

int RadixSort(int *a, int len)                      //  分配  
{  
    int *radix = (int *)malloc(sizeof(int) * len);  
  
    int radix_base = 1; 
    int is_ok = 0;

    while (!is_ok)  
    {
		int i;
        is_ok = 1;  
        radix_base *= 10;  
   
        for (i = 0; i < len; ++i)  
		{  
            radix[i] = a[i] % radix_base;  
            radix[i] /= radix_base / 10; 
            if (a[i] / (radix_base / 10) > 0)  
            {  
               is_ok = 0;  
            }
		}
		if (is_ok)  
		{  
           break;         
		}  

        RadixCountSort(radix, a, len);    
	}  
  
    free(radix);  
  
    return 1;  
}  

int main()
{
    int length,i;
    length = sizeof(a)/sizeof(a[0]);

    for(i = 0; i < length; i++)  // 打印原始数据
    {
        printf("%d ",a[i]);
    }
    printf("\n");
/*
    Insertsort(a,length);          // 直接插入排序

    Shellsort(a,length);           // 希尔排序

    Quick(0,length - 1);           // 快速排序

    SelectSort(a, length);         // 简单选择排序

    HeapSort(array, length);       // 堆排序

    MergeSort(a, 0, length -1);    // 归并排序
*/
    RadixSort(a, len);             // 基数排序

    for(i = 0; i < length; i++)  //打印排序后的数据
    {
        printf("%d ",a[i]);
    }
    printf("\n");
    
    return 0;
}