排序算法笔记

//#include <cstdio>
//#include<iostream>
//#include<vector>
#include<bits/stdc++.h>
using namespace std;


const int INF = 1e3;
const int eps = 1e-3;
//从左到右，每两个比较，不断地把最大的放到最右边
void bubble_sort(int arr[],int left, int right) {
	for (int i = left; i < right; i++) {
		for (int j = 0; j < right-i; j++) {
			if (arr[j] > arr[j+1]) {
				swap(arr[j], arr[j+1]);
			}
		}
	}
}

//选择排序 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再
//从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此
//类推，直到所有元素均排序完毕。
void select_sort(int arr[], int left, int right) {
	for (int i = left; i < right; i++) {
		for (int j = i; j <= right ; j++) {
			if (arr[i] > arr[j])
				swap(arr[i],arr[j]);
		}
	}
}

//插入排序（Insertion Sort）的算法描述是一种简单直观的排序算法。它的工作原理
//是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应
//位置并插入。插入排序在实现上，通常采用inplace排序（即只需用到O(1)的额外空
//间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，
//为最新元素提供插入空间。
void insert_sort(int arr[], int left, int right) {
	for (int cur = left + 1; cur <= right; cur++) {
		int tmp = arr[cur];
		int i = cur - 1;
		while (i>=left && tmp <arr[i]) {
			arr[i + 1] = arr[i];
			i--;
		}
		arr[i+1] = tmp;
	}
}
void shell_sort(int arr[], int left, int right,int N) {
	for (int gap = N/2; gap >= 1; gap = gap / 2) {
		for (int cur = left + gap; cur <= right; cur+=gap) {
			int tmp = arr[cur];
			int i = cur - gap;
			while (i >= left && tmp < arr[i]) {
				arr[i+gap] = arr[i];
				i-=gap;
			}
			arr[i+gap] = tmp;
		}
	}
}

//二分（折半）插入（Binary insert sort)排序是一种在直接插入排序算法上进行小改
//动的排序算法。其与直接排序算法最大的区别在于查找插入位置时使用的是二分查
//找的方式，在速度上有一定提升。
int binary_search(int arr[], int left, int right,int value) {
	while (abs(left - right) > 1) {
		int mid = (left + right) >> 1;
		 //cout << left << " " << right << endl;
		 if (value <= arr[mid])
			 right = mid;
		else
			left= mid + 1;
	}
	return left;
}
void binary_sort(int arr[], int left, int right) {
	for (int cur = left + 1; cur <= right; cur++) {
		int tmp = arr[cur];
		int i = cur - 1;
		int idx=binary_search(arr, left, cur-1, tmp);
		for (int j=cur; j > idx; j--) {
			arr[j] = arr[j - 1];
		}
		arr[idx] = tmp;
	}
}

//快速排序是各种笔试面试中常出的一类题型，其基本思想是：从序列中选取一个作
//为关键字，对序列排一次序，使得关键字左侧的数都比关键字小，右侧的都大于等
//于关键字（左右两侧的序列依然是无序的），然后 将左侧的序列按照同样的方法进
//行排序，将右侧序列也按照同样的方法排序，已达到整个序列有序。
void quick_sort(int arr[], int left, int right) {
	int L = left, R = right;
	if (L >= R)return;
	//找空位
	int val = arr[L];
	while (L != R) {
		while (arr[R]>val&&R>L) {
			R--;
		}
		if (R > L)
			arr[L] = arr[R], L++;
		while (arr[L] < val && R>L) {
			L++;
		}
		if (R > L)
			arr[R] = arr[L], R--;
	}
	arr[R] = val;
	quick_sort(arr,left,R-1);
	quick_sort(arr, L+1, right);
}


//堆排序
//堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个
//近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于
//（或者大于）它的父节点。
//
void heapify(int tree[],int n,int i) {
	int parent = i, c1 = 2 * i + 1, c2 = 2 * i + 2;
	if (tree[parent] < tree[c1]&&c1<=n) 
		swap(tree[parent], tree[c1]);
		
	if (tree[parent] < tree[c2]&&c2<=n)
		swap(tree[parent], tree[c2]);
}

void build_heap(int tree[], int n) {
	int node = (n - 1) / 2;
	for (int i = node; i >= 0; i--)
		heapify(tree, n, i);
}

void heap_sort(int tree[],int n) {
	for (int i = n; i >= 0; i--) {
		build_heap(tree, i);
		/*cout << " 堆：";
		for (int j = 0; j <=i; j++) {
			cout << tree[j] << " ";
		}*/
		swap(tree[0], tree[i]);
	}

}

//归并排序是一种稳定的算法，采用分治的思想，有序的子序列合并得到有序序列。
//实现步骤：
//1. 将序列分成长度为 n / 2的两部分
//2. 对于左右两部分采用分治的方法得到有序序列
//3. 将左右两个有序序列合并得到整个有序序列

//合并相邻有序子序列
void merge(int arr[],int left, int right) {
	int arrL[100], arrR[100];
	int i = 0,j = 0;
	int k = left;
	//int mid = M;
	int mid = (right + left) / 2;
	int left_size = mid - left + 1, right_size = right - mid;
	//设置数组
	for (int i =0 ; i < left_size; i++)
		arrL[i] = arr[i+left];
	for (int j = 0; j < right_size; j++)
		arrR[j] = arr[j+mid+1];

	//arrL ，arrR进行比较
	while (i<left_size&&j<right_size) {
		if (arrL[i] < arrR[j]) {
			arr[k++] = arrL[i++];
		}
		if (arrR[j] < arrL[i]) {
			arr[k++] = arrR[j++];
		}
	}
	
	while (i < left_size) {
		arr[k++] = arrL[i++];
	}
	while (j < right_size) {
		arr[k++] = arrR[j++];
	}

}

void merge_sort(int arr[], int L,  int R) {
	int M = (R + L) / 2;
	if (R <= L )return;
	merge_sort(arr, L, M);
	merge_sort(arr, M+1, R);
	merge(arr, L, M, R);
}

void cocktail_sort(int arr[], int left, int right) {
	int i = left, j = right;
	while (i < j) {
		for (int k = i; k < j; k++) {
			if (arr[k] > arr[k + 1])
				swap(arr[k], arr[k + 1]);
		}
		j--;
		for (int k = j; k > i; k--) {
			if (arr[k] < arr[k - 1])
				swap(arr[k], arr[k - 1]);
		}
		i++;
	}
}

void count_sort(int arr[], int left, int right) {
	const int max_ = 1000;
	int count[max_];
	for (int i = left; i <= right; i++) {
		count[arr[i]] = +1;
	}
	int index = 0;
	while (index <= max_) {
		if (count[index]) {
			for (int i = 1; i <= count[index]; i++) {
				arr[left++] = index;
			}
		}
		index++;
	}
}

int cmp1(int a, int b) {
	return a > b;
}

int cmp2(int a, int b) {
	return a < b;
}


struct A{
	int a, b;
}aa[5];

void init() {
	aa[0].a = 3;
	aa[0].b = 2;
	aa[1].a = 2;
	aa[1].b = 4;
	aa[2].a = 2;
	aa[2].b = 5;
	aa[3].a = 2;
	aa[3].b = 3;
	aa[4].a = 1;
	aa[4].b = 9;
}

int cmp11(A aa, A bb) {
	if (aa.a == bb.a)
		return aa.b > bb.b;
	return aa.a > bb.a;
}

int cmp22(A a, A b) {
	if (a.a == b.a)
		return a.b > b.b;
	return a.a < b.a;
}

void _print() {
	for (int i = 0; i < 5; i++)
		printf("%d %d\n", aa[i].a, aa[i].b);
}


int main() {
	int arr[1000];
	for (int i = 100; i >= 0; i--) {
		arr[100-i] = i;
	}
	for (int i = 0; i <= 100;i++) {
		cout  << arr[i] << " ";
	}
	//for (int i = 100; i >= 0; i--) {
	//	arr[i] = i;
	//}
	cout << endl;
	//bubble_sort(arr, 0, 100);
	//select_sort(arr, 0, 100);
	//insert_sort(arr, 0, 100);
	//quick_sort(arr, 0, 100);
	//heap_sort(arr, 100);
	//merge_sort(arr, 0, 100);
	//int a = binary_search(arr, 0, 100, 67);
	//cout << "Here " << a << endl;
	//binary_sort(arr, 0, 100);
	//shell_sort(arr, 0, 100, 101);
	//cocktail_sort(arr, 0, 100);
	//count_sort(arr, 0, 100);
	//sort(arr, arr+100, cmp1);
	//sort(arr+0, arr + 101, cmp2);
	init();
	sort(aa, aa + 5, cmp22);
	_print();
	//for (int i = 0; i <= 100; i++) {
	//	cout << arr[i] << " ";
	//}
	return 0;
}