java 查找排序笔记

1. 二分查找(有重复值)

给定一个 元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的第一个出现的target，如果目标值存在返回下标，否则返回 -1

先附上正确代码

import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 如果目标值存在返回下标，否则返回 -1
     * @param nums int整型一维数组 
     * @param target int整型 
     * @return int整型
     */
    public int search (int[] nums, int target) {
        int low = 0;
        int high = nums.length-1;
        int mid = 0;
        while(low <= high){
            mid = low+ (high- low) / 2; //获取中间数的下标，每次循环都要重新算mid
            if(nums[mid] == target){  //判断是不是第一个目标值
                while(mid != 0 &&(nums[mid-1] == nums[mid])){//由于数据本身是升序的，只需往前推看有没有重复的即可
                    mid--;
                }
                return mid;
            }
            else if(nums[mid] > target){
                high = mid-1; 
             //若数据为三个数，要求的数是左侧或右侧，
            //若这里high/low=mid,再循环一次，mid始终在中间，要求的依旧在一侧，就陷入了死循环
            }
            else {
                low = mid+1;
            }
        }
        return -1;
    }
}

在写的时候，我有一点很困惑，mid 指向的数如果小于或大于目标值 target,那 low 和high 是等于 mid ,还是 mid-1 / mid+1 呢？

好像都可以 ？

后经过测试发现，选 mid ,不满足所有用例，例如，下图所示：

总结：验证程序正确性，需要考虑到多种测试用例。

2. 冒泡排序

public class BubbleSort {
	public static void main(String[] args) {
		int []arr ={5,2,8,1,43,88,44};//声明并赋值一个数组
		BubbleSort bs= new BubbleSort();//创建一个类对象
		bs.bubbleSort(arr);
	}
	public void bubbleSort(int []arr){
		for(int i=arr.length-1;i>=0;i--){ //外层循环递减，每次确定一个数，每次比较的个数递减
		    int count =0;  //优化：定义一个变量count来保存一趟交换中两两交换的次数,
		    for(int j=0;j<i;j++){ //内层循环两个两个比，把最大的换到最右边 ,注意这里不能写成j<=i，若j=i,当i=6,j+1=7,下面j+1就角标越界了
		        if(arr[j]>arr[j+1]){
		            int t= arr[j];
		            arr[j]=arr[j+1];
		            arr[j+1]=t;

		           count++; //优化：交换次数
		        }
		    }
		    if(count==0){ //优化：如果i==0,则说明排序已经完成,退出for循环
		        break;
		    }
		    for(int k=0;k<arr.length;k++) {
		    	System.out.print(arr[k]+" "); //打印排序过程
		    }
		    	System.out.println();
		}
//		//法二：变了循环，实际上是一样的
//		for(int i=0;i<arr.length;i++){
//			int count =0;
//            for(int j=0;j<arr.length-i-1;j++){//若j<arr.length-i,当i=0,j从0-6，j=6,j+1=7,角标越界，因此需要减1
//            	if(arr[j]>arr[j+1]){
//		            int t= arr[j];
//		            arr[j]=arr[j+1];
//		            arr[j+1]=t;
//
//		           count++; //优化：交换次数
//		        }
//            }
//            if(count==0){ //优化：如果i==0,则说明排序已经完成,退出for循环
//		        break;
//		    }
//		    for(int k=0;k<arr.length;k++) {
//		    	System.out.print(arr[k]+" "); //打印排序过程
//		    }
//		    	System.out.println();
//        }
	}
}

效果：

3. 快排

public class QuickSort {	
	public static void main(String[] args) {
		int [] x= {6,2,7,4,5,3,2,7,8,9,2,3,4,5,2,1,8,4};
		quickSort(x,0,x.length-1);
		
		for (int i = 0; i < x.length; i++) {
			System.out.print(x[i]+",");	
		}
	}
	static void quickSort(int [] x, int low,int high) {	
		if(low<high) {
		   int m=partSort(x,low,high);  
		   //每次递归执行partSort(int [] x, int low, int high),进行排序
           //m接收partsort()返回的low	  
		   quickSort(x,low,m-1);
		   quickSort(x,m+1,high);
		}	
	}
	static int partSort(int [] x, int low, int high) {
		int mid=x[low];//第一次执行，把数组中第一个元素作为mid，之后把交换过后的low作为mid,继续小于它的放左边，大于它的放右边
		while(low<high) {
		    //high 从右往左走，走到比选定的中间数小的，停下来
			while(low<high && x[high]>=mid) {
				high--; 
			}
			
			x[low]=x[high]; //要把小的放左边，但数组长度是固定的？不能插入。那就替换掉原数组的一个。换谁呢？把这个比mid小的数换给左边的low(因为mid已经记录了这个low值,所以不用担心值被覆盖)
			
			//low从左往右走，遇到比选定中间数大的，停下来
			while(low<high && x[low]<=mid) {
				low++;
			}
			
			x[high]=x[low];//把这个比mid大的数补到刚刚空缺出来的high的位子上		
		}
		
		x[low]=mid; //交换完一次后，low左边的数肯定是小于他的，右边的不确定，因此把mid赋值给当前low
		
		return low; //low就是中间的那个数,应该所在的索引位置
	}
}

java学习ing.jpg 😊o(￣▽￣)ブ

有其他见解，评论区留言或者私信，一起讨论，纠正。

关注我，努力鸭~和我一起学习鸭~

另外，转载文章请记得附上原文链接哦