算法复习

二分查找

重要条件:该数组是有序的,
默认数组是升序排列。查找的值val;定义low=0,mid=(low+high)/2和high=数组的长度-1;当数组中的mid>val;high=mid-;mid<vall时,low=mid+1;

注意; 数组一定是有序的,要看清是升序还是降序

例题:
对于一个有序数组,我们通常采用二分查找的方式来定位某一元素,请编写二分查找的算法,在数组中查找指定元素。
给定一个整数数组A及它的大小n,同时给定要查找的元素val,请返回它在数组中的位置(从0开始),若不存在该元素,返回-1。**若该元素出现多次,请返回第一次出现的位置**。假定数组为升序

    public int BinarySearch(int[] A, int n, int val) {
  
        int low=0,high=n-1;
        
        while(low<=high){
            int mid=low+(high-low)/2;
            if(A[mid]==val){
                while(mid-1>-1&&A[mid-1]==val) //往前遍历
                    mid=mid-1;
                return mid;
            }
            
            if(A[mid]>val){
                high=mid-1;
            }else
                low=mid+1;
        }
        return -1;
    }


冒泡排序

  1. 比较前后相邻的两个数据,若前者大于后者,则交换两者位置;
  2. 当从数组的0个数据到第n-1个数据进行一次遍历以后,第n-1个数据此时是数组中最大的数据;
  3. n=n-2;若n不为0则重复前两步。直到排序完成。
public static void bubbleSort1(int [] a, int n){
     int i, j;
      for(i=0; i<n; i++){//表示 n 次排序过程。
         for(j=1; j<n-i; j++){
             if(a[j-1] > a[j]){//前面的数字大于后面的数字就交换
               //交换 a[j-1]和 a[j]
               int temp;
               temp = a[j-1];
                a[j-1] = a[j];
                a[j]=temp;
              }
            }
         }
}

插入排序

整个数组分为无序序列和有序序列,第一次排序时,将第一个数据当作有序序列,然后逐渐从无序序列中取一个数据,把这个数据当作插入值insertVal,在有序序列中从右往左扫描,直到遇到第一个小于等于插入值的数据val时,将插入值放在有序区中val值的后面。

 public void sort(int arr[])
 {
     for(int i =1; i<arr.length;i++)
     {
         //插入的数
         int insertVal = arr[i];
         //被插入的位置(准备和前一个数比较)
         int index = i-1;
         //如果插入的数比被插入的数小
         while(index>=0&&insertVal<arr[index])
         {
         //将把 arr[index] 向后移动
         arr[index+1]=arr[index];
         //让 index 向前移动
          index--;
     }
         //把插入的数放入合适位置
         arr[index+1]=insertVal;
         }
 }

快速排序

快速排序的原理:选择一个关键值作为基准值。比基准值小的都在左边序列(一般是无序的),比基准值大的都在右边(一般是无序的)。一般选择序列的第一个元素。
一次循环:从后往前比较,用基准值和最后一个值比较,如果比基准值小的交换位置,如果没有继续比较下一个,直到找到第一个比基准值小的值才交换。找到这个值之后,又从前往后开始比较,如果有比基准值大的,交换位置,如果没有继续比较下一个,直到找到第一个比基准值大的值才交换。直到从前往后的比较索引>从后往前比较的索引,结束第一次循环,此时,对于基准值来说,左右两边就是有序的了。


    public void sort(int[] a,int low,int high){
     int start = low;
     int end = high;
     int key = a[low];
     while(end>start){
     //从后往前比较
     while(end>start&&a[end]>=key)
    //如果没有比关键值小的,比较下一个,直到有比关键值小的交换位置,然后又从前往后比较
         end--;
         if(a[end]<=key){
         int temp = a[end];
         a[end] = a[start];
         a[start] = temp;
 }
         //从前往后比较
         while(end>start&&a[start]<=key)
        //如果没有比关键值大的,比较下一个,直到有比关键值大的交换位置
         start++;
         if(a[start]>=key){
             int temp = a[start];
             a[start] = a[end];
             a[end] = temp;
         }
 //此时第一次循环比较结束,关键值的位置已经确定了。左边的值都比关键值小,右边的
值都比关键值大,但是两边的顺序还有可能是不一样的,进行下面的递归调用
 }
 //递归
         if(start>low) 
             sort(a,low,start-1);//左边序列。第一个索引位置到关键值索引-1
         if(end<high)
             sort(a,end+1,high);//右边序列。从关键值索引+1 到最后一个
     }
 }

猜你喜欢

转载自blog.csdn.net/qq_35383654/article/details/88239979