标签：com 左右 次数 区间 pivot 其他 元素 最好 blog
1、折半查找
思想：分治策略。把n个元素分成个数大致相同的两半，取a[n/2]与查找的key相比，一直搜索下去。
比如：总共有n个元素，每次查找的区间大小就是n，n/2，n/4，…，n/2^k（接下来操作元素的剩余个数），其中k就是循环的次数。
由于n/2^k取整后>=1，即令n/2^k=1，
可得k=log2n,（是以2为底，n的对数），所以时间复杂度可以表示O()=O(logn)
/*折半查找，非递归*/ int Binary_Search(int *a, int n, int key) //O(log n) { int low, mid, high; low = 0; high = n-1; while(low <= high) { mid = (low + high) / 2; if(a[mid] == key) return mid; if(a[mid] > key) high = mid - 1; if(a[mid] < key) low = mid + 1; } return 0; } /*折半查找，递归实现*/ int Binary_Search2(int *a, int low, int high, int key) { int mid = (low + high) / 2; if(a[mid] == key) return mid; if(a[mid] > key) return Binary_Search2(a, low, mid-1, key); //有没有return都可以 else return Binary_Search2(a, mid+1, high, key); //有没有return都可以 }
2、冒泡、选择、快速、堆
void bubblesort(int a[], int n) { for(int i=0; i<n-1; i++) for(int j=0; j<n-1-i; j++) if(a[j]>a[j+1]) swap(a[j],a[j+1]); } //或者 void bubblesort(int a[], int n) { for(int i=0; i<n; i++) for(int j=i; j<n; j++) if(a[i]>a[j]) swap(a[i],a[j]); } ————————————
比较次数：1+2+......+N-1
快速排序采用的思想是分治思想。
快速排序是找出一个元素（理论上可以随便找一个）作为基准(pivot),然后对数组进行分区操作,使基准左边元素的值都不大于基准值,基准右边的元素值 都不小于基准值，如此作为基准的元素调整到排序后的正确位置。递归快速排序，将其他n-1个元素也调整到排序后的正确位置。最后每个元素都是在排序后的正 确位置，排序完成。所以快速排序算法的核心算法是分区操作，即如何调整基准的位置以及调整返回基准的最终位置以便分治递归。
举例说明一下吧，这个可能不是太好理解。假设要排序的序列为
2 2 4 9 3 6 7 1 5 首先用2当作基准，使用i j两个指针分别从两边进行扫描，把比2小的元素和比2大的元素分开。首先比较2和5，5比2大，j左移
2 2 4 9 3 6 7 1 5 比较2和1，1小于2，所以把1放在2的位置
2 1 4 9 3 6 7 1 5 比较2和4，4大于2，因此将4移动到后面
2 1 4 9 3 6 7 4 5 比较2和7，2和6，2和3，2和9，全部大于2，满足条件，因此不变
经过第一轮的快速排序，元素变为下面的样子
[1] 2 [4 9 3 6 7 5]
之后，在把2左边的元素进行快排，由于只有一个元素，因此快排结束。右边进行快排，递归进行，最终生成最后的结果。
int quicksort(int a[], int left, int right) { if(left >= right){ return; } int key = a[left]; int low = left; int high = right; while(low < high) { while(low < high && a[high] > key) { high--; } a[low] = a[high]; while(low < high && a[low] < key) { low++; } a[high] = a[low]; } a[low] = key; quicksort(a,left,low-1); quicksort(a,low+1,right); } O(nlog2n)----O(n^2)
基本思想为(大顶堆)：
1)将初始待排序关键字序列(R1,R2....Rn)构建成大顶堆，此堆为初始的无须区；
2)将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,......Rn-1)和新的有序区(Rn),且满足R[1,2...n-1]<=R[n];
3)由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,......Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2....Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。
最好以及最坏都是O(nlog2n)，空间复杂度O(1).
void Create(int a[], int start, int end) { int temp=a[start]; for(int i=2*start+1; i<=end; i*=2) //假设根结点的序号为0（不是1），所以i结点左孩子和右孩子分别为2i+1和2i+2 { if(i<end && a[i]<a[i+1]) //左右孩子的比较 { ++i; //i为较大的记录的下标 } if(temp>a[i]) //左右孩子中获胜者与父亲的比较 break; a[start] = a[i]; //将孩子结点上位，则以孩子结点的位置进行下一轮的筛选 start = i; } a[start]=temp; } void HeapSort(int a[], int n) { for(int i=n/2; i>=0; i--) //先建立大顶堆 { Create(a,i,n); } for(int i=n-1; i>0; i--) //进行排序，最后一个元素和第一个元素进行交换 { swap(a[i], a[0]); Create(a,0,i-1); //将剩下的元素继续进行调整排序 } }
关于堆排序的一篇好文章：https://www.cnblogs.com/lanhaicode/p/10546257.html
========附录============
关于topK问题就不得不说了，类型有，找出前K个大的数、找出第K个大的数、找出重复K次的数
/* topK算法实现 */ #include <stdio.h> /* 调整小顶堆，pos：唯一违反堆性质的点的位置 */ void heapsort(int *a, const int len, int pos) { int min; int child = (pos * 2) + 1;// 左孩子 while (1) { if (child + 1 < len)// 有两个孩子 { min = a[child] < a[child + 1] ? a[child] : a[++child]; } else if (child + 1 == len) // 只有左孩子 { min = a[child]; } else break; // 数组结束，调整完成 if (a[pos] > min) { a[child] = a[pos]; a[pos] = min; pos = child; // 更新父节点索引 child = (pos * 2) + 1; // 下一个调整点 } else break; // 已经是堆，无需调整 } } /* 建立小顶堆 */ void Create(int *b, const int k) { int i; for (i = k / 2 -1; i >= 0; --i) { heapsort(b, k, i); } } /* 选出数组中最大的k个数，存入数组arr_k中 */ void top_k(const int *a,const int len, int *b, int k) { int i; for (i = 0; i < k; ++i) b[i] = a[i]; Create(b, k); // 用a的前k个数建堆 for (; i < len; ++i) { b[0] = a[i]; heapsort(b, k, 0); } } /* 测试代码 */ int main() { int a[] = { 8, 1, 2, 7, 3, 4, 5, 6, 9 }; int K 4; int i; int b[K]; top_k(a, 9, b, K); for (i = 0; i < K; ++i) { printf("%d ", b[i]); } return 0; }
标签：com 左右 次数 区间 pivot 其他 元素 最好 blog
原文地址：https://www.cnblogs.com/fangzheng-nie/p/13235364.html
