程序入门之一维数组

BiuBiuBiu---子默

于 2022-11-22 10:55:49 发布

阅读量569

点赞数

分类专栏： Java 文章标签：算法数据结构 java 排序算法

本文链接：https://blog.csdn.net/m0_45851263/article/details/127927997

版权

Java 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一、数组的基本概念

数组就是若干个相同数据类型的元素按照一定顺序排列的集合。

二、一维数组

2.1 一维数组的定义

三步骤：

数据类型【】数组名； //声明数组

数组名 = new 数据类型【个数】； //分配空间；

数组名【下标】 = num；····· //创建数组元素并赋值

int[] arr;
arr = new int [3];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;

2.1.1 动态初始化

数据类型【】数组名 = new 数据类型【个数】；

数据类型数组名【】 = new 数据类型【个数】；

int[] arr = new int[3];
int num[] = new int[3];

2.2.2 静态初始化

数据类型【】数组名 = new 数据类型【】{元素1，元素2，元素三....}；

int[] arr = new int[5]{1,2,3,4,5};

2.2.3 静态初始化省略格式

数据类型【】数组名={元素1，元素2，元素3....}；

int[] arr = {1,3,5,7,9};

三、数组的访问

3.1 索引

每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号就称作数组索引（index）。可以通过数组的索引访问到数组中的元素。

3.1.1 数组元素的引用方式

数组名【索引】

3.1.2 数组的长度属性

每个数组都具有长度，并且是固定的；

语句格式：数组名.length

public static void main(String[] args) {
	 int[] arr = new int[]{1,2,3,4,5,6,7,8,9,10}; 
	 //打印数组的属性，输出结果是10
	  System.out.println(arr.length);
}

3.1.3 通过索引访问数组中的元素

public static void main(String[] args) {
 //定义存储int类型数组，赋值元素1，2，3，4，5 
 int[] arr = {1,2,3,4,5};
  //为0索引元素赋值为6 
  arr[0] = 6; 
  //获取数组0索引上的元素 
  int i = arr[0]; 
  System.out.println(i); 
  //直接输出数组0索引元素 
  System.out.println(arr[0]); 
}

四、一维数组的操作以及算法

4.1 数组的遍历

4.1.1 数组遍历

就是将数组中的每个元素分别获取出来

public static void main(String[] args) {
	 int[] arr = { 1, 2, 3, 4, 5 }; 
	 System.out.println(arr[0]); 
	 System.out.println(arr[1]); 
	 System.out.println(arr[2]); 
	 System.out.println(arr[3]); 
	 System.out.println(arr[4]);
 }

4.1.2 for循环遍历

public static void main(String[] args) { 
 int[] arr = { 1, 2, 3, 4, 5 }; 
 for (int i = 0; i < arr.length; i++) { 
 System.out.println(arr[i]); 
	}
}

4.1.3 for-each循环遍历

public static void main(String[] args) { 
 int[] arr = { 1, 2, 3, 4, 5 }; 
 for (int i : arr) { 
 System.out.println(i); 
	}
}

4.2 求最值

4.2.1 求最大值

/**
 * 求最大值
 */
public class Test2 {
    public static void main(String[] args) {
        int arr[] = new  int[]{25,12,51,30,20};
        //求最大值
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(max < arr[i]) {
                max = arr[i];
            }
        }
        System.out.println("该数组中最大值："+max);

    }
}

4.2.2 求最小值

/**
 * 求最小值
 */
public class Test2 {
    public static void main(String[] args) {
        int arr[] = new  int[]{25,12,51,30,20};
        //求最小值
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(min > arr[i]){
                min = arr[i];
            }
        }
        System.out.println("该数组中最小值："+min);
    }
}

4.3 插入

/**
 * 插入
 * 把 15 插入{5,10,20,25,30,35} 中
 */
public class Test3 {
    public static void main(String[] args) {
        //定义要插入的数组，数组的长度要大于数据的个数，否则插入时会溢出
        int arr[] = new int[]{5,10,20,25,30,35,0};
        //要插入的数字
        int num = 15;
        //要插入位置的变量
        int count = -1;
        for (int i = 0; i < 6; i++) {
            if(arr[i] > num){
                count = i;
                //找到要插入的位置
                break;
            }
            //如果break没有执行过
            if(count == -1){
                count = arr.length-1;
            }
        }
        System.out.println("要插入的位置：" + count);
        //需要移动的位置
        for (int i = 6; i > count; i--) {
            arr[i] = arr[i-1];
        }
        //插入数据
        arr[count] = num;
        //查看是否插入正确位置
        for (int temp:arr) {
            System.out.print(temp+"\t");
        }
    }
}

4.4 删除

/**
 * 删除
 * 从{5,10,15,20,25,30,35} 中删除某一个元素
 */
public class Test4 {
    public static void main(String[] args) {
        int arr[] = new int[]{5,10,15,20,25,30,35};
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入你要删除的元素：");
        //要删除的元素
        int num = scanner.nextInt();
        //记录要删除元素的下标
        int count = -1;
        //找到要删除的位置
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]==num){
                count = i;
                break;
            }
        }
        if(count == -1){
            System.out.println("没有这个元素!");
            return;
        }
        System.out.println("要删除的位置：" + count);
        //删除数据
        for (int i = count; i < arr.length-1; i++) {
            arr[i] = arr[i+1];
        }
        //显示删除后的数组
        for (int i = 0; i < arr.length-1; i++) {
            System.out.print(arr[i]+"\t");
        }
    }
}

4.5 查找

4.5.1 顺序查找

import java.util.Scanner;

/**
 * 顺序查找
 */
public class Test1 {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = new int[]{1,3,5,7,9,11,13,17,19,23};
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入你要查找的元素：");
        int num = scanner.nextInt();
        int index = -1;   //用来记录元素所在的下标
        for (int i = 0; i < arr.length; i++) {
            if (num == arr[i]){
                index = i;
                System.out.println("找到了！");
                System.out.println("这个元素所在的下标是:"+index);
            }
        }
        if (index==-1){
            System.out.println("没有找到！");
        }
    }
}

4.5.2 二分查找

import java.util.Scanner;

/**
 * 二分查找
 */
public class Test5 {
    public static void main(String[] args) {
        int[] arr = {1,3,5,7,11,13,17,19,23,31,37};
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入你要查找的数据：");
        //要查找的数据
        int find = scanner.nextInt();
        //定义边界
        int low,high,mid;
        low = 0;
        high = arr.length-1;
        boolean bool = false;

        while (low <= high) {
            mid = (low+high)/2;
            if(find >arr[mid]){
                low = mid+1;
            }else if (find < arr[mid]){
                high = mid-1;
            }else{
                System.out.println("找到了："+arr[mid]);
                bool = true;
                break;
            }
        }
        if(!bool){
            System.out.println("没有找到！");
        }
    }
}

4.6 排序

4.6.1 冒泡排序

/**
 * 冒泡排序
 */
public class Test6 {
    public static void main(String[] args) {
        int arr[] = {3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};

        //控制轮数
        for (int i = 0; i < arr.length-1; i++) {
            //控制每轮的次数
            for (int j = 0; j < arr.length-1; j++) {
                //交换位置
                if (arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        for (int a:arr) {
            System.out.print(a+"\t");
        }
    }
}

/**
 * 冒泡排序优化
 */
public class Test7 {
    public static void main(String[] args) {
        int arr[] = {3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};

        //控制轮数
        for (int i = 0; i < arr.length - 1; i++) {

            boolean bool = false;
            //控制每轮的次数
            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;
                    bool = true;
                }
            }
            //提前排好了就退出循环
            if (!bool) {
                System.out.println("该数组已排好序了！");
                break;
            }
        }
            for (int a : arr) {
                System.out.print(a + "\t");
            }

    }
}

4.6.2 插入排序

/**
 * 插入排序
 */
public class Test9 {
    public static void main(String[] args) {
        int[] arr = {3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};

        //控制无序区的每个数都要进行插入
        for (int i = 1; i < arr.length ; i++) {

            //从无序区中找出来要插入的数
            int data = arr[i];

            //打印有序区的数据
            System.out.println("**************有序区数据*****************");
            for (int j = 0; j <i ; j++) {
                System.out.print(arr[j]+"\t");
            }
            System.out.println();

            //找到的要插入的位置
            int position = i;
            //从有序区中一个个的去寻找插入位置
            for (int j = 0; j < i ; j++) {
                if(data < arr[j]){
                    //找到了位置
                    position = j;
                    break;
                }
            }

            //打印要插入的数以及位置
            System.out.printf("要插入的数以及位置，%d, %d", arr[i], position);
            System.out.println();

            //移动
            for (int j = i-1; j >=position ; j--) {
                arr[j+1] = arr[j];
            }

            arr[position] = data;

            //打印要插入的数以及位置
            System.out.println("**************有序区数据*****************");
            for (int j = 0; j <i+1 ; j++) {
                System.out.print(arr[j]+"\t");
            }
            System.out.println();

        }

        for (int temp:arr) {
            System.out.print(temp+"\t");
        }
    }
}

4.6.3 选择排序

/**
 * 选择排序
 */
public class Test10 {
    public static void main(String[] args) {
        int[] arr={3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
        for (int i = 0; i < arr.length-1; i++) {
            int index=i;//标记第一个为待比较的数
            for (int j = i+1; j < arr.length; j++) { //然后从后面遍历与第一个数比较
                if (arr[j]<arr[index]) {  //如果小,就交换最小值
                    index=j;//保存最小元素的下标
                }
            }
            //找到最小值后，将最小的值放到第一的位置，进行下一遍循环
            int temp=arr[index];
            arr[index]=arr[i];
            arr[i]=temp;
        }
        for (int temp:arr) {
            System.out.print(temp+"\t");
        }
    }
}