`

二分法、冒泡排序

    博客分类:
  • j2se
 
阅读更多

import java.util.Scanner;
/**
   总结: if,switch,for,while,一维数组,二维数组,函数
**/
public class Test
{
 /**平年闰年
 public static void main(String[] args)
 {
       int month=2;
    int year=2002;
     if(month==1||month==3||month==5||month==7||month==8||month==10||month==12){
          System.out.println("31天");
  }else if(month==4||month==6||month==9||month==11){
          System.out.println("30天");
  }else if(month==2){
   if(year%4==0&&year%100!=0 || year%400==0){
          System.out.println("29天");
   }else{
    System.out.println("28天");
   } 
 }**/
   /**switch运用
   public static void main(String[] args) {
       int grade=6;
    switch(grade){
     case 1:
                  System.out.println("☆");
            break;
     default:
        System.out.println("错了");
          // break;
           case 2:
         System.out.println("☆☆");
         break;
     case 3:
         System.out.println("☆☆☆");
         break;
     case 4:
         System.out.println("☆☆☆☆");
         break;
     case 5:
         System.out.println("☆☆☆☆☆");
         break;
    
    }

 }
 **/
/** for和while输出1-100之内的奇数和
  public static void main(String[] args) {
   int sum=0;
   for(int i=1;i<100;i++){
    if(i%2!=0){
    sum=sum+i;
    }
   }
   System.out.println(sum);
 

     sum=0;
  int i=1;
  while(i<100){
   if(i%2!=0){
            sum=sum+i;
   }
   i++;
  }
}
**/
//打印实心等腰三角形
/**
public static void main(String[] args) {
  int rows = 0; //三角形行数
  System.out.print("请输入等腰三角形的行数:");
  Scanner input = new Scanner(System.in);
  rows = input.nextInt();
  //打印等腰三角形,其中i表示整个这个等腰三角形的行数,j表示三角形中空格的行数,k表示三角形中*的行数
  for(int i = 1; i <= rows; i++){
   for(int j = 1; j <= rows-i; j++){
    System.out.print(" ");//先输出row-i个空行
   }
   for(int k = 1; k <= 2*i-1; k++){
    System.out.print("*");//再输出2*i-1个*
   }                         //先输出row-i个空行,再输出2*i-1个*,这就是三角形的左半部分空白和所有*,右半部分空白不用管。到此为止完成一行
   System.out.print("\n");//回车,开始打印三角形的下一行
  }
 }
**/
/**
//打印空心菱形
public static void main(String[] args) {
  int rows = 0; //菱形的行数
  Scanner input = new Scanner(System.in);
  System.out.print("请输入菱形行数:");
  rows = input.nextInt();

  while(rows%2 == 0){
   System.out.print("请输入奇数:");
   rows = input.nextInt();
  }

  int n = (rows+1)/2;
  //打印菱形的上半部分
  for(int i = 1; i <= n; i++){//外层循环变量i控制行数
   for(int j = 1; j <= n-i; j++){//内层循环变量j控制该行空格数
    System.out.print(" ");
   }
   System.out.print("*");
   for(int k = 1; k <= 2*(i-1)-1; k++){//内层循环变量k控制该行*号数
    System.out.print(" ");
   }
   if(i!=1){
   System.out.print("*");
   }
   System.out.print("\n");
  }
  //打印菱形的下半部分
  for(int i = n-1; i >= 1; i--){
   for(int j = 1; j <= n-i; j++){
    System.out.print(" ");
   }
   System.out.print("*");
   for(int k = 1; k <= 2*(i-1)-1; k++){
    System.out.print(" ");
   }
   if(i!=1){
   System.out.print("*");
   }
   System.out.print("\n");
  }
 }
**/

 

 

public static void main(String[] args) {
 int val=78;
 //1
 int temp=Test.max(4,67);//这里用类名,只是默认不写,
                          //这就是函数和方法的区别,函数用static修饰,用类名调用。方法不用static修饰,用对象名调用
 System.out.println(temp);
    //2
 int temp1=Test.max1(34,68,45);
 System.out.println(temp1);
    //3
 int[] a={34,78,99,10,100};
 int temp2=max2(a);
 System.out.println(temp2);
    //4
 bubble_Sort(a);
 for(int i=0;i<a.length;i++){
  System.out.print(a[i]+"  ");
 }
 System.out.println("");
    //5
 int temp3=search(a,val);
 System.out.println(temp3);
    //6
 int temp4=search1(a,val);
 System.out.println(temp4);
    //7
 reverse(a);
 for(int i=0;i<a.length;i++){
  System.out.print(a[i]+"  ");
 }
 System.out.println("");
 //8
 int temp5=add(a);
 System.out.println(temp5);
 //9
 double temp6=avg(a);
    System.out.println(temp6);
    //注释:这能打出具体的商,因为是float类型,在求商的时候强制类型转换了。
 int x=20;
 float y=22.19f;
    System.out.print(x/y);
 System.out.println("");
 //10.
 System.out.println("---------");
 double temp7=avg1(a);//double保留十四位小数
    System.out.println("打印:"+temp7);
 float temp8=avg1(a);//float保留一位小数
    System.out.println("打印:"+temp8);
 System.out.println("---------");
 //11.
 sort(a);
 for(int i=0;i<a.length;i++){
  System.out.print(a[i]+"  ");
 }
   System.out.println("");
   //12.
   String temp9=arrToString(a);
   System.out.println(temp9);
}

//1.求两个数的最大值
public static int max(int x,int y){//这里必须加上static关键字,否则无法运行
  int m=x>y?x:y;                  //返回值为基础数据类型保存在栈内存???还是方法没有被对象调用???
  return m;
}
//2.求三个数的最大值
public static int max1(int x,int y,int z){
    int m=max(x,y);
  m=max(m,z);
  return m;
}
//3.求数组的最大值
public static int max2(int[] arr){
 int max=arr[0];
    for(int i=1;i<arr.length;i++){
  if(arr[i]>max){
   max=arr[i];
  }
 }
 return max;
}
//4.数组的冒泡排序
public static void bubble_Sort(int[] arr){
 for(int i=0;i<arr.length-1;i++){
  for(int j=0;j<arr.length-1-i;j++){
   if(arr[j]<arr[j+1]){
    int temp=arr[j];
    arr[j]=arr[j+1];
    arr[j+1]=temp;
   }
  }
 }
}
//5.数组中的查找,查找这个数在数组中的位置
public static int search(int[] arr,int value){
 for(int i=0;i<arr.length;i++){
  if(arr[i]==value){
          return i;
  }
 }
 return -1; 
}
//6.数组中的查找,二分法查找
public static int search1(int[] arr,int value){
 int min=0;//第一个数下标(索引)
 int max=arr.length-1;//最后一个数的下标
 int mid=(max+min)/2;//中间数下标
 while(arr[mid]!=value){
  if(value>arr[mid]){
    min=mid+1;  
  }else if(value<arr[mid]){
   max=mid-1;
  }
  mid=(max+min)/2;
 }
 return mid;
 }

//7.数组中的反转
public static void reverse(int []arr) {
 for(int i=0;i<arr.length/2;i++){//这里注意循环次数
  int temp=arr[i];//将arr[i]与arr[arr.length-1-i]进行交换
  arr[i]=arr[arr.length-1-i];
  arr[arr.length-1-i]=temp;  
 }
  }
//8.数组求和
public static int add(int[] arr){
 int sum=0;
 for (int i=0;i<arr.length ;i++ )
 {
  sum=sum+arr[i];
 }
 return sum;
}
//9.数组求平均值:思路是在用/号的时候引入double或者float类型的数据,让除完的结果变成小数
public static float avg(int[] arr){
 int sum=0;
 for (int i=0;i<arr.length ;i++ )
 {
        sum=sum+arr[i];
 }
 int num1=sum/arr.length;//整数
 
 float num2=sum%arr.length;//余数,这里的类型不能为整型,因为还需要利用余数求小数呢,在求小数的时候需要double类型或者float类型的,这样能够打印具体的小数出来
 float num3=num2/arr.length;//余数的余数
 System.out.println("整数部分:"+num1);
 System.out.println("余数部分:"+num2);
 System.out.println("余数再次求余(小数部分):"+num3);
 float avg=num1+num3;//这题能证明:float保留一位小数,double保留14位小数
 System.out.println("平均数:"+avg);
 return avg;
}
//10.求数组平均值,简化第九题。
public static float avg1(int[] arr){
 float sum=0;
 for (int i=0;i<arr.length ;i++ )
 {
        sum=sum+arr[i];
 }
 System.out.println(sum);
 float avg1=sum/arr.length;
 return avg1;
}
//11.数组排序中的选择排序:选择排序
public static void sort(int[] arr){
 for(int i=0;i<arr.length;i++){
  for(int j=i+1;j<arr.length;j++){
   if(arr[i]<arr[j]){
    int temp=arr[i];
    arr[i]=arr[j];
    arr[j]=temp;
   }
  }
 }
}
//12.将数组转化成字符串,例[34,45,38,79]
public static String arrToString(int[] arr){
 String str="[";
 for(int i=0;i<arr.length;i++){
  if(i!=arr.length-1){
   str=str+arr[i]+",";
  }else{
   str=str+arr[i]+"]";
  }
 }
   return str;
}


}

分享到:
评论

相关推荐

    冒泡排序以及二分法查询

    冒泡排序以及二分法查询冒泡排序以及二分法查询冒泡排序以及二分法查询冒泡排序以及二分法查询冒泡排序以及二分法查询

    实现直接插入排序,二分法插入排序、希尔排序,冒泡排序,快速排序,直接选择排序的算法.pdf

    在本文中,我们将深入探讨五种常见的排序算法:直接插入排序、二分法插入排序、希尔排序、冒泡排序和快速排序,并对其实现进行详细的解释。 直接插入排序 直接插入排序是一种简单的排序算法,它的实现思路是:从第...

    冒泡排序、快速排序和二分法查找的分析 Java

    ### 冒泡排序、快速排序和二分法查找的分析:Java实现 #### 冒泡排序(Bubble Sort) 冒泡排序是一种简单的排序算法,它重复地遍历要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。遍历数列...

    冒泡 快速排序 选择排序 二分法 插入 快速选择

    以下将详细讲解标题和描述中提到的几种排序算法:冒泡排序、快速排序、选择排序、二分法、插入排序以及快速选择排序。 1. **冒泡排序**:冒泡排序是一种简单的比较排序算法。它通过重复遍历待排序的数列,一次比较...

    C#冒泡算法+经典算法

    冒泡排序是一种基础且经典的排序算法,它在C#中有着广泛的应用。此算法通过不断地交换相邻的不正确顺序的元素来逐步使整个序列有序。它的核心思想是重复地走访过要排序的元素,依次比较并交换相邻元素,如果它们的...

    用javascript实现的十大排序算法详解

    冒泡排序是一种简单的排序方法,通过重复遍历待排序的数组,比较相邻元素并交换位置来实现排序。JavaScript实现冒泡排序的关键在于两层循环结构,外层控制遍历次数,内层用于比较和交换。 2. 插入排序(Insertion ...

    算法之排序专题 二分法排序等等

    冒泡排序是最基础的排序方法,其工作原理就像水中的气泡上升一样,逐步将较大的元素“冒”到数组的末尾。虽然冒泡排序的时间复杂度为O(n^2),但在某些特定情况下,如数据已部分有序,它的效率可能会提高。在冒泡排序...

    java 冒泡算法和插入法排序,二分法查找

    本文将深入探讨Java中的冒泡排序、插入排序以及二分法查找这三种基础算法,这些都是面试时经常会被问到的技术点。 首先,让我们从冒泡排序开始。冒泡排序是一种简单直观的排序算法,它重复地遍历待排序的数列,一次...

    C# 简单的冒泡、快速排序及二分法查找.zip

    首先,我们来探讨冒泡排序(Bubble Sort)。这是一种简单的交换排序方法,适用于小规模数据的排序。其基本思想是通过不断比较相邻元素并交换位置,使较大的元素逐渐“浮”到数组的一端。冒泡排序的时间复杂度为O(n^2...

    数据结构里的排序问题

    - **冒泡排序**:是最简单的交换排序之一,它通过不断比较相邻元素并交换位置,使得最大(或最小)的元素逐渐“浮”到序列末尾,就像气泡上升一样。虽然效率较低,但易于理解和实现。 - **快速排序**:由C.A.R. ...

    【Java→冒泡排序与二分法查找】懒惰的小黑笔记08(小白一名,请大家多指点)

    文章目录6.4 冒泡排序的基础算法6.4.1 冒泡排序优化算法6.5二分法查找(折半检索) 6.4 冒泡排序的基础算法 冒泡排序是常用的排序算法,笔试中非常常见。 算法重复地走访过排序的数列,一次比较两个元素,如果他们的...

    【JAVA基础】【算法】冒泡排序_优化排序,二分法查找_折半检索

    【JAVA基础】冒泡排序与优化排序 冒泡排序是一种简单直观的排序算法,它重复地遍历要排序的数列,一次比较两个元素,如果它们的顺序错误就把它们交换过来。这种排序方式就像水底下的气泡一样,较大的元素通过不断地...

    java二分法排序源码-Article:十大经典排序算法动画,看我就够了!

    常见的内部排序算法有:插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。 用一张图概括: 关于时间复杂度: 平方阶 (O(n2)) 排序 各类简单排序:直接插入、直接选择和冒泡排序。 ...

    21天学会Java之(Java SE第八篇):数组、冒泡排序法、二分法查找

    数组 数组的定义 数组是相同类型数据的有序集合,数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。其中,每一个数据称作一个元素,每个元素可以通过一个索引(下标)来访问它们。...

    数据结构排序.rar

    这里我们主要讨论的是在数据结构中的几种常见排序方法,包括插入排序、冒泡排序、快速排序以及与二分法相关的排序策略。 1. 插入排序: 插入排序是一种简单直观的排序算法,它的工作原理类似于打扑克牌。初始时,...

    冒泡排序法

    关于排序的问题,冒牌排序、二分法、以及许多。此处为最基本的冒泡排序

    Java常用排序算法&程序员必须掌握的8大排序算法+二分法查找

    1. **冒泡排序**:最简单的排序方法,通过不断交换相邻的逆序元素来逐步排序。虽然效率较低,但易于理解。 2. **选择排序**:每次从未排序的部分找到最小(或最大)的元素,放到已排序部分的末尾。其优点在于算法...

    二分法 文件写入读出

    例如,我们可以创建一个ArrayList,用冒泡排序(一种简单的排序算法)对数据进行排序,然后将数据写入文件。冒泡排序的工作原理是通过不断交换相邻的逆序元素来逐步排序整个序列。 对于文件读出,我们可以先读取...

    Java常用高效8大排序算法与二分法查找

    1. 冒泡排序:这是一种简单的排序方法,通过重复遍历待排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。 2. 插入...

    Python编程二分法实现冒泡算法+快速排序代码示例

    #冒泡排序 def func(lt): if type(lt).__name__ !='list' and type(lt).__name__ !='tuple': return if type(lt).__name__ == 'tuple': return list(lt) for i in range(1,len(lt)-1): for j in range(1,len(lt)-i)...

Global site tag (gtag.js) - Google Analytics