数据结构排序

**data_struct sort**  

排序是计算机程序设计中的一种重要操作，它的功能是将一个数据元素（或记录）的任意序列，重新排列成一个按关键字有序的序列。排序分为内排序和外排序，内排序的待排序序列都在内存中，外排序则不然。

常用的排序有九种：exchange_sort bubble_sort select_sortinsert_sortshell_sortquite_sort heap_sort merge_sort base_sort等。

下面是这些排序的代码实现:

sort.h

#ifndef _SORT_H_
#define _SORT_H_
int * get_arr(int len);//随机生成数组
void insert_sort(int *arr,int len);//插入排序
void sheel_sort(int *arr,int len);//希尔排序
void quit_sort(int* arr,int len);//快速排序（递归实现）
void quick_sort_loop(int *arr,int len);//快速排序（循环版本）
void meger_sort(int *arr,int len);//归并排序
void heap_sort(int *arr,int len);//堆排序
void show_lite(int *arr,int len);
void show(int *arr,int len);
#endif

sort.cpp

#include "SORT.h"
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <time.h>

//生成数组元素
int * get_arr(int len)
{
 	//srand(time(NULL));
	srand(100);
	int *arr = (int *)malloc(sizeof(int)*len);
	assert(arr != NULL);
	for (int i = 0;i<len;i++)
	{
		arr[i]=rand()+rand()*2;
	}
	return arr;
}

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


//sheel排序

static void sheel(int* arr,int len,int gap)
{
	int i=0;
	int j=0;
	int tmp=0;
	for(i=gap;i<len;i++)
	{
		tmp=arr[i];
		for (j=i-gap;j=0;j=j-gap)
		{
			if (tmp>arr[j])
			{
				break;
			}
			arr[j+gap]=arr[j];
		}
	}

	arr[j+gap]=tmp;
	//insert_sort(arr,len);
}


void sheel_sort(int *arr,int len)
{
	sheel(arr,len,107);
	sheel(arr,len,11);
	sheel(arr,len,3);
	sheel(arr,len,1);
}

//数组输出
void show(int *arr,int len)
{
	for (int i = 0;i<len; i++)
	{
		if (i % 5 == 0)
		{
			printf("\n");
		}
		printf("%5d ",arr[i]);
	}
}

//数组输出精简版
void show_lite(int *arr,int len)
{
	for (int i = 0;i<len;i++)
	{
		printf("%d ",arr[i]);
	}
	printf("\n");
}

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


//快速排序(递归)
int partition(int *arr,int left,int right)
{
	int tmp = arr[left];
	while (left < right)
	{
		while (arr[right] >= tmp && left<right )
		{
			right--;
		}
		arr[left] = arr[right];
		while (arr[left] <= tmp && left<right )
		{
			left++;
		}
		arr[right] = arr[left];
	}
	arr[left]=tmp;
	return left;
}
void quick(int *arr,int left,int right)
{
	if (left<right)
	{
		int base = partition(arr,left,right);
		quick(arr,left,base-1);
		quick(arr,base+1,right);
	}
}

void quit_sort(int* arr,int len)
{
	quick(arr,0,len-1);
}
//快速排序(非递归)

void quick_sort_loop(int *arr,int len)
{
	int *stack = (int *)malloc(sizeof(int)*len*len);
	assert(stack != 0);
	
	int top = 0;
	int left = 0;
	int right = 0;
	int base = 0;

	stack[top++] = 0;
	stack[top++] = len-1;

	while (top != 0)
	{
		right = stack[--top];
		left = stack[--top];
		base = partition(arr,left,right);
	
		if (left<base-1)
		{
			stack[top++] = left;
			stack[top++] = base-1;
		}

		if (base+1 <right)
		{
			stack[top++] = base+1;
			stack[top++] = right;
		}
	}
	free(stack);
}

static void heap_adjust(int *arr,int start,int len)
{
	int tmp = 0;
	int i = 0;
	tmp = arr[start];
	for (i = 2*start+1;i < len;i = 2*i+1)
	{
		if (i+1<len && arr[i]<arr[i+1])
		{
			i++;
		}
		if (tmp > arr[i])
		{
			break;
		}
		else if (tmp < arr[i])
		{
			arr[start] = arr[i];
		}
		start = i;
	}
	arr[start] = tmp;
}


void heap_sort(int *arr,int len)
{
	int start = 0;
	int k = 0;
	for (start = len/2-1;start >= 0;start--)
	{
		heap_adjust(arr,start,len);
	}
	swap(&arr[0],&arr[len-1]);
	for (k = len-1;k > 0;k--)
	{
		heap_adjust(arr,0,k);
		swap(&arr[0],&arr[k-1]);
	}
}
static void meger(int *arr,int len,int gap)
{
	int l1 = 0;
	int h1 = l1+gap-1;
	int l2 = h1+1;
	int h2 = l2+gap-1<len ? l2+gap-1:len-1;


	int *buffer = (int *)malloc(sizeof(int)*len);
	int i = 0;

	while (l2 <len)
	{
		while (l1 <= h1 && l2 <= h2)
		{
			if (arr[l1] <= arr[l2])
			{
				buffer[i++] = arr[l1++];
			}
			else
			{
				buffer[i++] = arr[l2++];
			}
		}
		while(l1 <= h1)
		{
			buffer[i++] = arr[l1++];
		}
		while(l2 <= h2)
		{
			buffer[i++] = arr[l2++];
		}
		l1 = h2+1;
		h1 = l1+gap-1;
		l2 = h1 + 1;
		h2 = l2+gap-1<len ? l2+gap-1:len-1;
	}
	while (l1 < len)
	{
		buffer[i++] = arr[l1++];
	}
	for (int i=0;i<len;i++)
	{
		arr[i] = buffer[i];
	}
}

void meger_sort(int *arr,int len)
{
	int gap = 1;
	for(gap = 1;gap<len;gap = gap*2)
	{
		meger(arr,len,gap);
	}
}

测试程序

#include "SORT.h"
#include<stdio.h>
#include <stdlib.h>
#include <time.h>
#include<vld.h>


int main()
{
	//int *arr = get_arr(100000);
	//int len = 100000;
	int arr[] = {43,6,25,31,31,78,36,55};
	int len = sizeof(arr)/sizeof(arr[0]);
	//insert_sort(arr,len);
	meger_sort(arr,len);
	//clock_t t1 = clock();
	//quick_sort_loop(arr,len);
	//clock_t t2 = clock();
	//printf("%d个整数排序共用了%ldms\n",len,t2-t1);//计算排序所用时间
	//show(arr,len);
	show_lite(arr,len);
	return 0;
}