0
点赞
收藏
分享

微信扫一扫

Java基础篇1-二分查找与排序算法学习笔记

b91bff6ffdb5 2022-04-05 阅读 75
java

Java基础篇1-二分查找算法与排序算法

1.二分查找

1.1什么是二分查找?

二分查找(Binary Search)也叫作折半查找。二分查找有两个要求,一个是数列有序,另一个是数列使用顺序存储结构(比如数组)。

JQ:先进行排序,然后找中间值,然后比较查询的值与中间值得大小,确定搜索范围,然后进行一次折半查找
在这里插入图片描述在这里插入图片描述在这里插入图片描述

1.2 二分查找代码编写

代码编写步骤:

  1. 前提:有已排序数组 A(假设已经做好)

  2. 定义左边界 L、右边界 R,确定搜索范围,循环执行二分查找(3、4两步)

  3. 获取中间索引 M = Floor((L+R) /2)

  4. 中间索引对应的值 A[M] 与待搜索的值T 进行比较

    ① A[M] == T 表示找到,返回中间索引

    ② A[M] > T,中间值右侧的其它元素都大于 T,无需比较,中间索引左边去找,M - 1 设置为右边界,重新查找

    ③ A[M] < T,中间值左侧的其它元素都小于 T,无需比较,中间索引右边去找, M + 1 设置为左边界,重新查找

  5. 当 L > R 时,表示没有找到,应结束循环

算法代码

public static int binarySearch(int[] a, int t) {
    int l = 0, r = a.length - 1, m;
    while (l <= r) {
        m = (l + r) / 2;
        if (a[m] == t) {
            return m;
        } else if (a[m] > t) {
            r = m - 1;
        } else {
            l = m + 1;
        }
    }
    return -1;
}

测试代码

public static void main(String[] args) {
    int[] array = {1, 5, 8, 11, 19, 22, 31, 35, 40, 45, 48, 49, 50};
    int target = 47;
    int idx = binarySearch(array, target);
    System.out.println(idx);
}

1.3获取间索引时,如何避免整数溢出

原因:当L和R都特别大时,L+R就可能超出整数范围

两种解决方式:

  • M= (L+R) /2 换种表示
    M=((L+R) /2=L-L/2+R/2=L+(-L/2+R/2)=L+(R-L)/2

  • 利用右移方式计算代替除法
    ((L+R) /2–》 ((L+R) >>>1

1.3二分查找其他考法

其它考法

  1. 有一个有序表为 1,5,8,11,19,22,31,35,40,45,48,49,50 当二分查找值为 48 的结点时,查找成功需要比较的次数
  2. 使用二分法在序列 1,4,6,7,15,33,39,50,64,78,75,81,89,96 中查找元素 81 时,需要经过( )次比较
  3. 在拥有128个元素的数组中二分查找一个数,需要比较的次数最多不超过多少次

对于前两个题目,记得一个简要判断口诀

  • 奇数二分取中间
  • 偶数二分取中间靠左

对于后一道题目,需要知道公式:

n = l o g 2 N = l o g 10 N / l o g 10 2 n = log_2N = log_{10}N/log_{10}2 n=log2N=log10N/log102

  • 如果计算结果是整数,则该整数为最终结果
  • 如果计算结果为小数,则舍去小数,整数加一为最终结果

其中 n 为查找次数,N 为元素个数

2.排序算法

2.1冒泡排序

2.1.1图解冒泡排序(写代码)

相邻元素比较

  • value(t)<value(t+1),则位置不变
  • value(t)>value(t+1),交换t与t+1 位置对应的值

在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

2.1.2冒泡排序代码实现

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int [] array={5,9,7,4,1,3,2,8};
        bubbleSort(array);
        
    }
    
    public static void bubbleSort(int[]a){
        
        for(int j=0;j<a.length-1;j++){
            // 一轮冒泡
            for (int i=0 ; i<a.length-1;i++){
            if (a[i]>a[i+1]){
                swap(a,i,i+1);
                }
            }
            
        }
        
        System.out.println(Arrays.toString(a)); 
    }
    public static void swap(int [] a ,int i,int j){
        int temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

2.1.3冒泡排序代码优化

优化方案1 经过第一轮的循环后,最大元素无需再与前面的元素比较,减少内层循环次数

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int [] array={5,9,7,4,1,3,2,8};
        bubbleSort(array);
        
    }
    
    public static void bubbleSort(int[]a){
        
        for(int j=0;j<a.length-1;j++){
            // 一轮冒泡
            for (int i=0 ; i<a.length-1-j;i++){
            if (a[i]>a[i+1]){
                swap(a,i,i+1);
                }
            }
            
        }
        
        System.out.println(Arrays.toString(a)); 
    }
    public static void swap(int [] a ,int i,int j){
        int temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

优化方案2 减少不必要的冒泡次数,判断什么时候已经有序了,如果一次循环过后,没有发生位置交换,则数组已经有序了

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int [] array={5,9,7,4,1,3,2,8};
        bubbleSort(array);
        
    }
    
    public static void bubbleSort(int[]a){
        boolean swapped=false;// 数组中元素是否发生了位置交换
        
        for(int j=0;j<a.length-1;j++){
            // 一轮冒泡
            for (int i=0 ; i<a.length-1-j;i++){
            if (a[i]>a[i+1]){
                swap(a,i,i+1);
                swapped=true;
                }
            }
            if(!swapped){
                break;
            }
            
        }
        System.out.println(Arrays.toString(a));   
    }
    public static void swap(int [] a ,int i,int j){
        int temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

优化方案3 记录最后一次交换位置时的索引,作为下一次循环的次数

 public static void bubbleSort2(int [] a){
        int n=a.length-1;
        while(true){
            int last=0; // 表示最后一次交换索引时的位置
            for(int i=0;i<n;i++){
                if(a[i]>a[i+1]){
                    swap(a,i,i+1);
                    last=i;
                }
            }
            n=last;
            if(n==0){
                break;
            }
            System.out.println(Arrays.toString(a));
     	}        
}
    

2.1.4冒泡排序总结(以升序为例)

  • 依次比较数组中相邻两个元素大小,若a[j]>a[j+1],则交换两个元素,两两都比较一遍成为一轮冒泡,结果是让最大的元素排至最后
  • 重读以上步骤,直到整个数组有序
  • 优化方式:每轮冒泡时,最后一次交换索引可以作为下一次冒泡的比较次数,如果这个值为零,表示整个数组有序,直接退出外层循环即可。

2.2 选择排序(写代码)

2.2.1图解选择排序

寻找数组中最小的元素,假设最小元素位置在0 ,与其他元素比较,找到最小的,并与其交换位置
在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

2.2.2选择排序代码实现

public staatic void selection(int[]a){
	for(int i=0;i<a.length-1;i++){
		//i 代表每轮循环最小元素要交换的目标位置索引
		int s=i; //s表示最小元素所在位置的索引
		for(int j=s+1;j<a.length;j++){
			if(a[s]>a[j]){
				s=j;
			}
		}
		if(s!=i){
			swap(a,s,i);
		}
	}

}

public static void swap(int[] a ,int i,int j){
    int temp=a[i];
    a[i]=a[j];
    a[j]=temp;
}

2.2.3选择排序总结(以升序为例)

  • 将数组分为两个子集,排序的和未排序的,每一轮从未排序的子集中选出最小的元素,放入排序的子集
  • 重复以上步骤,直到整个数组有序
  • 优化:为减少交换次数,每一轮可以先找最小的索引,在每轮的最后再交换元素。

2.3冒泡排序与选择排序比较

  • 二者平均时间复杂度都是O(n^2)
  • 选择排序一般要快于冒泡排序,因为交换次数少
  • 但如果集合有序度高,冒泡优于选择
  • 冒泡属于稳定排序算法,而选择属于不稳定排序

2.4插入排序

2.4.1图解插入排序

假定第t个元素是有序的,则与t+1元素比较,并将t+1的元素 与t+1前元素比较并插入合适的位置
8在这里插入图片描述在这里插入图片描述在这里插入图片描述

2.4.2插入排序代码实现

public static void insert(int[]a){
	for(int i=1;i<a.length;i++){
		//i 代表待插入元素的索引
		int temp=a[i]; // 代表待插入的元素值
		int j=i-1; //代表已排序区域的元素索引
		while(j>=0){
			
			if(temp<a[j]){
					a[j+1]=a[j];
								
			}else{
				break;
			}
			j--;
		}
		a[j+1]=temp;
	
	}
}

2.4.3优化方式

  • 带插入元素进行比较时,遇到比自己小的元素,就代表找到了插入位置,无需进行后续比较
  • 插入时,可以直接移动元素,而不是交换元素

2.4.4插入排序总结

  • 将数组分为两个区域,排序区域和未排序区域,每一轮从未排序区域中取出第一个元素,插入到排序区域(需要保证顺序)、
  • 重读以上步骤,直到整个数组有序

2.5插入排序与选择排序比较

  • 二者平均时间复杂度都是O(n^2)
  • 大部分情况下,插入都略优于选择排序
  • 有序集合插入的时间复杂度为O(n)
  • 插入排序属于稳定排序算法,选择排序属于不稳定排序

2.6希尔排序(掌握思路)

  1. 首先选取一个间隙序列,如 (n/2,n/4 … 1),n 为数组长度

  2. 每一轮将间隙相等的元素视为一组,对组内元素进行插入排序,目的有二

    ① 少量元素插入排序速度很快

    ② 让组内值较大的元素更快地移动到后方

  3. 当间隙逐渐减少,直至为 1 时,即可完成排序

2.7快速排序

2.7.1图解快速排序

分区,选取一个基准点,比基准点大的元素放在基准点的右边,比基准点小的元素放在基准点的左边
在这里插入图片描述在这里插入图片描述

2.7.2快速排序文字描述

  1. 每一轮排序选择一个基准点(pivot)进行分区
    让小于基准点的元素的进入一个分区,大于基准点的元素的进入另一个分区
    当分区完成时,基准点元素的位置就是其最终位置
  2. 在子分区内重复以上过程,直至子分区元素个数少于等于 1,这体现的是分而治之的思想 (divide-and-conquer)
  3. 从以上描述可以看出,一个关键在于分区算法,常见的有洛穆托分区方案、双边循环分区方案、霍尔分区方案

2.7.3快速排序实现方式1-单边循环快排(洛穆托分区方案)*

  • 选择最元素作为基准点元素
  • j指针负责找到比基准点小的元素,一旦找到则与i进行交换
  • i指针维护小于基准点元素的边界,也是每次交换的目标索引
  • 最后基准点与i交换,i即为分区位置
    在这里插入图片描述
    在这里插入图片描述在这里插入图片描述
public static void main(String[] args) {
    int [] array={5,3,7,2,9,8,1,4};
    // partition(array,0,array.length-1);
    quick(array,0,array.length-1);
}

public static void quick(int[]a,int l,int h){
	if(l>=h){
		return;
	}
	int p=partition(a,l,h);
	//递归实现
	quick(a,l,p-1); //左侧分区的确定范围
	quick(a,p+1,h); //右侧分区的确定范围
}
public static int partition(int[]a,int l,int h){
	int pv=a[h]; //基准点元素
	int i=l;
	for(int j=l;j<h;j++){
		if(a[j]<pv){
			if(i!=j){
				swap(a,i,j);
			}
			i++;
		}
	}
	//基准元素与i交换
	if(i!=h){
		swap(a,h,i);
	}
	
	System.out.println(Arrays.toString(a));
	// 返回值代表基准点元素所在的正确索引,用它确定下一轮分区的边界
	return i;
	


}
public static void swap(int[] a ,int i,int j){
    int temp=a[i];
    a[i]=a[j];
    a[j]=temp;
}

2.7.4快速排序实现方式2-双边循环快排(并不完全等价于hoare分区方案)

  • 选择最边的元素作为基准点
  • j指针负责从右→左找比基准点的元素;i指针负责从左→右寻找比基准点的元素,一旦找到二者交换位置,直至i,j相交
  • 最后基准点与i(此时i与j相等)交换,i即为分区位置
    在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

public static void quick(int[]a,int l,int h){
	if(l>=h){
	    return;
	 }
   int p=partition(a,l,h);
  	// p 基准点的索引值
   quick(a,l,p-1);//左边分区的范围确定
   quick(a,p+1,h);//右边分区的范围确定
	}
public static int binPartition(int[]a,int l,int h){
    	int pv=a[l];
    	int i=l;
    	int j=h;
    	while(i<j){
    		//j从右往左找小的
    		while(i<j&&a[j]>pv){
    			j--;
    		}
    		//i从左网右找大的
    		while(i<j&&a[i]<=pv){
    			i++;
    		}
    		swap(a,i,j);
    	}
		swap(a,l,j);
		System.out.println(Arrays.toString(a));
		return j;
}

	

public static void swap(int[] a ,int i,int j){
    int temp=a[i];
    a[i]=a[j];
    a[j]=temp;
}

2.7.5 快速排序特点

  • 平均时间复杂度 O ( n l o g 2 ⁡ n ) O(nlog_2⁡n ) O(nlog2n),最坏时间复杂度 O ( n 2 ) O(n^2) O(n2)
  • 数据量较大时,优势非常明显
  • 属于不稳定排序
  • 霍尔的移动次数平均来讲比洛穆托少3倍
举报

相关推荐

0 条评论