二分查找算法

要点：数组迅速排列

只要看到面试题里给出的数组是有序数组，都可以想一想是否可以使用二分法。

二分查找涉及的很多的边界条件，逻辑比较简单，就是写不好。

注意点：数组区间的差异（左闭右闭，左闭右开的区别）

int search(int* nums,int size,int target)
{
    int start=0;
    int end=size;
    int mid;
    while(start<end)
    {
        mid=(start+end)/2;
        if(nums[mid]==target)
        {
            return mid;
        }
        else if(nums[mid]<target)
        {
            start=mid+1;
        }
        else if(nums[mid]>target)
        {
            end=mid-1;
        }
    }
    return -1;

}

练习：(力扣)35 34

排序算法（冒泡，快速，选择，插入，归并）

java

import java.util.Scanner;

public class wang {
    //冒泡排序
    public static int[] BubbleSort(int[] num){
        int temp;
        for(int i=0;i<num.length-1;i++)
        {
            for (int j=i+1;j<num.length;j++)
            {
                if(num[i]>num[j]) {
                    temp = num[i];
                    num[i] = num[j];
                    num[j] = temp;
                }
            }
        }
        return num;
    }
    //选择排序：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
    //再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
    public static int[] SelectSort(int[] num){
        int temp;
        for(int i=0;i<num.length-1;i++)
        {
            int k=i;
            for (int j=i+1;j<num.length;j++)
            {
                if(num[k]>num[j]) {
                    k=j;
                }
            }
            if(k!=i)
            {
                temp = num[k];
                num[k] = num[i];
                num[i] = temp;
            }
        }
        return num;
    }
    //将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
    //从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）
    public static int[] InsertSort(int[] num){
        //第一个默认有序
        for(int i=1;i<num.length;i++)
        {
            int temp=num[i];//有序序列右边的元素
            int j=i;
            while (j>0&&temp<num[j-1])//与有序序列比较 从后开始比较
            {
                num[j]=num[j-1];
                j--;
            }
            if(j!=i)
            {
                num[j]=temp;
            }
        }
        return num;
    }
    //快排关键  划分
    public static void QuickSort(int[] num,int left,int right)
    {
        if(left<right)
        {
            int index=partition(num,left,right);
            QuickSort(num,left,index-1);
            QuickSort(num,index+1,right);
        }
    }
    public static int partition(int[] num,int left,int right)
    {
        int key=num[left];
        while(left<right)
        {
            while(left<right&&num[right]>=key)
            {
                right--;
            }
            num[left]=num[right];
            while (left<right&&num[left]<=key)
            {
                left++;
            }
            num[right]=num[left];
        }
        num[left]=key;
        return left;
    }
    /**
     * 合并两个有序数列
     * array[first]~array[mid]为第一组
     * array[mid+1]~array[last]为第二组
     * temp[]为存放两组比较结果的临时数组
     */
    public static void MergeArrays(int[] num,int[] temp,int start,int mid,int end)
    {
        int i=start,j=mid+1;
        int k=0;
        while (i<=mid&&j<=end)
        {
            if(num[i]<=num[j])
            {
                temp[k++]=num[i++];
            }else{
                temp[k++]=num[j++];
            }
        }
        while(i<=mid)
        {
            temp[k++]=num[i++];
        }
        while (j<=end)
        {
            temp[k++]=num[j++];
        }
        for (int m=0;m<k;m++)
        {// 将排好序的数填回到array数组的对应位置
            num[start+m]=temp[m];
        }
    }
    public static void MergeSort(int[] num,int[] temp,int start,int end)
    {
        if(start<end)
        {
            int mid=(start+end)/2;
            MergeSort(num,temp,start,mid);// 递归归并左边元素
            MergeSort(num,temp,mid+1,end);// 递归归并右边元素
            MergeArrays(num,temp,start,mid,end);
        }
    }
    public static void output(int[] num)
    {
        for(int i=0;i<num.length;i++)
        {
            System.out.println(num[i]);
        }
    }
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        int[] num={82,65,84,4,5,78,89,100,25,106};
        int[] temp=new int[num.length];
        //int[] bubbleSort=BubbleSort(num);
        //int[] selectSort=SelectSort(num);
        //int[] insertSort=InsertSort(num);
        MergeSort(num,temp,0,num.length-1);
        //QuickSort(num,0,num.length-1);
        //output(bubbleSort);
        //output(selectSort);
        output(num);
    }
}

c语言

#include<stdio.h>
#include<stdlib.h>
void BubleSort(int num[],int size);
void SelectSort(int num[],int size);
void InsertSort(int num[],int size);
int parition(int num[],int left,int right);
void QuickSort(int num[],int left,int right);
void MergeSort(int num[],int temp[],int start,int end);
void MergerArrays(int num[],int temp[],int start,int mid,int end);
int main()
{
    int num[10]= {82,65,84,4,5,78,89,100,25,106};
    int temp[10];
    int i;
    //BubleSort(num,10);
    //SelectSort(num,10);
    //InsertSort(num,10);
    //QuickSort(num,0,9);
    MergeSort(num,temp,0,9);
    for(i=0; i<10; i++)
    {
        printf("%d\n",num[i]);
    }
}
//冒泡排序：比较相邻的元素。如果第一个比第二个大，就交换他们两个。
void BubleSort(int num[],int size)
{
    int i,j,temp;
    for(i=0; i<size-1; i++)
    {
        for(j=i+1; j<size; j++)
        {
            if(num[i]>num[j])
            {
                temp=num[i];
                num[i]=num[j];
                num[j]=temp;
            }
        }
    }
    for(i=0; i<size; i++)
    {
        printf("%d\n",num[i]);
    }
}
//选择排序：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。

//再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
void SelectSort(int num[],int size)
{

    int i,j,temp,k;
    for(i=0; i<size-1; i++)
    {
        k=i;
        for(j=i+1; j<size; j++)
        {
            if(num[k]>num[j])
            {
                k=j;
            }
        }
        if(k!=i)
        {

            temp=num[k];
            num[k]=num[i];
            num[i]=temp;
        }
    }
    for(i=0; i<size; i++)
    {
        printf("%d\n",num[i]);
    }
}
//将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。

//从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）
void InsertSort(int num[],int size)
{
    int i;
    for(i=1; i<size; i++)
    {
        int key=num[i];
        int j=i;
        while(j>0&&key<num[j-1])
        {
            num[j]=num[j-1];
            j--;
        }
        if(j!=i)
        {
            num[j]=key;
        }
    }
    for(i=0; i<size; i++)
    {
        printf("%d\n",num[i]);
    }
}
int parition(int num[],int left,int right)
{
    int key=num[left];
    while(left<right)
    {
        while(left<right&&num[right]>=key)
        {
            right--;
        }
        num[left]=num[right];
        while(left<right&&num[left]<=key)
        {
            left++;
        }
        num[right]=num[left];

    }
    num[left]=key;
    return left;
}
void QuickSort(int num[],int left,int right)
{
    if(left<right)
    {
        int index=parition(num,left,right);
        QuickSort(num,left,index-1);
        QuickSort(num,index+1,right);
    }
}

void MergerArrays(int num[],int temp[],int start,int mid,int end)
{
    int i=start,j=mid+1;
    int k=0,m;
    while(i<=mid&&j<=end)
    {
        if(num[i]<=num[j])
        {
            temp[k++]=num[i++];
        }
        else
        {
            temp[k++]=num[j++];
        }
    }
    while(i<=mid)
    {
        temp[k++]=num[i++];
    }
    while(j<=end)
    {
        temp[k++]=num[j++];
    }
    for(m=0; m<k; m++)
    {
        num[start+m]=temp[m];
    }

}
void MergeSort(int num[],int temp[],int start,int end)
{
    if(start<end)
    {
        int mid=(start+end)/2;
        MergeSort(num,temp,start,mid);
        MergeSort(num,temp,mid+1,end);
        MergerArrays(num,temp,start,mid,end);
    }
}