数据结构---排序与二分查找

排序与二分查找

一、排序

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

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=basis)
        {
            j--;
        }
        if(i

1.3 插入排序

• 插入排序有直接插入排序和折半插入排序

• 直接插入排序：插入排序通过构建有序序列，对于未排序数据，在已排序序列中从后往前扫描，找到相应位置并插入，反复下去，直到完成序列排序。
• 折半插入排序：是直接插入排序的一个变种，区别是，在有序区中查找新元素插入位置时，为了减少元素比较次数提高效率，采用二分查找算法进行插入位置的确定。

//代码实现

//1.直接插入排序
void insertSort(int a[],int n)
{
   for(int i=1;i=0 && temp=high+1;j--)
        {
            a[j+1]=a[j];
        }
        a[high+1]=temp;
    }
}

1.4 冒泡排序

冒泡排序，先从数组中找到最大值，并放到数组的最左端，让后在剩下的数字中找到次大值，以此类推，直到数组有序。

//冒泡排序
void bubbleSort(int arr[],int length)
{
    for(int i=0;iarr[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

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)

LeetCode 239

class Solution
{
public:
    vector maxSlidingWindow(vector& nums, int k)
    {
        vector f;
        int n = nums.size();
        if(n == 0 || k > n)
            return f;
        deque 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 大元素

LeetCode 215

/*
    用了快排的思想，调用一次快排，返回基准值在数组里面的位置与K-1比较，
    如果正好等于K-1那就可以返回这个数，如果小于说明要找的数还在右边，需要对右边再进行一次快排，大于则是在左边，再对左边进行一次快排。 
*/

class Solution {
public:
    int findKthLargest(vector& 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& 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(keya[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练习题

LeetCode 69

//二分法实现
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;
    }
};