5、数组

最新推荐文章于 2022-12-11 00:17:54 发布

knight啊

最新推荐文章于 2022-12-11 00:17:54 发布

阅读量124

点赞数

分类专栏：小白入门到精通文章标签：算法 java 数组

本文链接：https://blog.csdn.net/weixin_51633983/article/details/109731385

版权

小白入门到精通专栏收录该内容

7 篇文章 0 订阅

订阅专栏

数组

概念

用于存储具有相同数据类型的容器称之为数组，可以使用统一的标识符（变量名进行管理）

数据既可以存储基本数据类型也可以存储引用数据类型=》可以存储任意类型的数据

数组的使用

①声明

	//### ①声明
	//与变量声明类似，在相应位置声明一个变量用于存储指定数据地址
	//声明语法有两种
	//1)数组保存数据的数据类型  [] 数组名;
	//声明一个保存int整数类型的数组名为scores1
		int [] scores1;
	//2)数组保存数据的数据类型 数组名[];
	//声明一个保存int整数类型的名为scores2的数组
		int scores2 [];
	//[]表示当前声明数组用于与变量进行区分

②创建

	//### ②创建
	//创建的过程就是初始化的过程，创建数组对象并进行初始化赋值
	//1)动态初始化
	//就是在创建时指定数组长度并为所有数据赋初始值
	//创建一个新的用于存储int整数类型的长度为10的数组并进行初始化赋值之后赋值给已经声明好的数组变量
	scores1=new int[5];
	//通常将声明与创建一同进行
	int[] scores3=new int[5];
	//动态初始化后存储的数据为默认值   [0,0,0,0,0]

	//2)静态初始化
	//在创建数组时不指定长度，而是将所有数据赋值填入使用这些数据创建数组
	//创建时所有数据以{}包裹数据与数据之间使用,分隔
	//静态创建需要与声明一同进行
	int [] scores4={1,2,3,4,5};
	//在静态创建过程中创建数组存储对象数据类型从声明与存储的数据中进行获取
	//静态初始化后存储的数据为指定值[1,2,3,4,5]

③赋值

	//### ③赋值
	//无论是静态初始化还是动态初始化进行赋值的语法都是一样的
	//在数组中通过一个变量名（数组名）进行所有数据的存储，没有像对象一样的属性名
	//但是在进行存储时放入的顺序是固定，所以进行赋值时，使用索引（下标）进行管理
	//语法：
	//数组名[索引]=值;
	//数组索引从0开始到存储数据长度-1

④使用

	//### ④使用
	//使用与赋值语法相同
	//语法:
	//数组名[索引]进行获取指定数组中指定索引的数据
	
	//数组额外提供了一个公开的属性length用于快速获取当前数组可以存储数据的个数
	System.out.println(scores4.length);

总结：

1.数组只能存储同一数据类型数据

2.数据可以存储任意类型数据

3.创建数组时声明数据类型与创建数据类型必须匹配

4.创建数组时必须指定数据类型与长度

5.数组存储数据的个数由创建时长度确定（创建时就讲数组存满）而且不能更改

6.索引范围为0~length-1

数组的内存形式

数组存储数据的形式类似于格子,每个格子位置固定索引固定，在使用时为格子依次赋值

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WdlXWTOS-1605535827524)(F:\teacher\笔记\img\image-20201015114916959.png)]$

JAVA中的内存分配

Java 程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
栈存储局部变量
堆存储new出来的东西
方法区 (面向对象部分重点讲)
本地方法区 (和系统相关)
寄存器 (给CPU使用)

在java中是否有寄存器存在争议，即使存在也不是我们使用而是在程序运行过程中由jvm进行分配

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7Nr4ZI1q-1605535827526)(img\image-20201015111916099.png)]$

多维数组

在java中其实没有多维数组的概念，只不过是依据数组的概念以及特点技术上的延伸

本质上就是存储数组的数组

多维的数组的使用

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HqQ464Wv-1605536074307)(F:\teacher\笔记\img\image-20201016101021268.png)]$

①声明

		// ### ①声明
		// 1)数据类型 [][] 数组名;
		// 创建一个存储整数类型数组 的 数组 名为arr1
		int[][] arr1;
		// 2)数据类型 数组名[][]
		// 创建一个存储整数类型数据的 名为arr2 的数组中存储数组
		int arr2[][];

②创建

		// ### ②创建
		// 1)动态创建
		// 多维数组创建与普通数组不同的是，普通数组创建时必须指定长度
		// 多维数组也是必须指定长度，但是可以先不指定里层数组长度
		// 多维数组就是将原来存储数据的块改为存储数组
		// 前面的长度必填，代表当前数组存储数据的个数
		// 后面的长度可以先不填，但是在使用时必须创建相应长度数组存储，代表存储的数组可以存储数据的个数
		arr1 = new int[3][4];
		// {0,0,0,0}
		// {0,0,0,0}
		// {0,0,0,0}

		// 2)静态创建
		int arr3[][] = { { 1, 2, 3, 4 }, { 4, 5, 6, 7 }, { 7, 8, 9, 10 } };
		// 不论是静态创建还是动态创建每块保存数组的长度可以不同
		int arr4[][] = { { 1 }, { 4, 5 }, { 7, 8, 9 } };

③赋值

// ### ③赋值
		// 数组赋值只有一种通过数组名[下标]的形式进行赋值
		arr3[0] = new int[1];// 注意现在存储的数据为数组那么赋值的数据也应该为数组
		// 对于多维数组通常使用两个索引进行数据的定位数组名[行][列]
		arr3[1][2] = 2;
		System.out.println(arr3[1][2]);

④使用

		// ### ④使用
		// 与赋值相同
		// 本质上使用与一维数组一样，但是由于其存储数据的形式与一维数组不同所以语法上也存在不同
		// 数组名[取出数据所在数组索引索引][取出数据在其数组索引]

		int [] a=new int[2];
		int [][] b=new int[2][2];

排序算法

算法:

算法可以理解为完成某一需求的过程（最简洁）

完成需求的思路

1、冒泡排序算法

将指定的数据通过交换依次向后输送

演示：

在这里插入图片描述

	// 冒泡排序
	public static void main(String[] args) {
		int[] arr = { 3, 7, 6, 2, 4, 1, 8, 9, 5 };
		// 将数据两两比较（当前位与后一位比较）
		// 如果后一位较大则交换依次进行

		// arr[0]=>arr[1];
		// arr[1]=>arr[2];
		// arr[2]=>arr[3];
		// arr[i]=>arr[i+1];
		// 当比较到最后一位时i+1会越界 所以i的范围应为0~最大索引-1
		for (int i = 0; i < arr.length - 1 - 1; i++) {
			if (arr[i] > arr[i + 1]) {
				int tmp = arr[i];
				arr[i] = arr[i + 1];
				arr[i + 1] = tmp;
			}
		}
		// 执行一轮只能确定一位最值 根据长度需要执行length-1次
		for (int j = 0; j < arr.length - 1; j++) {
			for (int i = 0; i < arr.length - 1 - 1; i++) {
				if (arr[i] > arr[i + 1]) {
					int tmp = arr[i];
					arr[i] = arr[i + 1];
					arr[i + 1] = tmp;
				}
			}
		}
		// 在内存进行判断时每次都会判断到最后但每次执行最后已经判断过的最值不应该继续判断
		// 每次判断时应将内层条件 随着外层修改而修改 修改范围应为arr.length - 1 - 1-j（外层循环次数）
		// 外层每每循环一次就会确定一个最值 那么在内层判断时就可以少判断一个
		for (int j = 0; j < arr.length - 1; j++) {
			for (int i = 0; i < arr.length - 1 - 1 - j; i++) {
				if (arr[i] > arr[i + 1]) {
					int tmp = arr[i];
					arr[i] = arr[i + 1];
					arr[i + 1] = tmp;
				}
			}
		}

		// for (int j = 0; j < arr.length - 1; j++) {
		// for (int i = 0; i < arr.length - 1 - j; i++) {
		// if (arr[i] > arr[i + 1]) {
		// int tmp = arr[i];
		// arr[i] = arr[i + 1];
		// arr[i + 1] = tmp;
		// }
		// }
		// }

		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
	}

2、选择排序（Selection Sort）

表现最稳定的排序算法之一，因为无论什么数据进去都是O(n2)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法了吧。

选择排序(Selection-sort)是一种简单直观的排序算法。
工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

2.1 算法描述

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

初始状态：无序区为R[1…n]，有序区为空；
第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
n-1趟结束，数组有序化了。

动图演示：
在这里插入图片描述

代码的实现：

/**
     * 选择排序
     * @param array
     * @return
     */
    public static int[] selectionSort(int[] array) {
        if (array.length == 0)
            return array;
        for (int i = 0; i < array.length; i++) {
            int minIndex = i;
            for (int j = i; j < array.length; j++) {
                if (array[j] < array[minIndex]) //找到最小的数
                    minIndex = j; //将最小数的索引保存
            }
            int temp = array[minIndex];
            array[minIndex] = array[i];
            array[i] = temp;
        }
        return array;
}

3、插入排序（Insertion Sort）
插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

3.1 算法描述

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

从第一个元素开始，该元素可以认为已经被排序；
取出下一个元素，在已经排序的元素序列中从后向前扫描；
如果该元素（已排序）大于新元素，将该元素移到下一位置；
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
将新元素插入到该位置后；
重复步骤2~5。

3.2 动图演示

在这里插入图片描述
3.2 代码实现

/**
     * 插入排序
     * @param array
     * @return
     */
    public static int[] insertionSort(int[] array) {
        if (array.length == 0)
            return array;
        int current;
        for (int i = 0; i < array.length - 1; i++) {
            current = array[i + 1];
            int preIndex = i;
            while (preIndex >= 0 && current < array[preIndex]) {
                array[preIndex + 1] = array[preIndex];
                preIndex--;
            }
            array[preIndex + 1] = current;
        }
        return array;
}

4、归并排序（Merge Sort）
和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(n log n）的时间复杂度。代价是需要额外的内存空间。

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

4.1 算法描述

把长度为n的输入序列分成两个长度为n/2的子序列；
对这两个子序列分别采用归并排序；
将两个排序好的子序列合并成一个最终的排序序列。

4.2 动图演示

在这里插入图片描述
4.3 代码实现

/**
* 归并排序
*
* @param array
* @return
*/
public static int[] MergeSort(int[] array) {
if (array.length < 2) return array;
int mid = array.length / 2;
int[] left = Arrays.copyOfRange(array, 0, mid);
int[] right = Arrays.copyOfRange(array, mid, array.length);
return merge(MergeSort(left), MergeSort(right));
}

    /**
     * 归并排序——将两段排序好的数组结合成一个排序数组
     *
     * @param left
     * @param right
     * @return
     */
    public static int[] merge(int[] left, int[] right) {
        int[] result = new int[left.length + right.length];
        for (int index = 0, i = 0, j = 0; index < result.length; index++) {
            if (i >= left.length)
                result[index] = right[j++];
            else if (j >= right.length)
                result[index] = left[i++];
            else if (left[i] > right[j])
                result[index] = right[j++];
            else
                result[index] = left[i++];
        }
        return result;
}

5、快速排序（Quick Sort）

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

5.1 算法描述

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

从数列中挑出一个元素，称为 “基准”（pivot）；
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

5.2 动图演示

在这里插入图片描述
5.3 代码实现

/**
     * 快速排序方法
     * @param array
     * @param start
     * @param end
     * @return
     */
    public static int[] QuickSort(int[] array, int start, int end) {
        if (array.length < 1 || start < 0 || end >= array.length || start > end) return null;
        int smallIndex = partition(array, start, end);
        if (smallIndex > start)
            QuickSort(array, start, smallIndex - 1);
        if (smallIndex < end)
            QuickSort(array, smallIndex + 1, end);
        return array;
    }
    /**
     * 快速排序算法——partition
     * @param array
     * @param start
     * @param end
     * @return
     */
    public static int partition(int[] array, int start, int end) {
        int pivot = (int) (start + Math.random() * (end - start + 1));
        int smallIndex = start - 1;
        swap(array, pivot, end);
        for (int i = start; i <= end; i++)
            if (array[i] <= array[end]) {
                smallIndex++;
                if (i > smallIndex)
                    swap(array, i, smallIndex);
            }
        return smallIndex;
    }
 
    /**
     * 交换数组内两个元素
     * @param array
     * @param i
     * @param j
     */
    public static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
}

knight啊

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
5、数组

数组概念用于存储具有相同数据类型的容器称之为数组，可以使用统一的标识符（变量名进行管理）数据既可以存储基本数据类型也可以存储引用数据类型=》可以存储任意类型的数据数组的使用①声明 //### ①声明 //与变量声明类似，在相应位置声明一个变量用于存储指定数据地址 //声明语法有两种 //1)数组保存数据的数据类型 [] 数组名; //声明一个保存int整数类型的数组名为scores1 int [] scores1; //2)数组保存数据的数据类型数组名[]; //声明一个保存
复制链接

扫一扫