数据结构经典排序算法

//冒泡排序
int bubble_sort(int *arrays,int arr_len) 
{
	if (NULL == arrays || arr_len < 2)
		return 0;

	for (int i = 0; i < arr_len - 1; i++)
	{
		for (int j = 1; j < arr_len - i; j++)
		{
			if (arrays[j-1] > arrays[j])
			{
				int tmp = arrays[j - 1];
				arrays[j - 1] = arrays[j];
				arrays[j] = tmp;
			}
		}
	}
	return 0;
}

//选择排序
int select_sort(int* arrays, int arr_len)
{
	if (NULL == arrays || arr_len < 2)
		return 0;


	for (int i=0;i<arr_len;i++) 
	{
		int min_idx = i;
		int min_val = arrays[i];

		for (int j=i;j<arr_len;j++) 
		{
			if (arrays[j] < min_val)
			{
				min_val = arrays[j];
				min_idx = j;
			}
		}


		int tmp = arrays[i];
		arrays[i] = arrays[min_idx];
		arrays[min_idx] = tmp;

	}
}

//插入排序
int insert_sort(int* arrays, int arr_len)
{
	if (NULL == arrays || arr_len < 2)
		return 0;

	for (int i = 1; i < arr_len; i++) 
	{
		int cur_val = arrays[i];

		for (int j=i-1;j>-1;j--) 
		{
			if (arrays[j] > cur_val)
				arrays[j+1] = arrays[j];
			else
			{
				arrays[j + 1] = cur_val;
				break;
			}

		}
	}

}



//快速排序
int partition(int* arrays, int left,int right)
{
	if (NULL == arrays)
		return 0;


	int base_val = arrays[left];

	while (left < right)
	{
		while (arrays[right] >= base_val && left < right)
			right--;

		if (left < right)
		{
			arrays[left] = arrays[right];
			left++;
		}

		while (arrays[left] < base_val && left < right)
			left++;

		if (left < right)
		{
			arrays[right] = arrays[left];
			right--;
		}

	}

	arrays[left] = base_val;

}

int quick_sort(int* arrays, int left,int right)
{
	if (NULL == arrays )
		return 0;

	if (left < right) 
	{
		int base_idx = partition(arrays, left, right);
		quick_sort(arrays, left, base_idx-1);
		quick_sort(arrays, base_idx + 1, right);
	}
;

}


//希尔排序
int shell_sort(int* arrays, int len)
{
	if (NULL == arrays || len < 2)
		return 0;

	int gap = len / 2;

	while (gap > 0) 
	{
		for (int i= gap;i<len;i++)
		{
			int tmp = arrays[i];
			int pre_idx = i - gap;

			while (pre_idx >= 0 && arrays[pre_idx] > tmp) 
			{
				arrays[pre_idx + gap] = arrays[pre_idx];
				pre_idx = pre_idx - gap;
			}
			arrays[pre_idx + gap] = tmp;
		}

		gap = gap / 2;
	}

	return 0;
}


//归并排序
int merge(int* left, int left_len, int* right, int right_len, int* res) 
{
	if (NULL == res || NULL == left || NULL == right || left_len < 1 || right_len < 1)
		return 0;


	int left_idx = 0;
	int right_idx = 0;
	int res_idx = 0;

	while (left_idx<left_len ||right_idx<right_len) 
	{
		if (left_idx >= left_len && right_idx < right_len) 
		{
			res[res_idx] = right[right_idx];
			res_idx++;
			right_idx++;
		}
		else if (left_idx < left_len && right_idx >= right_len)
		{
			res[res_idx] = left[left_idx];
			res_idx++;
			left_idx++;
		}
		else if (left_idx < left_len && right_idx < right_len) 
		{
			if (left[left_idx]<= right[right_idx])
			{
				res[res_idx] = left[left_idx];
				res_idx++;
				left_idx++;
			}
			else 
			{
				res[res_idx] = right[right_idx];
				res_idx++;
				right_idx++;
			}
		}


	}


	return 0;
}

int merge_sort(int* arrays, int len)
{
	if (NULL == arrays || len < 2)
		return 0;

	int mid = len / 2;

	int* left = new int[mid];
	int* right = new int[len - mid];

	for (int i = 0; i < mid; i++)
		left[i] = arrays[i];

	for (int i = 0; i < len - mid; i++)
		right[i] = arrays[i + mid];


	merge_sort(left, mid);
	merge_sort(right, len - mid);

	merge(left, mid, right, len - mid, arrays);

	delete []right;
	delete []left;

	return 0;
}




//堆排序
int heapify(int* arrays, int cur_node, int len) 
{
	if (cur_node < len) 
	{
		int left = cur_node * 2 + 1;
		int right = cur_node * 2 + 2;

		int max = cur_node;

		if (left < len) 
		{
			if (arrays[left]>arrays[max]) 
			{
				max = left;
			}
		}

		if (right < len) 
		{
			if (arrays[right]>arrays[max]) 
			{
				max = right;
			}
		}


		if (cur_node != max) 
		{
			int tmp = arrays[cur_node];
			arrays[cur_node] = arrays[max];
			arrays[max] = tmp;

			heapify(arrays, max, len);
		}
	}


	return 0;
}



int max_heapify(int* arrays, int len)
{
	if (NULL == arrays || len < 2)
		return 0;

	for (int i=len-1;i>-1;i--) 
	{
		heapify(arrays, i, len);
	}

	return 0;
}


int heap_sort(int* arrays, int len)
{
	if (NULL == arrays || len < 2)
		return 0;


	for (int i=0;i<len;i++) 
	{
		max_heapify(arrays, len - i);

		int tmp = arrays[0];

		arrays[0] = arrays[len-i-1];
		arrays[len - i-1] = tmp;
	}

	return 0;
}


//计数排序
int count_sort(int* arrays, int len)
{
	if (NULL == arrays || len < 2)
		return 0;

	int max = arrays[0];
	int min = arrays[0];

	for (int i=0;i< len;i++)
	{
		if (max < arrays[i])
			max = arrays[i];

		if (min > arrays[i])
			min = arrays[i];
	}

	int tmp_len = max - min + 2;

	int* tmp_buffer = new int[tmp_len];

	for (int i=0;i< tmp_len;i++)
	{
		tmp_buffer[i] = 0;
	}

	for (int i=0;i<len;i++) 
	{
		tmp_buffer[arrays[i]- min]++;
	}

	int array_idx = 0;

	for (int i = 0; i < tmp_len; i++)
	{
		while (tmp_buffer[i] != 0)
		{
			arrays[array_idx] = i + min;
			array_idx++;
			tmp_buffer[i]--;
		}
	}


	delete[]tmp_buffer;

	return 0;

}

//基数排序
int radix_sort(int* arrays, int len)
{
	if (NULL == arrays || len < 2)
		return 0;

	int mod = 10;
	int dev = 1;

	int max_val = arrays[0];

	int* tmp_vals = new int[len];

	for (int i=0;i<len;i++) 
	{
		if (max_val < arrays[i])
			max_val = arrays[i];
	}

	int tmp_max = max_val;

	int max_digit_len = 0;

	while (max_val != 0)
	{
		max_val = (max_val / 10) % 10;
		max_digit_len++;
	}

	int count[10];

	for (int i = 1; i <= max_digit_len; i++)
	{
		for (int j = 0; j < 10; j++)
			count[j] = 0;

		for (int j=0;j<len;j++) 
		{
			int tmp_idx = (arrays[j] / dev) % mod;
			count[tmp_idx]++;
		}

		for (int j=1;j<10;j++) 
		{
			count[j] = count[j - 1] + count[j];
		}

		for (int j = len - 1; j >= 0; j--)
		{
			int tmp_idx = (arrays[j] / dev) % mod;
			tmp_vals[count[tmp_idx] - 1] = arrays[j];
			count[tmp_idx]--;
		}

		for (int j=0;j<len;j++) 
		{
			arrays[j] = tmp_vals[j];
		}

		dev = dev * 10;
	}

	delete[]tmp_vals;
	return 0;
}



int main()
{
	int arrays[] = { 1, 2, 8, 7, 4, 12, 3, 9, 22, 4 };
	radix_sort(arrays,10);

	for (int i = 0; i < 10; i++)
		std::cout << arrays[i] << std::endl;

	return 0;
}

以上就是基本的排序C++代码，亲自码了一遍，有需要请自取。