A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 晓随缘 中级黑马   /  2015-9-21 11:39  /  369 人查看  /  1 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

以下是自己初学所做的示例笔记,可能不够规范,但对于本人新人来讲还是比较清晰的了,不足以及疏漏之处希望各位指点一下!
  1. import java.util.*;
  2. /*
  3. 需求:
  4. 1.定义一个可以存储10个整数的容器,
  5. 2.打印数组中角标为0的值,
  6. 3.对数组 int[] arr={2,45,56,4,65,87,345,6756,5435,675,43534,43634};进行遍历,
  7. 4.定义功能,用于打印数组中的元素,元素用逗号隔开
  8. 5.给定一个数组int[] arr={24,45,56,4,65,87,345,6756,5435,675,43934,43734};,获取数组中最大值以及最小值。
  9. 6.对数组int[] arr={24,45,56,4,65,87,345,6756,5435,675,43934,43734};进行从小到大和从大到小排序。
  10. 7对数组int[] arr={24,45,56,4,65,87,345,6756,5435,675,43934,43734}进行冒泡排序。

  11. */
  12. public class Sz
  13. {
  14.         public static void bubbleSort1(int[] arr)
  15.         {
  16.                 for(int x=0;x<arr.length-1;x++)
  17.                 {
  18.                         for(int y=0;y<arr.length-x-1;y++)
  19.         //-x:让每一次比较的元素减少;-1:避免角标越界
  20.                         {
  21.                                 if(arr[y]<arr[y+1])
  22.                                 {
  23.                                         /*
  24.                                         int temp=arr[y];
  25.                                         arr[y]=arr[y+1];
  26.                                         arr[y+1]=temp;
  27.                                         */
  28.                                         swap(arr,y,y+1);
  29.                                 }
  30.                         }
  31.                 }
  32.         }
  33.         //从大到小进行冒泡排序

  34.         public static void bubbleSort(int[] arr)
  35.         {
  36.                 for(int x=0;x<arr.length-1;x++)
  37.                 {
  38.                         for(int y=0;y<arr.length-x-1;y++)
  39.         //-x:让每一次比较的元素减少;-1:避免角标越界
  40.                         {
  41.                                 if(arr[y]>arr[y+1])
  42.                                 {
  43.                                         int temp=arr[y];
  44.                                         arr[y]=arr[y+1];
  45.                                         arr[y+1]=temp;
  46.                                 }
  47.                         }
  48.                 }
  49.         }
  50.         //进行从小到大冒泡排序
  51.         //冒泡排序:内循环结束一次,最值出现在最后位



  52.         public static void selectSort(int[] arr)
  53.         {
  54.                 for(int x=0;x<arr.length-1;x++)
  55.                 {
  56.                         for(int y=x+1;y<arr.length;y++)
  57.                         {
  58.                                 if(arr[x]>arr[y])
  59.                                 {
  60.                                         int temp=arr[x];
  61.                                         arr[x]=arr[y];
  62.                                         arr[y]=temp;
  63.                                 }
  64.                         }
  65.                 }
  66.         }
  67.         //进行从小到大排序


  68.         public static void selectSort1(int[] arr)
  69.         {
  70.                 for(int x=0;x<arr.length-1;x++)
  71.                 {
  72.                         for(int y=x+1;y<arr.length;y++)
  73.                         {
  74.                                 if(arr[x]<arr[y])
  75.                                 {
  76.                                         /*
  77.                                         int temp=arr[x];
  78.                                         arr[x]=arr[y];
  79.                                         arr[y]=temp;
  80.                                         */
  81.                                         swap(arr,x,y);
  82.                                         }
  83.                         }
  84.                 }
  85.         }
  86.         //从大到小排序
  87.         //选择排序:内循环结束一次,最值出现在头角标的位置上。


  88.         /*
  89.           发现无论什么排序,在条件满足后的元素都需要进行位置置换,所以可以将这部分
  90.         相同的代码提取出来,对其封装,定义函数.
  91.         */

  92.         public static void swap(int[] arr,int a ,int b)
  93.         {
  94.                 int temp=arr[a];
  95.                 arr[a]=arr[b];
  96.                 arr[b]=temp;
  97.         }


  98.         public static void getLine()
  99.         {
  100.                 System.out.println("-------------------------------------");
  101.         }
  102.         //分割线

  103.         public static void getArray(int[] arr)
  104.         {
  105.                 System.out.print("[");
  106.                 for(int x=0;x<arr.length;x++)
  107.                 {
  108.                         if(x<arr.length-1)
  109.                                 System.out.print(arr[x]+",");
  110.                         else
  111.                                 System.out.print(arr[x]);
  112.                 }
  113.                 System.out.println("]");
  114.         }
  115.         //功能,用于打印数组中的元素,元素用逗号隔开

  116.         public static int getMax(int[] arr)
  117.         {
  118.                 int max=arr[0];
  119.                 for(int x=1;x<arr.length;x++)
  120.                 {
  121.                         if(max<arr[x])
  122.                                 max=arr[x];
  123.                 }
  124.                 return max;
  125.         }
  126.         //获取数组中最大值

  127.         public static int getLeast(int[] arr)
  128.         {
  129.                 int least=arr[0];
  130.                 for(int x=1;x<arr.length;x++)
  131.                 {
  132.                         if(least>arr[x])
  133.                                 least=arr[x];
  134.                 }
  135.                 return least;
  136.         }
  137.         //获取数组中最小值



  138.         public static void main(String[] args)
  139.         {
  140.                 //定义一个可以存储10个整数的容器
  141.                 int[] sum = new int[10];
  142.                 sum[0]=39;
  143.                 sum[1]=213;
  144.                 sum[2]=424;
  145.                 sum[3]=464;
  146.                 sum[4]=443;
  147.                 sum[5]=444;
  148.                 sum[6]=4354;
  149.                 sum[7]=434;
  150.                 sum[8]=474;
  151.                 sum[9]=4744;
  152.                 System.out.println(sum[0]);//打印数组中角标为0的值
  153.                 getLine();


  154.                 //对数组进行遍历
  155.                 int[] arr={24,45,56,4,65,87,345,6756,5435,675,43934,43734};
  156.                 for(int x=0;x<arr.length;x++)
  157.                 {
  158.                         //System.out.println("sum["+x+"]"+"="+sum[x]+";");
  159.                         System.out.println("arr["+x+"]"+"="+arr[x]+";");
  160.                 }
  161.                 getLine();


  162.                 //定义功能,用于打印数组中的元素,元素用逗号隔开
  163.                 getArray(arr);
  164.                 getLine();


  165.                 //给定一个数组,获取数组中最大值以及最小值。               
  166.                 //获取数组中最大值
  167.                 int max1=0;
  168.                 for(int b=0;b<arr.length;b++)
  169.                 {
  170.                         if(arr[max1]<arr[b])
  171.                                 max1=b;
  172.                 }
  173.                 System.out.println("max="+arr[max1]);
  174.                 getLine();

  175.                 //获取数组中最小值
  176.                 int least1=0;
  177.                 for(int b=0;b<arr.length;b++)
  178.                 {
  179.                         if(arr[least1]>arr[b])
  180.                                 least1=b;
  181.                 }
  182.                 System.out.println("least="+arr[least1]);
  183.                 getLine();


  184.                 int max=getMax(arr);
  185.                 System.out.println("max="+max);
  186.                 getLine();


  187.                 int least=getLeast(arr);
  188.                 System.out.println("least="+least);
  189.                 getLine();
  190.                
  191.                 selectSort(arr);
  192.                 getArray(arr);
  193.                 getLine();
  194.                 //选择排序:从小到大排序

  195.                 selectSort1(arr);
  196.                 getArray(arr);
  197.                 getLine();
  198.                 //选择排序:从大到小排序

  199.                 bubbleSort(arr);
  200.                 getArray(arr);
  201.                 getLine();
  202.                 //进行从小到大冒泡排序       

  203.                 bubbleSort1(arr);
  204.                 getArray(arr);
  205.                 getLine();
  206.                 //进行从大到小冒泡排序       

  207.                 Arrays.sort(arr);
  208.                 /*
  209.                 在顶部定义import java.util.*;
  210.                 java中已经定义好的一种排序方式,开发中对数组排序,要使用该句代码。
  211.                 效率相对稍高,不容易出错
  212.                 */

  213.                 getArray(arr);
  214.                 getLine();

  215.         }
  216.                
  217.        
  218. }
复制代码



1 个回复

倒序浏览
当初我一个人冥思苦想冒泡排序,想了很久才弄明白。
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马