JavaSE第三章

最新推荐文章于 2024-07-27 13:31:57 发布

疯子在辉

最新推荐文章于 2024-07-27 13:31:57 发布

阅读量70

点赞数

分类专栏： javaSE 文章标签： java 插入排序排序算法

本文链接：https://blog.csdn.net/m0_53679492/article/details/119206068

版权

javaSE 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

JavaSE第三章

文章目录

JavaSE第三章

数组的基本概念及作用

数组是相同数据类型元素的集合

数组本身是引用数据类型，即对象。但是数组可以存储基本数据类型，也可以存储引用数据类型。

总结：

Java数组：存储一组相同类型的数据

数组是一个连续的存储空间，当数组的长度一旦确定，就不能改变了。

数组属于引用数据类型（也可以说数组属于对象）

数据可以存储基本数据类型，也可以存储引用类型

数组的声明与创建

import java.util.Arrays;

/**
 * @author 辉欲静，而风止。
 * 动态数组
 * @date 2021年7月21日08:59:20
 */
public class DynamicArray {
    public static void main(String[] args) {
        /*
        声明数组
        X[] a;数组a  X表示数组中可以存储数据的数据类型
         */
        //动态创建  整型数组
        int[] array = new int[5];
        System.out.println(Arrays.toString(array));
        //长整型
        long[] longs = new long[5];
        System.out.println(Arrays.toString(longs));
        //字符型数组
        char[] chars = new char[5];
        System.out.println(Arrays.toString(chars));
        //字符串型数组
        String[] strings = new String[5];
        System.out.println(Arrays.toString(strings));
        // 布尔型数组
        boolean[] booleans = new boolean[5];
        System.out.println(Arrays.toString(booleans));
        //静态创建的两种方式
        //当数量已知，或者数量确定时     建议使用第二种方式进行静态创建
        int[] b1 = new int[]{1,2,3};
        System.out.println(Arrays.toString(b1));
        int[] b2 ={1,2,3,5,9};
        System.out.println(Arrays.toString(b2));
    }
}

运行结果：

[0, 0, 0, 0, 0]
[0, 0, 0, 0, 0]
[ ,  ,  ,  ,  ]
[null, null, null, null, null]
[false, false, false, false, false]
[1, 2, 3]
[1, 2, 3, 5, 9]

数组的访问与迭代

package com.sxlg.blog.note_array;

import java.util.Arrays;

public class Traitarray {
    public static void main(String[] args) {
         /*
        数组元素的访问：通过索引下标访问
            索引的特点：index
                     整数
                     从零开始，到数组长度-1
         */
        int[] b2 ={1,2,3,5,9};
        // 数组长度为五   下标范围既是从0到数组长度-1   数组下标 从0--4
        System.out.println(Arrays.toString(b2));
        System.out.println(b2[0]);
        System.out.println(b2[2]);
        //ArrayIndexOutOfBoundsException  数组越界
        System.out.println(b2[5]);

    }
}

运行结果：

[1, 2, 3, 5, 9]
1
3
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
	at com.sxlg.blog.note_array.Traitarray.main(Traitarray.java:17)

第一种：for循环

第二种：增强for循环

public static void main(String[] args) {
     	//整型静态数组
        int[] c = {1,2,3,4};
        //遍历 for循环
        for (int i = 0; i < c.length; i++) {
            //i=0 1 2 3   通过索引访问
            System.out.println(c[i]);
        }
        //增强for循环
        /*
        for(声明一个变量，用来接收每次从数组中取出来的元素 ： 需要遍历的数组){
        每循环一次，从数组中取出一个元素，赋给定义的变量，直到没有元素
        }
         */
        for(int t : c){
            System.out.println(t);
        }
    }

运行结果：

//双精度型数组
        double[] d = {1.0,2.0,3,4};
        for (double t : d){
            System.out.print(t+"\t");
        }
        //浮点型数组   浮点型数组它里面的小数数据后面必须加F或f  不然会报错
        float[] f = {1.2f,2.3F,3.0f,4};
        System.out.println(Arrays.toString(f));

在这里插入图片描述

运行结果：

1.0	2.0	3.0	4.0	[1.2, 2.3, 3.0, 4.0]

数组排序

冒泡排序

冒泡排序就是将相邻的元素比较交换，然后进行升序排序

import java.util.Arrays;

/**
 * @author 辉欲静，而风止。
 * 冒泡排序
 * 典型的交换排序方法，需要按照升序进行排序
 */
public class BubbleSort {
    /**
    冒泡排序即就是相邻的元素进行比较排序
     */
    public static void main(String[] args) {
        int[] a = {5,4,3,2,1};
        //控制循环次数     冒泡排序会将最大的一位放在最后，所以最后一位不用再比较
        for (int i = 0; i < a.length-1; i++) {
            //控制比较次数
            for (int j = i+1; j < a.length; j++) {

                if(a[i]>a[j]){
                    int temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(a));
        /*
        toString 方法：
             public static String toString(int[] a) {
        if (a == null)
            return "null";
        int iMax = a.length - 1;
        if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0; ; i++) {
            b.append(a[i]);
            if (i == iMax)
                return b.append(']').toString();
            b.append(", ");
        }
    }
         */
    }
}

选择排序

选择排序是一种简单直观的排序算法。它的工作原理是每一趟从待排序的数据元素中
选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部排序的
数据元素排完
选择排序算法通过选择和交换来实现排序，其排序流程如下：
（1）首先从原始数组中选择最小的一个数据，将其和第一个位置的数据交换
（2）接着从剩下的n-1个数据中选择次小的1个元素，将其和第二个位置的数据交换
（3）以此类推，直到最后两个数据完成交换。最后，便完成了对原始数据的从大到小的排序

import java.util.Arrays;

/**
 * @author 辉欲静，而风止。
 * 选择排序
 * @date 2021年7月27日07:41:15
 */
public class Select {
    public static void main(String[] args) {
        Select w=new Select();
        //调用选择排序1
        System.out.println("普通选择排序：");
        w.select1();
        //调用优化后的选择排序2
        System.out.println("优化选择排序：");
        w.select2();

    }
    public void select1(){
        int[] a={5,4,3,2,1};
        //示例选择排序比较过程在笔记里
        //从数组索引下标为零第一个元素开始
        for (int i = 0; i < a.length-1; i++) {
            //与后面的元素挨个比较
            for (int j = i+1; j < a.length; j++) {
                //从小到大排序  <从大到小排序
                if(a[i]>a[j]){
                    //定义一个中间变量
                    int temp = a[i];
                    a[i]=a[j];
                    //交换位置
                    a[j]=temp;
                }
            }
            System.out.println(Arrays.toString(a));
        }

    }
    public void select2(){
        int[] a = {5,4,3,2,1};

        /*从第一个元素开始与后面每个元素比较*/
        for (int i = 0; i < a.length-1; i++) {
            //在外层循环下记录最小下标
            int minIndex = i;
            for (int j = i+1; j < a.length; j++) {
                if(a[minIndex]>a[j]){
                    //再次记录最小下标
                    minIndex = j;
                }
            }
            /*整个比较完成之后，交换位置*/
            int temp = a[i];
            a[i]=a[minIndex];
            a[minIndex]=temp;

            System.out.println(Arrays.toString(a));
        }
       // System.out.println(Arrays.toString(a));
    }

}

运行结果：

普通选择排序：
[1, 5, 4, 3, 2]
[1, 2, 5, 4, 3]
[1, 2, 3, 5, 4]
[1, 2, 3, 4, 5]
优化选择排序：
[1, 4, 3, 2, 5]
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]

import java.util.Arrays;

/**
 * @author 辉欲静，而风止。
 * 选择排序
 */
public class Selects {
    public static void main(String[] args) {
        int[] a = {3,2,8,6,1};
        for (int i = 0; i < a.length-1; i++) {
            for (int j = i+1; j < a.length; j++) {
                    if(a[i]>a[j]){
                        int temp = a[i];
                        a[i] = a[j];
                        a[j] = temp;
                    }
            }
            //排序过程
            System.out.println(Arrays.toString(a));
        }
    }
}

运行结果：

[1, 3, 8, 6, 2]
[1, 2, 8, 6, 3]
[1, 2, 3, 8, 6]
[1, 2, 3, 6, 8]

import java.util.Arrays;

/**
 * @author 辉欲静，而风止。
 * 优化选择排序
 */
public class SelectSort {
    public static void main(String[] args) {
       // int[] a = {2,0,3,4,9,1};
        int[] a = {3,2,8,6,1};
        for (int i = 0; i < a.length-1; i++) {
            //记录最小下标
            int minIndex = i;
            for (int j = i+1; j < a.length; j++) {
                if(a[minIndex]>a[j]){
                    //再次记录最小下标
                    minIndex = j;

                }
            }
            int temp = a[i];
            a[i] = a[minIndex];
            a[minIndex] = temp;

            System.out.println(Arrays.toString(a));
        }

    }
}

运行结果：

[1, 2, 8, 6, 3]
[1, 2, 8, 6, 3]
[1, 2, 3, 6, 8]
[1, 2, 3, 6, 8]

插入排序

有一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列

仍然有序，这个时候就要用到一种新的排序方法——插入排序法，插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序。

插入排序是将要排序的数组分为两个部分：一部分为有序，一部分无序，每次从无序部分中取出一个
元素与有序部分进行比较，若小于前面的元素，则交换位置，直到数组变为有序数组为止

import java.util.Arrays;

/**
 * @author 辉欲静，而风止。
 * 插入排序
 */
public class ChaRuSort {
    public static void main(String[] args) {
        
        int[] a = {9,5,1,0,7,2};
        //外层循环取出除第一元素外的其他所有元素
        for (int i = 1; i < a.length; i++) {
            //确保存外层循环取出的元素都与前面每一个元素进行比较
             //从后向前比较，比较到第0个位置停止
            for (int j = i; j > 0; j--) {
                if(a[j]<a[j-1]){
                    int temp = a[j];
                    a[j] = a[j-1];
                    a[j-1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

import java.util.Arrays;

/**
 * @author 辉欲静，而风止。
 * 优化插入排序
 */
public class ChaRu {
    public static void main(String[] args) {
        int[] a = {9, 5, 1, 0, 7, 2};
        //记录当前要排序的那个元素  
        int currentValue = 0;
        for (int i = 0; i < a.length - 1; i++) {
            //拿到无序数组首位元素5
            currentValue = a[i + 1];
            //记录当前所比较的位置
            int preIndex = i;
            while (preIndex >= 0 && currentValue < a[preIndex]) {
                //若是后一个元素小于前面的元素，则将前面的元素依次向后移一位
                a[preIndex + 1] = a[preIndex];
                preIndex--;//-1 不满足循环条件 执行下面语句
            }
            //将小的元素插入到0号位置
            //preIndex=-1  +  1 =0
            a[preIndex + 1] = currentValue;
        }
        System.out.println(Arrays.toString(a));
    }
}

疯子在辉

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaSE第三章

JavaSE第三章文章目录JavaSE第三章数组的基本概念及作用数组的声明与创建数组的访问与迭代第一种：for循环第二种：增强for循环数组排序冒泡排序选择排序插入排序数组的基本概念及作用数组是相同数据类型元素的集合数组本身是引用数据类型，即对象。但是数组可以存储基本数据类型，也可以存储引用数据类型。总结： Java数组：存储一组相同类型的数据数组是一个连续的存储空间，当数组的长度一旦确定，就不能改变了。数组属于引用数据类型（也可以说数组属于对象）数据可以存储
复制链接

扫一扫

专栏目录