Java.基础知识篇.03 循环、数组、冒泡排序



一、循环:

     1.循环:反复执行一段相同或相似的代码
     2.循环三要素:
           1)循环变量的初始化
           2)循环的条件(以循环变量为基础)
           3)循环变量的改变(向着循环的结束变)

     3.三种循环的更佳适用情况:
          1)while:"当..."循环
          2)do...while:"直到..."循环
                       第1要素与第3要素相同时首选do...while
          3)for:固定次数循环,应用率最高


二、数组:

      1.相同数据类型元素的集合
      2.是一种数据类型(引用类型)
      3.数组的定义:
               int[] arr = new int[4];//4表示数组共有四个元素
      4.数组的初始化:
               int[] arr = new int[4]; //0,0,0,0
               char[] arr = {a,b,c,d}; //a,b,c,d
               int[] arr = new int[]{1,4,5,8}; //1,4,5,8


               int[] arr;
               arr = {1,4,5,8}; //编译错误
               arr = new int[]{1,4,5,8}; //正确
      5.数组的访问:
           5.1)通过(数组名.length)可以获取数组的长度
                       int[] arr = new int[5];
                       System.out.println(arr.length); //5
           5.2)通过下标来访问数组中的元素下标从0开始,最大到(数组.length-1)
                       int[] arr = new int[3];
                       arr[0] = 100; //给arr中第1个元素赋值为100
                       arr[1] = 200; //给arr中第2个元素赋值为200
                       arr[2] = 300; //给arr中第3个元素赋值为300
                       arr[3] = 400; //数组下标越界异常
                       System.out.println(arr[arr.length-1]); //输出arr中的最后一个元素
      6.数组的遍历:
                int[] arr = new int[10];
                for(int i=0;i<arr.length;i++){
                      arr[i] = (int)(Math.random()*100);
                 }
                 for(int i=0;i<arr.length;i++){ //正序
                       System.out.println(arr[i]);
                  }
                for(int i=arr.length-1;i>=0;i--){ //倒序
                       System.out.println(arr[i]);
                  }
      7.数组的复制:
             ①  System.arraycopy(a,1,a1,0,4);
             ②  int[] a1 = Arrays.copyOf(a,6);
                  a = Arrays.copyOf(a,a.length+1); //扩容
      8.数组的排序:
            Arrays.sort(arr); //升序,效率高
    

三、冒泡排序(Bubble Sort)       

      1.排序步骤:
            ①比较相邻的元素。如果第一个比第二个大,就交换他们两个。
            ②对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。
            ③针对所有的元素重复以上的步骤,除了最后一个。
            ④持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
         简单总结为:逐一比较相邻元素,每轮确定一个元素位置,直至所有元素位置确定。
      2.复杂度、稳定性:
              时间复杂度:O(n²) 
              稳定排序算法
   
     3.算法描述(Java)
public class BubbleSort
{
    public void sort(int[] a)
    {
        int temp = 0;
        for (int i = a.length - 1; i > 0; --i)
        {
            for (int j = 0; j < i; ++j)
            {
                if (a[j + 1] < a[j])
                {
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
    }
}
 
 

猜你喜欢

转载自blog.csdn.net/u012761191/article/details/69097827