排序和查找的方法

排序

排序分为：冒泡排序、选择排序、直接插入排序、希尔排序、快速排序

冒泡排序

排序思想

相邻的两个元素进行比较，如果满足大小关系，就交换两个元素的位置，一趟排序后会让一个元素放在他的最终位置上。就像冒泡一样

排序方法

void bubblesort(int arr[],int len){

    int i,j,temp;       //定义外层循环变量i  内层循环变量j  临时变量temp
    for(i=0;i<len-1;i++){       //外层控制元素比较多少趟
        for(j=0;j<len-i-1;j++){    //内层控制元素一趟比较的次数
            if(arr[j]>arr[j+1]){    //从大到小进行排序
                temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
    }

}

冒泡排序 是稳定的，最多执行n(n-1)/次

选择排序

排序思想

首先，找到数组中最大或者最小的元素，其次，将它和数组的第一个元素交换位置，把他当成已排序序列，然后在从待排序的序列中选出最大或最小的元素，顺序放在已排好序的序列最后，直到全部记录排序完毕。

排序方法

void selectSort(int arr[],int len){
    int i,j,temp,min;
    for(i=0;i<len;i++){
        min=i;        //min标记未排序第一个元素的位置
        for(j=i+1;j<len;j++){    //找到比min还小的元素
            if(arr[min]>arr[j]){
                min=j;
            }
        }
        
        if(min!=i){    //如果最小值所在位置不为i，交换最小值和第i个元素的位置
            temp=arr[min];
            arr[min]=arr[i];
            arr[i]=temp;
        }
    }
}

选择排序是不稳定的，平均比较次数n(n-1)/2

直接插入排序

排序思想

首先，把第一个元素当成有序序列，把未排序的第一个元素与有序序列比较插入已排序序列中合适的位置，插入后，把这两个元素当成有序序列，再从未排序的的一个元素与有序序列比较直到序列有序为止。

排序算法

void insertSort(int arr[],int len){
    
    int i, j, temp;
    
    for( i=1 ; i < len ; i++ ) {            //从1开始,0位置当成有序
        
        temp = arr[i];            //temp记录未排序第一个
        
        for( j = i-1 ; j >= 0 && arr[j] > temp ; j-- ) {
            
            arr[j+1] = arr[j];    //元素后移,腾位置给插入元素
            
        }
        
        arr[j+1] = temp;            //插入比较的后一位
        
    }

}

直接插入排序，是在有序基础上，速度最快且稳定的排序方法

希尔排序

排序思想

希尔排序：按照步长进行分组，然后每一组的第几个元素进行比较，再用直接插入的排序算法进行排序

排序算法

//dk是增量 步长
void shellInsert(int arr[],int len,int dk){
    int i,j,temp;            //i 循环变量，j记录前边组的位置，temp 临时变量
    for(i=dk;i<len;i++){
        //判断 每组 的第几个元素大小
        if(arr[i]<arr[i-dk]){            //后边组小于前边组
            temp=arr[i];
            j=i-dk;
            for( ;j>=0&&arr[j]>temp;j=j-dk){
                //前边的值给到后边
                arr[j+dk]=arr[j];
            }
            arr[j+dk]=temp;                
            
        }
    }
}

希尔排序是不稳定的

快速排序

排序思想

首先选出一个基准值，一般是左边或者右边，在定义i，j。i从前往后找比基准值大的元素，找到后将元素给到j的位置。j从后往前找，找比基准值小的元素，找到后将元素给到i的位置。最后结束的条件是i=j,此时将基准值放到这个位置。

排序算法

int getPivot(int a[],int low,int high){
    int pivot=a[low];
    while(low<high){                //i<j的时候
        //j从后向前找，比基准值小的元素
        while(low<high && a[high]>pivot){
            high--;
        }
        //找到了比基准值小的元素，将元素给到i位置
        a[low]=a[high];
        //i从前向后找，比基准值大的元素
        while(low<high && a[low]<=pivot){
            low++
        }
        //找到了比基准值大的元素，将元素给到j位置
        a[high]=a[low];
        
    }
    //结束条件 i=j找到了基准值的位置
    a[low]=pivot;
    //返回基准值位置
    return low;
    
}
void quickSort(int a[],int low,int high){
    if(low<high){
        //基准值位置变量
        int pivot=getPivot(arr,low,high);
        //递归对基准值位置左边进行快速排序
        quickSort(a,low,pivot-1);
        //递归对基准值有边进行快速排序
        quickSort(a,pivot+1,high)
        
    }
}

查找

查找分为：顺序查找和二分查找

顺序查找

查找思想

遍历数组，拿元素依次比较，相同返回下标，找不到 返回-1

顺序查找代码

//arr数组  len数组长度 value 要查找的值
int linearSearch(int arr[],int len,int value){
    int i;
    for(i=0;i<len;i++){
        if(value==arr[i]){
            return i;
        }
    }
    return -1;            //找不到
}

二分查找

二分查找（非递归）

//arr 数组，low 左边值 high 右边值 key 要查找的关键字
int binary(int arr[],int low,int high,int key){
    int mid;        //中间值
    while(low<=high){
        mid=(low+high)/2;        //找中间位置
        if(key==arr[mid]){
            return mid;                //返回下标
        }else if(key>arr[mid]){
            low=mid+1;
        }else{
            high=mid-1;
        }
    }
    //没有找到关键字
    return -1;
}

二分查找（递归）

int binary(int arr[],int low,int high,int key){
    int mid;                    //中间下标
    if(low<=high){
        mid=(low+high)/2;
        if(key==arr[mid]){
            return mid;            //递归出口
        }else if(key>arr[mid]){
            return binary(arr,mid+1,high,key);
        }else{
            return binary(arr,low,mid-1,key)
        }
    //没有找到关键字
    return -1；
}