//#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;
}
排序算法笔记
于 2022-09-20 11:25:34 首次发布