JAVA 排序的几个案例

我们新建一个工具类

这个工具类 便于我们方便去 做测试 或者是 学习
嗯…我们给它取名字为 Tool 吧

为了便于测试 ,我们 写一个方法 来方便用户创建 数组 以便于排序

//定义一个静态方法 我们跟JDK 中提供的 Arrays 和 Math 工具类 去比较的话 方法几乎都是静态的 这样方便引用
//我们定义一个静态的 方法  返回值的类型 是int[]  也就是int 类型的 数组
//参数1:我们为这个 自定义即将生成的 数组  既定一个长度  index
//参数2:我们给这个数组的数字区间 一个最大值~ max   最小是 0 来的

    public static int[] buildArray(int index ,int max){
    
    	//动态定义 数组 长度为 index
    	
        int[] a=new int[index];
        
        //for 循环为 每一个 赋值
        
        for (int i = 0; i <index ; i++) {
        
        	//每一次都要 重新为 对象 赋值 这样 才能达到 随机数的效果
        	
            Random random= new Random();
            int i1 = random.nextInt(max);
            a[i]=i1;
        }
        
        //将这个 整型的 数组返回~ 
        
        return  a;
    }

定义一个冒泡排序的方法

//定义一个 函数 从小到大 冒泡 排序
    public static int[] doSortTolarge(int num[]){
    
    //解释一下 这里为什么是 length-1呢?
    //原因很简单 ,青蛙跳井的故事 ,一只青蛙跳出一口10米的井,白天跳4米 晚上睡觉 滑下去3米  问:几天可以跳出去呢?
    //如果你斩钉截铁的回答 10天 那么 你就打错了  事实上 这只呱在第7天的 时候就出去了 (自己去算);
    //分析一下这个条件 首先 小于length 那么 遍历最大会在length-1 的地方 
    //为什么再 -1 呢? 因为 最后以为数 一定是 最大的那一个 ,已经没有 必要去 比了
    
        for (int i = 0; i <num.length-1 ; i++) {
        
        //子循环 很灵活 你可以依照这个公式 去写另一种 形式~
        
            for ( int j = 0; j < num.length - 1 - i  ;  j++ ) {
            
            //判断!这个判断的 大于小于  觉得 你的这个方法是 从大到小  还是 从小到大
            
                if ( num[j] > num[j+1] ){   //大于号 恰巧相反  是从小到大
                    int temp = num[j];
                    num[j] = num[j+1];
                    num[j+1] = temp;
                }
            }
        }
        return num;
    }

//如果你说 直接用    Arrays.sort( num );   不就可以了么!  那么~你说的对 从小到大 是这样的呢

再来一个String 类的方法
这个方法类似与toArray().toString();

public static String show(int variable[]){
        String s="";
        for (int i = 0; i <variable.length ; i++) {
            s+=variable[i]+",";
        }
        //截取字符串  
        //参数1 : 下标,角标,index 从 哪里开始 ?
        //参数2: 从哪里结束?
        String s1 = s.substring(0, s.length() - 1);
        
        return s1;
    }

定义一个选择排序的方法

for(int i=0 ; i<num.length-1 ; i++ ){
	for(int j=i+1 ; j.length ;j++ ){
		if( num[i] > num[j] ){
		int temp = num[i];
		num[i] = num[j];
		num[j] =temp;
		}
	}
}

定义一个 二分法排序

private void twoPointQuery() {
   int[] source = {1, 2, 3, 6, 7, 8, 10};
        //查找6的索引
        int num = 12;//要查找的数字
        int start = 0;//查找的起始角标
        int end = source.length - 1;//查找的结尾角标
        int mid = (start + end) / 2;//查找的中间角标
        while (num != source[mid]) {
            if (source[mid] > num) {
                end = mid - 1;
            } else if (source[mid] < num) {
                start = mid + 1;
            }
            //防止死循环
            if (start>end){
                mid=-1;// -1代表没有这个数字
                break;
            }
            mid = (start + end) / 2;
        }

        // 循环结束的时候，mid的值即为要查找的角标值
        Log.d("======", "要查找的num的角标为: "+mid);
    }

定义一个快速排序

/**
     * 快速排序算法
     */
    public void quickSort(int[] list, int left, int right) {
        if (left < right) {
            // 分割数组，找到分割点
            int point = partition(list, left, right);

            // 递归调用，对左子数组进行快速排序
            quickSort(list, left, point - 1);
            // 递归调用，对右子数组进行快速排序
            quickSort(list, point + 1, right);
        }

    }

    /**
 * 分割数组，找到分割点
 */
private int partition(int[] list, int left, int right) {
    // 用数组的第一个元素作为基准数
    int first = list[left];
    while (left < right) {
        while (left < right && list[right] >= first) {
            right--;
        }
        // 交换
        swap(list, left, right);

        while (left < right && list[left] <= first) {
            left++;
        }
        // 交换
        swap(list, left, right);
    }
    // 返回分割点所在的位置
    return left;
}

/**
 * 交换数组中两个位置的元素
 */
private void swap(int[] list, int left, int right) {
    int temp;
    if (list != null && list.length > 0) {
        temp = list[left];
        list[left] = list[right];
        list[right] = temp;
    }
}

具体的快速排序 可以参照
https://blog.csdn.net/sinat_20177327/article/details/76560079
感谢该作者