数组排序

最新推荐文章于 2022-10-23 23:04:46 发布

微辣加包面

最新推荐文章于 2022-10-23 23:04:46 发布

阅读量166

点赞数

本文链接：https://blog.csdn.net/weixin_45702478/article/details/104374920

版权

1.选择排序

就是用第一个元素和其他元素相比如果第一个元素大于后面的元素就进行交换位置

思路：

 使用两层循环来解决问题

第一层循环用于表示第一个元素

第二层循环用于表示后面的每一个元素



for (int i =
0; i < temp.length; i++) {

           //第二层循环用来表示与其比较的数组

           for (int j =i+1; j < temp.length; j++) {
              int bRet = 0;
              if(temp[i]> temp[j]){
                bRet= temp[i];
                temp[i]= temp[j];
                temp[j] = bRet;
              System.out.println(Arrays.toString(temp));

              }
           }
       }

2.冒泡排序

这个排序的方式为什么叫冒泡

相邻元素两两比较



//循环i用于控制要做数列比较的循环的次数

       for (int i =0; i < temp.length-1; i++) {

           //循环j用于表示两个相邻的数字做比较

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

                  bRet= temp[j];

                  temp[j]= temp[j+1];

                  temp[j+1]= bRet;

              }

           }

           System.out.println(Arrays.toString(temp));

       }

3.插入排序
将后面数组的第一个一个一个与前面数组相比较，在合理的位置插入



  int bRet = 0;

       for (int i =1; i < temp.length; i++) {

           for (int j =i; j > 0 ; j--) {
              if(temp[j-1] >temp[j]){              
                  bRet= temp[j-1];
                  temp[j-1]= temp[j];
                  temp[j]= bRet;                  
                  System.out.println(Arrays.toString(temp));
              }
           }
       }

4.计数排序

在这里插入图片描述
计数排序适用于有明确范围的数组，新建一个n-m+1的临时数组，遍历待排序数组，它的值-m作为临时数组下角标，这个位置的值加1 遍历结束，临时数组就存储了每个值的个数，最后将它展开赋值给原数组

public static void main(String[] args) {

    int[] arr = {1,4,6,7,5,4,3,2,1,4,5,10,9,10,3};
    sortCount(arr, 1, 10);
    System.out.println(Arrays.toString(arr));
}

//计数排序的初步实现，使用了多余的空间，可以尝试不使用多余的空间

public static void sortCount(int[] arr, int m, int n) {
     int len = arr.length;
     int[] tem = new int[n - m + 1];
     for(int i = 0; i < len; i++) {
         tem[arr[i] - m] += 1;
}
     for(int i = 0, index = 0; i < tem.length; i++) {
        int item = tem[i];
        while(item-- != 0) {
             arr[index++] = i + m;
                  }

         }

    }

}

数组的扩容
创建一个新的数组将元素赋值进去之后将新数组的地址返回

int[] arr=new int[]{1,2,3};
        arr=copyOf(arr,arr.length+1);
        arr[arr.length-1]=10;
        System.out.println(arr[3]);

题目整理

在这里插入图片描述
有序数组的合并最主要的问题在于数组之间有长有短

public static void main(String[] args){
        int[] list1={1,3,5,7,9};
        int[] list2={2,4,6,8,10};
        System.out.println(Arrays.toString(merge(list1,list2)));
    }

    public static int[] merge(int[] list1,int[] list2){
        if(list1==null&&list2==null){
            return null;
        }
        if(list1==null){
            return list2;
        }
        if(list2==null){
            return list1;
        }
        //只有两个都不是null的情况再考虑具体操作
        int[] list3=new int[list1.length+list2.length];
        int p1=0;
        int p2=0;
        int p3=0;
        while(true){
            if(p1==list1.length&&p2==list2.length){
                break;
            }
            if(p1<list1.length&&p2==list2.length){
                list3[p3++]=list1[p1++];
            }else if(p1==list1.length&&p2<list2.length){
                list3[p3++]=list2[p2++];
            }else{
                if(list1[p1]<=list2[p2]){
                    list3[p3++]=list1[p1++];
                }else{
                    list3[p3++]=list2[p2++];
                }
            }
        }
        return list3;
    }
}

在这里插入图片描述

输入的数据：槽子的个数球的个数=路径的个数
创建槽子的具体的容器int[]
每一个小球下落的路径L R 字符串
对于每一个小球而言其路径中的步骤是随机产生L R
1.提示用户输入槽子的个数和小球的个数
2.根据已有的槽子的个数去创建槽子容器
3.根据已有的球和槽子的个数去随机创建一个小球下落的路径
4.路径中经过几个钉子？路径的步骤有几步和槽子的个数有关
5.如何通过路径的经过得知最终所落入的槽子？

import java.util.*;
class Demo05_04{
    
    public static void main(String[] args){
        //1.
        Scanner scanner=new Scanner(System.in);
        System.out.print("Enter the number of balls to drop:");
        int balls=scanner.nextInt();
        System.out.print("Enter the number of slots in the bean machine:");
        int slots=scanner.nextInt();
        //2.
        int[] arr=new int[slots];
        //3.几个球几个路径path
        for(int i=0;i<balls;i++){
            String path=getPath(slots);
            System.out.println(path);
            //5.只要看当前路径中R的个数即可
            arr[getR(path)]++;
        }
        //6.输出
        System.out.println(Arrays.toString(arr));
        show(arr);
    }
    public static void show(int[] arr){
        int w=arr.length;
        int h=0;
        for(int i=0;i<arr.length;i++){
            if(arr[i]>h){
                h=arr[i];
            }
        }
        for(int i=h-1;i>=0;i--){
            for(int j=0;j<w;j++){
                if(i<arr[j]){
                    System.out.print("O");
                }else{
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
 
    }
    public static int getR(String path){
        int count=0;
        for(int i=0;i<path.length();i++){
            if(path.charAt(i)=='R'){
                count++;
            }
        }
        return count;
    }
    public static String getPath(int slots){
        //4.根据槽子的个数计算每一个球下落的路径
        Random random=new Random();
        String path="";
        for(int j=0;j<slots-1;j++){
            if(random.nextInt(2)==0){   //向左
                path+="L";
            }else{  //向右
                path+="R";
            }
        }
        return path;
    }
}
import java.util.*;
class Demo05_04{
    
    public static void main(String[] args){
        //1.
        Scanner scanner=new Scanner(System.in);
        System.out.print("Enter the number of balls to drop:");
        int balls=scanner.nextInt();
        System.out.print("Enter the number of slots in the bean machine:");
        int slots=scanner.nextInt();
        //2.
        int[] arr=new int[slots];
        //3.几个球几个路径path
        for(int i=0;i<balls;i++){
            String path=getPath(slots);
            System.out.println(path);
            //5.只要看当前路径中R的个数即可
            arr[getR(path)]++;
        }
        //6.输出
        System.out.println(Arrays.toString(arr));
        show(arr);
    }
    public static void show(int[] arr){
        int w=arr.length;
        int h=0;
        for(int i=0;i<arr.length;i++){
            if(arr[i]>h){
                h=arr[i];
            }
        }
        for(int i=h-1;i>=0;i--){
            for(int j=0;j<w;j++){
                if(i<arr[j]){
                    System.out.print("O");
                }else{
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
 
    }
    public static int getR(String path){
        int count=0;
        for(int i=0;i<path.length();i++){
            if(path.charAt(i)=='R'){
                count++;
            }
        }
        return count;
    }
    public static String getPath(int slots){
        //4.根据槽子的个数计算每一个球下落的路径
        Random random=new Random();
        String path="";
        for(int j=0;j<slots-1;j++){
            if(random.nextInt(2)==0){   //向左
                path+="L";
            }else{  //向右
                path+="R";
            }
        }
        return path;
    }
}

微辣加包面

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
数组排序

1.选择排序就是用第一个元素和其他元素相比如果第一个元素大于后面的元素就进行交换位置思路：使用两层循环来解决问题第一层循环用于表示第一个元素第二层循环用于表示后面的每一个元素for (int i =0; i < temp.length; i++) { //第二层循环用来表示与其比较的数组 for (int j =i+1;...
复制链接

扫一扫