本文详细介绍了排序算法，包括归并排序、快速排序、插入排序、冒泡排序、选择排序和堆排序，并讨论了如何在LeetCode上解决相关问题。此外，还探讨了二分查找，包括有序数组的二分查找和模糊二分查找的应用。
排序与二分查找
文章目录
一、排序
1.1 归并排序
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。归并排序是一种稳定的排序。
//归并排序
void mergesort(int a[],int start,int end)
{
if(a==NULL || start>=end)
return ;
int mid=(end+start)/2;
mergesort(a,start,mid);
mergesort(a,mid+1,end);
merge(a,start,mid,end); //合并
}
//合并算法：将一个数组中的两个相邻有序区间合并成一个
void merge(int a[],int start,int mid,int end)
{
int *tmp=(int *)malloc((end-start+1)*sizeof(int));
int i=start;
int j=mid+1;
int k=0;
while(i<=mid && j<=end)
{
if(a[i]<=a[j])
tmp[k++]=a[i++];
else
tmp[k++]=a[j++];
}
while(i<=mid)
tmp[k++]=a[i++];
while(j<=end)
tmp[k++]=a[j++];
//将排序后的元素全部整合到数组a中
for(i=0;i<k;i++)
a[start+i]=tmp[i];
free(tmp);
}
1.2 快速排序
快速排序是通过一趟排序将待排序记录分为独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录进行排序，最后达到整个序列有序。
//快速排序
void quickSort(int arr[],int start,int end)
{
if(start>end)
return ;
int i=start;
int j=end;
//基准
int basis=arr[start];
while(i<j)
{
//从右往左找比基准小的数
while(i<j && arr[j]>=basis)
{
j--;
}
if(i<j)
{
arr[i]=arr[j];
i++;
}
//从左往右找比基准大的数
while(i<j && arr[i]<basis)
{
i++;
}
if(i<j)
{
arr[j]=arr[i];
j--;
}
}
//将基准放到i位置
arr[i]=basis;
//递归
quickSort(arr,start,i-1);
quickSort(arr,i+1,end);
}
1.3 插入排序
- 插入排序有直接插入排序和折半插入排序
- 直接插入排序：插入排序通过构建有序序列，对于未排序数据，在已排序序列中从后往前扫描，找到相应位置并插入，反复下去，直到完成序列排序。
- 折半插入排序：是直接插入排序的一个变种，区别是，在有序区中查找新元素插入位置时，为了减少元素比较次数提高效率，采用二分查找算法进行插入位置的确定。
//代码实现
//1.直接插入排序
void insertSort(int a[],int n)
{
for(int i=1;i<n;i++)
{
if(a[i]<a[i-1])
{
int temp=a[i];
int j=0;
for(j=i-1;j>=0 && temp<a[j];j--)
a[j+1]=a[j]; // 大的元素后移
a[j+1]=temp; //temp插入正确位置
}
}
}
//折半插入排序
void BInsertSort(int a[],int n)
{
for(int i=1;i<n;i++)
{
int temp=a[i];
//有序数据分区的第一个元素位置为low，最后一个元素的位置为high。
int low=0;
int high=i-1;
while(low<=high)
{
int m=(low+high)/2;
if(a[m]<=temp)
low=m+1; //若待排序数据较大，则low~m-1分区的数据都比待排序数据小
else
high=m-1; //若待排序数据较小，则m+1~high分区的数据都比 待排序数据大
}
/*确定好位置后，将位置之后的数据后移，插入待排序数据*/
for(int j=i-1;j>=high+1;j--)
{
a[j+1]=a[j];
}
a[high+1]=temp;
}
}
1.4 冒泡排序
冒泡排序，先从数组中找到最大值，并放到数组的最左端，让后在剩下的数字中找到次大值，以此类推，直到数组有序。
//冒泡排序
void bubbleSort(int arr[],int length)
{
for(int i=0;i<length;i++)
{
for(int j=0;j<length-i-1;j++) //
{
if(arr[j]>arr[j+1])
{
int temp;
temp=arr[j+1];
arr[j+1]=arr[j];
arr[j]=temp;
}
}
}
}
1.5 选择排序
选择排序，在长度为n的数组arr中，先从n个数字中找到最小值min1，如果最小值min1的位置不在arr[0],则将arr[0]与min1交换，接着在剩下的n-1个数字中找到最小值min2，如果min2不等于arr[1]，则交换，以此类推，直到数组有序。
//选择排序
void selectSort(int arr[],int length)
{
for(int i=0;i<length;i++)
{
int index=i;
for(int j=i+1;j<length;j++)
{
if(arr[j]<arr[index])
{
index=j;
}
}
if(index==i)
continue;
else
{
int temp;
temp=arr[index];
arr[index]=arr[i];
arr[i]=temp;
}
}
}
1.6 堆排序
堆排序是利用堆进行的排序，将待排序列构成一个大顶堆(小顶堆)，整个序列的最大值(最小值)就是堆顶的根节点，将根节点的值和堆数组的末尾元素交换，此时末尾元素就是最值，然后将剩下的n-1个序列重新构成堆，就得到n个元素中的次大值(次小值)，反复进行，最终得到有序序列。
// arr 待调整的数组
//i待调整的结点的下标
//length 数组的长度
//调整
void HeapAdjust(int arr[], int i, int length)
{
// 调整i位置的结点
// 先保存当前结点的下标
int max = i;
// 当前结点左右孩子结点的下标
int lchild = i * 2 + 1;
int rchild = i * 2 + 2;
if (lchild < length && arr[lchild] > arr[max])
{
max = lchild;
}
if (rchild < length && arr[rchild] > arr[max])
{
max = rchild;
}
// 若i处的值比其左右孩子结点的值小，就将其和最大值进行交换
if (max != i)
{
int temp;
temp = arr[i];
arr[i] = arr[max];
arr[max] = temp;
// 递归
HeapAdjust(arr, max, length);
}
}
// 堆排序
void HeapSort(int arr[], int length)
{
// 初始化堆
// length / 2 - 1是二叉树中最后一个非叶子结点的序号
for (int i = length / 2 - 1; i >= 0; i--)
{
HeapAdjust(arr, i, length);
}
// 交换堆顶元素和最后一个元素
for (int i = length - 1; i >= 0; i--)
{
int temp;
temp = arr[i];
arr[i] = arr[0];
arr[0] = temp;
HeapAdjust(arr, 0, i);
}
}
1.7leetcode上的返回滑动窗口中的最大值(239)
class Solution
{
public:
vector<int> maxSlidingWindow(vector<int>& nums, int k)
{
vector<int> f;
int n = nums.size();
if(n == 0 || k > n)
return f;
deque<int> que; //双端队列
for(int i = 0; i < n; i++)
{
if(!que.empty())
{
if(i >= que.front()+k)
que.pop_front();
while(!que.empty() && nums[i] >= nums[que.back()])
que.pop_back();
}
que.push_back(i);
if(i+1 >= k)
f.push_back(nums[que.front()]);
}
return f;
}
};
1.8 编程实现 O(n) 时间复杂度内找到一组数据的第 K 大元素
/*
用了快排的思想，调用一次快排，返回基准值在数组里面的位置与K-1比较，
如果正好等于K-1那就可以返回这个数，如果小于说明要找的数还在右边，需要对右边再进行一次快排，大于则是在左边，再对左边进行一次快排。
*/
class Solution {
public:
int findKthLargest(vector<int>& nums, int k) {
int left = 0, right = nums.size() - 1;
while(true) {
int res = quick_sort(nums, left, right);
if(res == k - 1) return nums[res];
if(res < k - 1) left = res + 1;
if(res > k - 1) right = res - 1;
}
}
int quick_sort(vector<int>& nums, int left, int right) {
if(left <= right) {
int i = left, j = right, x = nums[left];
while(i < j) {
while(i < j && nums[j] < x) j--;
if(i < j) nums[i++] = nums[j];
while(i < j && nums[i] > x) i++;
if(i < j) nums[j--] = nums[i];
}
nums[i] = x;
return i;
}
else return -1;
}
};
二、二分查找
2.1 有序数组的二分查找
二分查找，将被查找的键和子数组的中间键进行比较，如果被查找的键小于中间键，就在左子数组中继续查找，如果大于中间键，就在右子数组中进行查找，否则中间键就是要找的值。
//二分查找递归实现
int bSearch(int a[],int start,int end,int key)
{
int mid=start+(end-start)/2;
if(a[mid]==key)
{
return mid;
}
if(start>=end)
return -1;
else if(key>a[mid])
{
return bSearch(a,mid+1,end,key);
}
else if(key<a[mid])
{
return bSearch(a,start,mid-1,key);
}
return -1;
}
//循环普通实现
int bSearch2(int a[],int key,int length)
{
int mid=length/2;
if(key==a[mid])
return mid;
int start=0;
int end=length-1;
while(start<=end)
{
mid=start+(end-start)/2;
if(key==a[mid])
return mid;
else if(key>a[mid])
start=mid+1;
else
end=mid-1;
}
return -1;
}
2.2 模糊二分查找（比如大于等于给定值的第一个元素）
int findFirst(int *array, int n, int target) //target 给定值 ；n 数组长度
{
int start = 0, end = n - 1;
while (start <= end) {
int mid = (start + end) / 2;
if (array[mid] < target)
start = mid + 1;
else if (array[mid] >= target)
end = mid - 1;
}
if (end == n - 1)
return -1;
return end + 1;
}
2.3 LeetCode练习题
//二分法实现
class Solution {
public:
int mySqrt(int x) {
int low = 0;
int up = x;
//注意mid和s的类型不能用int，用int的话可能会越界，会提示超出时间限制的错误。
//两个int相乘或者相加的结果不要再用int表示，可以考虑用long或long long。
while(low <= up){
long mid = (low + up) / 2;
long s = mid * mid;
if(x == s) return mid;
else if(x > s) low = mid + 1;
else up = mid -1;
}
return up;
}
};
扫一扫
1143
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
