C++ 常用算法 实现 记录

C++ 实现 常用算法记录

排序算法

冒泡排序

// 冒泡排序 ，就是把大的压到后面
/***********************************************************************/
/ 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 /
/***********************************************************************/

#include <iostream>
using namespace std;

template<typename T>
void bubble_sort(T arr[], int len)
{
	int i, j;
	for (i = 0; i < len - 1; i++)
	{
		for (j = 0; j < len - 1-i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				swap(arr[j], arr[j + 1]);
			}
		}
	}
}

void testbubblesort()
{
	int arr[] = { 61, 17, 29, 22, 34, 60, 72, 21, 50, 1, 62 };
	int len = (int)sizeof(arr) / sizeof(*arr);
	bubble_sort(arr, len);

	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << "	";
	}
	cout << endl;


	float arrf[] = { 17.5, 19.1, 0.6, 1.9, 10.5, 12.4, 3.8, 19.7, 1.5, 25.4, 28.6, 4.4, 23.8, 5.4 };
	len = (float) sizeof(arrf) / sizeof(*arrf);
	bubble_sort(arrf, len);
	for (int i = 0; i < len; i++)
		cout << arrf[i] << ' ' << endl;


}

快速排序

快速排序
/************************************************************************/
1.选择基准值pivot
2. 重排， 大于pivot 放右边，小于pivot放左边,
3. 小组， 大组重排 /
/***********************************************************************/

#include <iostream>
using namespace std;
int partition1(int A[],int low,int high)
{
	int pivot = A[low];
	while (low < high)
	{
		while (low < high && A[high] >= pivot)
			--high;
		A[low] = A[high];
		while (low < high && A[low] <= pivot)
			++low;
		A[high] = A[low];
	}

	A[low] = A[high];
	return low;
}

void quicksort(int A[], int low, int high)  
{
	if (low < high) {
		int pivot_id = partition1(A, low, high);
		quicksort(A, low, pivot_id - 1);
		quicksort(A, pivot_id+1, high);
	}

}

void testfastquick()
{
	int a[20] = { -1,2,3,0,323,23,02,239,4 };
	quicksort(a, 0, 19);

	for (auto iter : a)
	{
		cout << iter << "	" << endl;
	}
	cout << endl;
}

插入排序

// 插入排序
/*
将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。

从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

*/

#include <iostream>
using namespace std;
void insertion_sort(int arr[], int len)
{
	for (int i = 1; i < len; i++)
	{
		int key = arr[i];
		int j = i - 1;
		while (j >= 0 && key < arr[j])
		{
			arr[j + 1] = arr[j];
			--j;
		}
		arr[j + 1] = key;
	}
}

void testinsertsort()
{
	int arr[] = { 61, 17, 29, 22, 34, 60, 72, 21, 50, 1, 62 };
	int len = (int)sizeof(arr) / sizeof(*arr);
	insertion_sort(arr, len);

	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << "	";
	}
	cout << endl;
}   

选择排序

---

• 1. 找到全组 极值， 放到该放的位置，
• 2. 在剩下组 找极值， 放该放的位置。

template<typename T>
void selection_sort(T arr[],int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		int min_index = i;
		for (int j = i + 1; j < len; j++)
		{
			if (arr[j] < arr[min_index])
				min_index = j;
		}
		swap(arr[i], arr[min_index]);
	}
}

希尔排序

template<typename T>
void shell_sort(T arr[], int len)
{
	int h = 1;
	while (h < len / 3)
	{
		h = h * 3 + 1;
	}

	while (h >= 1)
	{
		for (int i = h; i < len; i++)
		{

			for (int j = i;j>=h&&arr[j]<arr[j-h];  j-=h)
			{
				std::swap(arr[j],arr[j-h]);
			}
		}
		h = h / 3;
	}

}  

归并排序

// 分治法
// 自上而下 (所有的递归的方法都可以迭代重写， )
// 自下而上的迭代

/*

1. 申请空间， 使其大小为两个已经排序序列之和，
2. 设定两个指针， 最初位置分别为两个已经排序序列的起始位置
3. 比较两个指针所指向的元素，选择相对小的元素放到合并空间，并移动指针到下一位置
4. 重复步骤3 知道某一指针达到序列尾部
5. 将另一个序列剩下的所有元素直接复制到合并序列尾
   */

template<typename T>
void merge_sort(T arr[], int len)
{
	T* a = arr;
	T* b = new T[len];

	for (int seg = 1; seg < len; seg += seg)
	{
		for (int start = 0; start < len; start += seg + seg)
		{
			int low = start, mid = min(start + seg, len);
			int high = min(start + seg + seg, len);

			int k = low;

			int start1 = low, end1 = mid;
			int start2 = mid, end2 = high;

			while (start1 < end1 && start2 < end2)
			{
				b[k++] = a[start1] < a[start2] ? a[start1++] : a[start2++];
			}
			while (start1 < end1)
				b[k++] = a[start1++];
			while (start2 < end2)
				b[k++] = a[start2++];


		}
		T *temp = a;
		a = b;
		b = temp;
		
	}

	if (a != arr)
	{
		for (int i = 0; i < len; i++)
		{
			b[i] = a[i];
		}
		b = a;
	}
	delete[] b;
}  

后面想明白再记