常见排序算法(冒泡、选择、插入、快速、归并C++实现)

常见排序算法(冒泡、选择、插入、快速、归并C++实现)

#include <iostream>
using namespace std;
// 冒泡排序
void bubbleSort (int data[], size_t size) {
	for (size_t i = 0; i < size - 1; ++i) {
		bool ordered = true;
		for (size_t j = 0; j < size - 1 - i; ++j)
			if (data[j+1] < data[j]) {
				int temp = data[j+1];
				data[j+1] = data[j];
				data[j] = temp;
				ordered = false;
			}
		if (ordered)
			break;
	}
}
// 插入排序
void insertSort (int data[], size_t size) {
	for (size_t i = 1; i < size; ++i) {
		int temp = data[i];
		size_t j;
		for (j = i; j > 0 && temp < data[j-1]; --j)
			data[j] = data[j-1];
		if (j != i)
			data[j] = temp;
	}
}
// 选择排序
void selectSort (int data[], size_t size) {
	for (size_t i = 0; i < size - 1; ++i) {
		size_t min = i;
		for (size_t j = i + 1; j < size; ++j)
			if (data[j] < data[min])
				min = j;
		if (min != i) {
			int temp = data[i];
			data[i] = data[min];
			data[min] = temp;
		}
	}
}
// 快速排序
void quickSort (int data[], size_t left,
	size_t right) {
	size_t p = (left + right) / 2;
	int pivot = data[p];
	for (size_t i = left, j = right; i < j;) {
		while (! (i>= p || pivot < data[i]))
			++i;
		if (i < p) {
			data[p] = data[i];
			p = i;
		}
		while (! (j <= p || data[j] < pivot))
			--j;
		if (j > p) {
			data[p] = data[j];
			p = j;
		}
	}
	data[p] = pivot;
	if (p - left > 1)
		quickSort (data, left, p - 1);
	if (right - p > 1)
		quickSort (data, p + 1, right);
}
// 异地合并
void merge (int data1[], size_t size1, int data2[],
	size_t size2, int data3[]) {
	size_t i = 0, j = 0, k = 0;
	for (;;)
		if (i < size1 && j < size2)
			if (data1[i] <= data2[j])
				data3[k++] = data1[i++];
			else
				data3[k++] = data2[j++];
		else if (i < size1)
			data3[k++] = data1[i++];
		else if (j < size2)
			data3[k++] = data2[j++];
		else
			break;
}
// 本地合并
void merge (int data[], size_t l, size_t m,
	size_t r) {
	int* res = new int[r-l+1];
	merge (data+l, m-l+1, data+m+1, r-m, res);
	for (size_t i = 0; i < r-l+1; ++i)
		data[l+i] = res[i];
	delete[] res;
}
// 归并排序
void mergeSort (int data[], size_t left,
	size_t right) {
	if (left < right) {
		int mid = (left + right) / 2;
		mergeSort (data, left, mid);
		mergeSort (data, mid+1, right);
		merge (data, left, mid, right);
	}
}
int main (void) {
	int data[] = {13,23,20,12,15,31,19,26,24,37};
	size_t size = sizeof (data) / sizeof (data[0]);
//	bubbleSort (data, size);
//	insertSort (data, size);
//	selectSort (data, size);
//	quickSort (data, 0, size - 1);
	mergeSort (data, 0, size - 1);
	for (size_t i = 0; i < size; ++i)
		cout << data[i] << ' ';
	cout << endl;
	/*
	int data1[] = {10, 20, 30, 45, 66};
	int data2[] = {15, 18, 27, 33};
	int data3[9];
	merge (data1, 5, data2, 4, data3);
	for (size_t i = 0; i < 9; ++i)
		cout << data3[i] << ' ';
	cout << endl;
	// 10 15 18 20 27 30 33 45 66
	/*
	int data[] = {100,10,20,30,45,66,15,18,27,33,0};
	merge (data, 1, 5, 9);
	for (size_t i = 0; i < 11; ++i)
		cout << data[i] << ' ';
	cout << endl;
	// 100 10 15 18 20 27 30 33 45 66 0
	*/
	return 0;
}
时间: 2024-10-12 09:25:56

常见排序算法(冒泡、选择、插入、快速、归并C++实现)的相关文章

排序算法-冒泡、插入、归并、希尔、快速、选择--代码总结

冒泡排序代码: #include <iostream> #include <string> using namespace std; template<class ItemType> void bubbleSort(ItemType theArray[], int n) { bool sorted = false; // False when swaps occur int pass = 1; while (!sorted && (pass < n

冒泡选择插入快速,四种最基础排序算法实现

<?php /** * Created by PhpStorm. * User: chm * Date: 2016/4/1 * Time: 19:35 */ //插入排序特点是一边是排好顺序的,另一边一个一个和顺序的数据对比,每次对比插入一个 function charu($arr) { $len = count($arr); //先给出一个原数组 echo "原数组为:"; for($y = 0;$y < $len;$y++){ echo $arr[$y]; } echo

java中各种经典排序(冒泡 选择 插入 希尔等)

1 import java.util.Arrays; 2 3 public class ArraySort { 4 public static void main(String[] args) { 5 int[] arr = { 12, 23, 14, 5, 64, 35, 42 }; 6 System.out.println("排序前:"); 7 System.out.println(Arrays.toString(arr)); 8 // bubbleSort(arr); 9 //

常见排序算法之选择排序

1.直接选择排序 直接选择排序和直接插入排序类似,都将数据分为有序区和无序区,所不同的是直接插入排序是将无序区的第一个元素直接插入到有序区以形成一个更大的有序区,而直接选择排序是从无序区选一个最小的元素直接放到有序区的最后. 设数组为a[0-n-1]. 1.      初始时,数组全为无序区为a[0..n-1].令i=0 2.      在无序区a[i-n-1]中选取一个最小的元素,将其与a[i]交换.交换之后a[0-i]就形成了一个有序区. 3.      i++并重复第二步直到i==n-1.

冒泡选择插入希尔归并快速排序等python实现

def bubble_sort(a_list): for pass_num in range(len(a_list) - 1, 0, -1): for i in range(pass_num): if a_list[i] > a_list[i + 1]: a_list[i], a_list[i + 1] = a_list[i + 1], a_list[i] def short_bubble_sort(a_list): exchanges = True pass_num = len(a_list)

几种常见排序算法

几种常见排序算法 几种常见排序算法 写在前面 基础介绍 初级排序算法 selection sort选择排序 insertion sort插入排序 ShellSort希尔排序 shuffing不是排序算法 merge sort归并排序 Abstract in-place merge原地归并的抽象方法 Top-down mergesort自顶向下的归并排序 Bottom-up mergesort自底向上的归并排序 quicksort 三向切分的快速排序 Heapsort堆排序 总结和比较 命题 本文

常见排序算法(JS版)

常见排序算法(JS版)包括: 内置排序,冒泡排序,选择排序,插入排序,希尔排序,快速排序(递归 & 堆栈),归并排序,堆排序,以及分析每种排序算法的执行时间. index.html 1 <!DOCTYPE html> 2 <html> 3 <head> 4 <title>twobin 常见排序算法 (JS版) </title> 5 <meta http-equiv="content-type" content=&

python 数据结构与算法之排序(冒泡,选择,插入)

目录 数据结构与算法之排序(冒泡,选择,插入) 为什么学习数据结构与算法: 数据结构与算法: 算法: 数据结构 冒泡排序法 选择排序法 插入排序法 数据结构与算法之排序(冒泡,选择,插入) 为什么学习数据结构与算法: 计算机重要的几门课: 1.数据结构和算法 2.网络 3.操作系统 4.计算组成原理 数据结构与算法: 算法: 衡量算法的标准: 时间复杂度:就是程序代码执行的大概次数 小结: 时间复杂度是用来估计算法运行时间的一个式子(单位) 一般来说,时间复杂度高的算法比复杂度低的算法慢 常见的

排序算法-冒泡——插入——快排

冒泡排序,往两个方向泡,一个往小泡,一个网大泡 #include<stdio.h> #include<stdlib.h> #include<time.h> void bubble_sort(int *a,int n){ int temp; for(int i=0;i<n;i++) for(int j=0;j<n-i-1;j++){ if(a[j]>a[j+1]){ temp=a[j]; a[j]=a[j+1]; a[j+1]=temp; } } } v