1.数组
1.数组的基本概念及作用
数组的基本概念及作用
数组是相同数据类型元素的集合
数组本身是引用数据类型，即对象。但是数组可以存储基本数据类型，也可以存储引用数据类型。
数组，是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按无序的形式组织起来的一种形式。这些无序排列的同类数据元素的集合称为数组。
2.数组的创建
1.声明
int[] ary0 = new int[10];
int[] ary1 = new int[]{1, 2, 3, 4, 5};
int[] ary2 = {1, 2, 3, 4, 5};
注：数组创建以后长度无法改变
2.数组类型
1.动态创建数组
没有为元素赋值，可以结合for循环进行赋值
2.静态创建数组
在创建的时候，即为每个元素赋初值
注：length属性可以获取数组长度
3.数组元素的访问
数组名字[下标] 例如：a[0],a[1]
注：数组的下标从0开始。例如：int []a=new int [10];//创建一个可以存放10个整形元素的数组。它的元素位置为：a[0],a[1],a[2],a[3],…a[9]。
1.利用for循环访问。
int []a=new int[10];
for(i=0;i<a.length;i++)
{
System.out.println(a[i]);
}
2.增强for循环
int []a=new int[10];
for(int temp:a)
{
System.out.println(x);
}
2.排序
1.冒泡排序
冒泡排序重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。
这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。
-
冒泡排序的特点：
总趟数是数组的长度减一。
每比较一趟，下一趟就少比较一次。
-
代码实现：
/*
* 冒泡排序
* 大的下沉，小的冒起来
* 比较趟数比数组的长度减一
* 每比完一次，就少比较一次
* */
public class BubbleSort {
public static void sort(int [] a){
for (int i = 0; i < a.length-1; i++) {// 趟数
for (int j = 0; j <a.length-i-1; j++) {// a.lenrth-i-1 ,意为每比较一趟之后少比较一个，
// 并且第一次比较的次数就比数组长度小一
int temp;// 临时变量 ，暂时存储元素。
if(a[j]>a[j+1]){
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
}
public static void main(String[] args) {
int [] a = {54,123,23,113,5,35,1};
// 54，23，113，5，35，1，123
// 23，54，5，35，1，113，123
// 23，5，35，1，54，113，123
// 5，23，1，35，54，113，123
// 5，1，23，35，54，113，123
// 1，5，23，35，54，113，123
BubbleSort.sort(a);// 引用类型传递
System.out.println(Arrays.toString(a));//这里输出的a和Array指向的是同一个引用，
// 所以方法中的内容改变会影响到外面的对象引用
}
}
2.选择排序
选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。
-
原理：用一个元素与后面所有的元素比较，若最小则不变，若不是，则交换位置，之后继续用"新"的最小的与后面尚未比较的一一比较，比完之后，这是一次比较的完成。找出最大的同理。
-
两种方式
第一种：每当在剩余元素中找到更小（大）的元素时，直接交换然后继续比较。
第二种：在剩余元素中找到更小（大）的元素时，先记录下来，然后用记录下来的元素继续与后面的元素相比较。
-
代码实现
第一种方式：
/* * 选择排序 * */ public class SelectSort { public static void sort(int [] a){ //找到就交换 for (int i = 0; i < a.length-1; i++) {// 趟数还是数组长度减一 for (int j = i+1; j < a.length; j++) {// 这里只需要第一个和后面的每一个排序， // 所以j=i+1,j<a.length,意为后面的每一个都遍历到了 if(a[i]>a[j]){// 这样是每次符合条件，都需要交换一次 int temp = a[i]; a[i] = a[j]; a[j] = temp; } } } } public static void main(String[] args) { int [] a = {7,5,9,1,3}; // 1，7，9，5，3 // 1，3，9，7，5 // 1，3，5，9，7 // 1，3，5，7，9 SelectSort.sort(a); System.out.println(Arrays.toString(a)); } }第二种方式：
/* * 选择排序 * */ public class SelectSort { public static void sort1(int [] a){ // 找到后记录再交换 int minindex;// 加了一个变量，可以记录目前最小的元素的下标 for (int i = 0; i < a.length-1; i++) {// 趟数比数组长度少一 minindex = i; for (int j = i+1; j <a.length ; j++) { if(a[minindex]>a[j]){ minindex = j; } } // 在内层循环找出最小的元素的下标之后，再在外层循环里面进行一次交换。 int temp1 = a[i]; a[i] = a[minindex]; a[minindex] = temp1; } } public static void main(String[] args) { int [] a = {7,5,9,1,3}; // 1，7，9，5，3 // 1，3，9，7，5 // 1，3，5，9，7 // 1，3，5，7，9; SelectSort.sort1(a); System.out.println(Arrays.toString(a)); } }
3.插入排序
插入排序，一般也被称为直接插入排序。对于少量元素的排序，它是一个有效的算法。插入排序是一种最简单的排序方法，它的基本思想是将一个记录插入到已经排好序的有序表中，从而一个新的、记录数增1的有序表。在其实现过程使用双层循环，外层循环对除了第一个元素之外的所有元素，内层循环对当前元素前面有序表进行待插入位置查找，并进行移动。
插入排序就像我们玩扑克牌。开始时，我们的左手为空并且桌子上的牌面向下。然后，我们每次从桌子上拿走一张牌并将它插入左手中正确的位置。为了找到一张牌的正确位置，我们从右到左将它与已在手中的每张牌进行比较。拿在左手上的牌总是排序好的。
- 原理：假定前面都是排好序的，现在要往其中插入一个数，但是为了保持之后仍是排好序的。因此，这个要插入的数需要与前面的每一个比较，直到找到自己的位置。反复执行，直到找到全部排好。
注：需要注意保存需要插入的元素的值，和已经排好序的紧挨的元素的下标，因为这个下标是后面用来判断下标合法范围的
-
代码实现:
/* * 插入排序 * */ public class InsertSort { public static void sort(int [] a){ for (int i=0; i < a.length-1; i++) { /* 这里只需要走过一遍数组就可以完成排序。 所以这里的 a.length-1 约束的是下标，而非趟数。*/ int current = a[i+1];/* 使用current变量存储a[i+1]的值，这里只能存储值，如果存储下标的话， 在for循环中会改变当前下标的值，导致值丢失。*/ int perindex = i; /* 使用perindex变量存储啊a[i]的下标 i ，这里不存储值是为了， 后面判断索引合法范围的时候需要使用。*/ while(perindex>=0 && a[perindex]>current){/* 假设目前用3进行比较，3的值被存储在current中，是隐式的， 但是是一直在用3和前面的比较，直到找到位置。*/ a[perindex+1] = a[perindex];// 用两者中的前一个将后面的覆盖 perindex--;// 光标前移，继续比较 } a[perindex+1] = current;// 这里的加一是因为上面的for循环多减了一个一，因此需要加一，返回到正确的位置。 } } // 这个是使用for循环来实现的 public static void sort1(int [] a){ for (int i = 0; i < a.length-1; i++) { int current1 =a[i]; int j=i-1; for ( ; j>0 && a[j]>a[i]; j--) { a[i] = a[j]; } a[j+1] =current1; } } public static void main(String[] args) { int [] a = {2,4,1,3,7,0}; // 2,4,1 // 2,4,4 // 2,2,4 // 1,2,4,3,7 // 1,2,4,4(3),7 // 1,2,3,4,7 InsertSort.sort(a); System.out.println(Arrays.toString(a)); InsertSort.sort1(a); System.out.println(Arrays.toString(a)); } }
3.二维数组
1.二维数组的定义
二维数组的中的元素都是数组。
2.二维数组的声明
int [][]a;（建议使用）int a2[][];
3.二维数组的创建
int [][]a = new int[][]{{1,2,3},{1,2,3},{1,2,3}};
int [] [] b = {{1,2,3},{1,2,3},{1,2,3}};
int [][] c = new int[3][5];
- 二维数组的迭代：
public class TwoDimensionalArray {
public static void main(String[] args) {
int [][]a=new int[][]{{1,2},{3,4}};
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
System.out.print(a[i][j]);
}
}
}
}
255
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
