数据结构——排序算法

演示数组 arr[]={5,3,1,4}。假设要求都是从小到大排。

1. 插入排序
2. 选择排序
3. 冒泡排序
4. 希尔排序
5. 快速排序
6. 堆排序
7. 归并排序
8. 计数排序

//单独写一个数组输出的函数
void print_array(int a[], int n)
{
	for (int i = 0; i < n; i++)
	{
		cout << a[i];
	}
	cout << endl;
}

//单独写一个交换函数
void swap(int* a, int* b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

**1. 插入排序
算法思想：第一个数字不动，从第二个开始。如果第二个数比第一个小，则交换。以此类推，每轮到一个数都要不停的比较交换，使得他前面没有数比他大，然后开始下一个数。
（或者说从第二个数字开始，让他去往前面的数的合适位置插入）
每一轮下来，这个数为止，前面都是有序的。

插入排序的代码实现

#include<iostream>
using namespace std;

void print_array(int a[], int n)//单独写一个数组输出的函数
{
	for (int i = 0; i < n; i++)
	{
		cout << a[i];
	}
	cout << endl;
}

void insertion_sort(int a[], int n)//插入排序
{
	print_array(a, n);//排序前打印
	for (int i = 1; i < n; i++)
	{
		int key = a[i];
		int j = i - 1;
		while (j >= 0 && a[j] > key)
		{
			a[j + 1] = a[j];
			j--;
		}
		a[j + 1] = key;
		print_array(a, n);//每排一轮打印一次
	}
}

int main()
{
	int a[] = { 5,3,1,4 };
	int len = sizeof(a) / sizeof(a[0]);
	insertion_sort(a,len);
	return 0;
}

输出结果：

5314
3514
1354
1345

2. 选择排序
   算法思想：
   选择一个数认为是最小的用min存放，然后后面的数都与之比较，如果有比他小的则交换。然后开始第二轮，选择第二个数认为是自小的，后面的数与之比较，以此类推。
   
   选择排序代码：

#include<iostream>
using namespace std;

void print_array(int a[], int n)//单独写一个数组输出的函数
{
	for (int i = 0; i < n; i++)
	{
		cout << a[i];
	}
	cout << endl;
}

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

void insertion_sort(int a[], int n)//插入排序
{
	print_array(a, n);//排序前打印
	int i, j, min;
	for (i = 0; i < n; i++)
	{
		min = i;//假定第一个是最小值
		for (j = i + 1; j < n; j++)
		{
			if (a[j] < a[min])
				min = j;
		}
		swap(&a[min], &a[i]);
	}
	print_array(a, n);//排序后打印
}

int main()
{
	int a[] = { 5,3,1,4 };
	int len = sizeof(a) / sizeof(a[0]);
	insertion_sort(a, len);
	system("pause");
	return 0;
}

输出结果：

5314
1345

4. 冒泡排序
   算法思想：
   相邻两数相比较，每次选出一个最大的数放后面去。
   每一轮下来，大的数字都是有序的且确定的。
   （或者说就是让最大的数字冒出来）

冒泡排序的代码

#include<iostream>
using namespace std;

void print_array(int a[], int n)//单独写一个数组输出的函数
{
	for (int i = 0; i < n; i++)
	{
		cout << a[i];
	}
	cout << endl;
}

void sort(int arr[], int n)
{
	print_array(arr, n);//排序前打印
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 3 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
				//print_array(arr, n);
			}
		}
	}
	print_array(arr, n);
}

int main()
{
	int arr[4] = { 5,3,1,4 };
	int len = sizeof(arr) / sizeof(arr[0]);
	sort(arr, len);
}

输出结果
5314
1345

5. 希尔排序
   算法思想：
   使用一个增量序列，实现分组排序。

6. 快速排序
   算法思想：
   一般把第一个数当基准pivot，其余的数用两个下表进行扫描，比基准大的放到后面，比基准小的放到前面。
   

#include<iostream>
using namespace std;

void print_array(int a[], int n)//单独写一个数组输出的函数
{
	for (int i = 0; i < n; i++)
	{
		cout << a[i];
	}
	cout << endl;
}

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

int partition(int arr[], int low, int high)
{
	int pivot = arr[high];
	int i = low;

	for (int j = low; j < high; j++)
	{
		// 比pivot小的，全部换到前面去
		if (arr[j] < pivot)
			swap(&arr[j], &arr[i++]);
	}
	// 此时，i指向的元素一定大于等于pivot
	swap(&arr[high], &arr[i]);
	return i;
}

/**
* @brief 递归划分
*
* @param arr 数字
* @param low 左边界下标
* @param high 右边界下标
*/

void qsort(int arr[], int low, int high)
{
	if (low < high)
	{
		int mid = partition(arr, low, high);
		qsort(arr, low, mid - 1);
		qsort(arr, mid + 1, high);
	}
}
/**
* @brief 快速排序入口
*
* @param arr 数组
* @param len 长度
*/
void quick_sort(int arr[], int len)
{
	qsort(arr, 0, len - 1);
	
}

int main()
{
	int a[] = { 5,3,1,4 };
	int len = sizeof(a) / sizeof(a[0]);
	quick_sort(a,len);
	print_array(a,len);
	system("pause");
	return 0;
}

8. 堆排序
   算法思想：
   先把所有的数都放到二叉树里面，每一次将父节点与子节点相比较交换，重复步骤，最后可得到有序序列。
   
   堆排序代码：

#include <iostream>
using namespace std;

//交换函数
void swap(int* a, int* b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

//使数据堆化
void max_heapify(int arr[], int len, int i) //i表示当前要堆化的节点的下标
{
    int largest = i;//父节点下标
    int lson = i * 2 + 1;//左孩子下标
    int rson = i * 2 + 2;
    if (lson < len && arr[largest] < arr[lson])//左孩子比父亲大
        largest = lson;//下标交换
    if (rson < len && arr[largest] < arr[rson])
        largest = rson;
    if (largest != i)//表示下标成功交换了
    {
        swap(&arr[largest], &arr[i]);//那么对应的数值也要交换
        max_heapify(arr, len, largest);//递归 接着往下堆化
    }
}

//堆排序
void heap_sort(int arr[], int len) 
{
    //初始化，i从最后一个父节点开始调整
    for (int i = len / 2 - 1; i >= 0; i--)
        max_heapify(arr, len, i);
    //先将第一个元素和已经排好的元素前一位做交换，再从新调整(刚调整的元素之前的元素)，直到排序完毕
    for (int i = len - 1; i > 0; i--) 
    {
        swap(&arr[0], &arr[i]);
        max_heapify(arr, i, 0);
    }
}
int main() 
{
    int arr[] = { 5,3,1,4};
    int len = (int)sizeof(arr) / sizeof(arr[0]);
    heap_sort(arr, len);
    for (int i = 0; i < len; i++)
    cout << arr[i] << ' ';
    cout << endl;
    return 0;
}

输出结果：1 3 4 5

8. 归并排序
9. 计数排序**

后续补充