第十课 数组

1.数组：多个相同类型数据的组合

          引用类型：类 数组 和 接口

     1)声明  int[]  var       或者  int var[] 建议大家使用第一种

     2)初始化   数组下标从0开始

        (1)  int[] arr1={1,2,3,4};
     
       (2) int[] arr2=new int[5];
          arr2[0]=1;
          arr2[1]=2;
          arr2[2]=3

        (3)
                              //对象数组
         Person[] arrPerson=new Person[3];
         arrPerson[0]=new Person("ddd");
         arrPerson[1]=new Person("ddd");
         arrPerson[2]=new Person("ddd");

       数组是引用类型 数组里的每一个元素相当于成员变量 所以数组初始化的时候
       和成员变量初始化是一样的(例如 int 默认0  引用类型 默认
       null  boolean 默认 false)
   3)数组 length属性 取数组长度

     循环遍历数组的每一个元素
   int[] after={1,30,8,2,200,5,100,7,6};

   for(int i=0;i<after.length;i++){
   System.out.println(after[i]);
  }

  4)数组的排序

      1)冒泡排序：/每次比较相邻的两个数 让最大的那个数排到第二个循环的末尾

            public int[] bubbleSort(int before[])
            {
                int t;
                for (int i=0;i<before.length;i++)
                 {
                   for(int j=0;j<before.length-i-1;j++)
                    {
                      if (before[j]>before[j+1])
                      {
                        t=before[j];
                        before[j]=before[j+1];
                         before[j+1]=t;
                      }
                    }
                }
               return before;
             }
        2)jdk api 提供的排序方法

            Arrays.sort(数组)

  5)二位数组

     初始化：

            1)静态初始化

                    int [][]  arr3 = {{1,2},{3,4},{5,6}};//正确
                    int [3][2]  arr3 = {{1,2},{3,4},{5,6}};//非法的

            2)动态初始化

                   int[][] arr4=new int[3][];//正确
            int[][] arr5=new int[3][5];//正确
            int[][] arr6=new int[][5];//非法的

            3)循环遍历二位数组
      for(int i=0;i<arr3.length;i++){
      for(int j=0;j<arr3[i].length;j++){
       System.out.println("arr3["+i+"]["+j+"]="+arr3[i][j]);
      }
      }

2.其它排序方式

        1）插入排序

//将数组分成两个小数组,每次从后面的数组中取出索引最小的数组元素,插入到前面
//的适当位置,使得插入到前面的数组后,它前面的数组元素都比它小,而后面都比它大
//{ 2, 1, 5, 876, 12, 56 }
public class InjectionSort {
 // 插入排序方法
 public static void injectionSort(int[] number) {
  // 第一个元素作为一部分，对后面的部分进行循环
  for (int j = 1; j < number.length; j++) {
   int tmp = number[j];
   int i = j - 1;
   //当前位置j之前比number[j] 还小的数
   while (tmp < number[i]) {
    number[i + 1] = number[i];
    i--;
    if (i == -1)
     break;
   }
   number[i + 1] = tmp;
  }
 }
 public static void main(String[] args) {
  int[] num = { 2, 1, 5, 876, 12, 56 };
  injectionSort(num);
  for (int i = 0; i < num.length; i++) {
   System.out.println(num[i]);
  }
 }
}

     2）选择排序

// 将要排序的数组分成两部分:一部分是从小到大排好序的,一部分是无序的,从无序的部分取出
//最小的数值 放到已排好序的部分的最后
//{7 8 9 6 5}
public class SelectionSort {
 // 选择排序方法
 public static void selectionSort(int[] number) {
  for (int i = 0; i < number.length - 1; i++) {
   int m = i;
   //找到number[i]之后的最小的数
   for (int j = i + 1; j < number.length; j++) {
    
    if (number[j] < number[m])
     //说明number[j]小于number[m]  这样把j给m说明了 想看看有没有比number[j]更小的数了
     m = j;
   }
   //分i==m 说明 number[i]以后没有比number[i]更小的数了
   if (i != m)
    swap(number, i, m);
  }
 }
 // 用于交换数组中的索引为i、j的元素
 private static void swap(int[] number, int i, int j) {
  int t;
  t = number[i];
  number[i] = number[j];
  number[j] = t;
 }
 public static void main(String[] args) {
  // 定义一个数组
  int[] num = { 2, 1, 5, 876, 12, 56 };
  // 排序
  selectionSort(num);
  for (int i = 0; i < num.length; i++) {
   System.out.println(num[i]);
  }
 }
}

    3）快速排序

//将一个大的数组的排序问题,分解成两个小的数组的排序.而每一个小的数组的排序又可以继续分解成更小的两个数组
//这样这个数组的排序方式可以一直的递归分解下去 直到数组的大小为2
public class QuickSort {
 // 排序方法，接受一个int[]参数，将会调用快速排序方法进行排序
 public static void sort(int[] number) {
  quickSort(number, 0, number.length - 1);
 }
 // 快速排序方法
 private static void quickSort(int[] number, int left, int right) {
  if (left < right) {
   int s = number[left];
   int i = left;
   int j = right + 1;
   while (true) {
    // 向右找大于s的数的索引
    while (i + 1 < number.length && number[++i] < s)
     ;
    // 向左找小于s的数的索引
    while (j - 1 > -1 && number[--j] > s)
     ;
    // 如果i>=j，退出循环
    if (i >= j)
     break;
    // 否则交换索引i和j的元素
    swap(number, i, j);
   }
   number[left] = number[j];
   number[j] = s;
   // 对左边进行递归
   quickSort(number, left, j - 1);
   // 对右边进行递归
   quickSort(number, j + 1, right);
  }
 }
 // 交换数组number中的索引为i、j的元素
 private static void swap(int[] number, int i, int j) {
  int t;
  t = number[i];
  number[i] = number[j];
  number[j] = t;
 }
 public static void main(String[] args) {
  int[] num = { 34, 1, 23, 345, 12, 546, 131, 54, 78, 6543, 321, 85,
    1234, 7, 76, 234 };
  sort(num);
  for (int i = 0; i < num.length; i++) {
   System.out.println(num[i]);
  }
 }
}

 

3.用数组模拟栈（stack）

public class MyStack {
 private int capacity = 100;
 private String[] items;
 private int top = 0;
 // 不带参数构造器
 public MyStack() {
  this(100);
 }
 // 带参数构造器，参数为堆栈大小
 public MyStack(int cap) {
  this.capacity = cap;
  items = new String[cap];
 }
 // 压栈
 public void push(String s) {
  top++;
  items[top] = s;
 }
 // 出栈
 public void pop() {
  items[top] = null;
  top--;
 }
//  获得堆栈元素个数
 public int size() {
  return top;
 }
 // 清空堆栈
 public void empty() {
  top = 0;
 }
 // 取出最顶端的堆栈元素
 public String top() {
  return items[top];
 } 
}