数组和链表

数组和链表

1.链表

1.1链表是什么

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：
	一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 
相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，
但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。

使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。
但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。
链表最明显的好处就是，常规数组排列关联项目的方式可能不同于这些数据项目在记忆体或磁盘上顺序
，数据的存取往往要在不同的排列顺序中转换。
链表允许插入和移除表上任意位置上的节点，但是不允许随机存取。
链表有很多种不同的类型：单向链表，双向链表以及循环链表。链表可以在多种编程语言中实现。
像Lisp和Scheme这样的语言的内建数据类型中就包含了链表的存取和操作。程序语言或面向对象语言，如C,C++和Java依靠易变工具来生成链表

分类：
1.单向链表

2.双向链表

3.循环链表

1.2、链表的特点

获取数据麻烦，需要遍历查找，比数组慢
方便插入、删除

1.3如何使用链表

创建一个节点类
其中节点类包含两个部分
第一个是数据域（你到时候要往节点里面储存的信息），第二个是引用域（相当于指针，单向链表有一个指针，指向下一个节点；双向链表有两个指针，分别指向下一个和上一个节点）
创建一个链表类
其中链表类包含三个属性：头结点、尾节点和大小，方法包含添加、删除、插入等等方法。

单向链表的节点类：

public class Node {
     public Object data;
     public Node next;
    
     public Node(Object e){
         this.data = e;
     }
 }

双向链表的节点类：

public class Node {
       public Object e;
       public Node next;
       public Node pre;
      public Node(){
   
      }
       public Node(Object e){
          this.e = e;
          next = null;
          pre = null;
      }
  }

1.4Java如何使用链表：

package com.wyw;

import java.util.LinkedList;

/**
 * @author Administrator
 */
public class LinkedTest {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        // 添加元素
        list.add(1);
        list.add(2);
        list.add(3);

        System.out.println(list.toString());

        // 插入元素
        list.add(2,99);
        System.out.println(list);

        // 根据元素位置得到元素
        int element = list.get(2);
        System.out.println(element);

        // 得到元素的位置
        int index = list.indexOf(99);
        System.out.println(index);

        // 更新元素
        list.set(1,22);
        System.out.println(list.toString());

        //链表的长度
        int length = list.size();
        System.out.println(length);

        // 移除元素
        list.remove(3);
        System.out.println(list);
    }
}

2.数组

2.1数组是什么

所谓数组，是有序的元素序列。
若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。
用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按有序的形式组织起来的一种形式。
这些有序排列的同类数据元素的集合称为数组。
数组是用于储存多个相同类型数据的集合。

2.2 如何使用数组

数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。
Java语言中提供的数组是用来存储固定大小的同类型元素。
你可以声明一个数组变量，如numbers[100]来代替直接声明100个独立变量number0，number1，…，number99。
本教程将为大家介绍Java数组的声明、创建和初始化，并给出其对应的代码。

1.声明数组变量首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

dataType[] arrayRefVar;   // 首选的方法

或

dataType arrayRefVar[];  // 效果相同，但不是首选方法

注意: 建议使用dataType[] arrayRefVar 的声明风格声明数组变量。 dataType arrayRefVar[] 风格是来自 C/C++ 语言 ，在Java中采用是为了让 C/C++ 程序员能够快速理解java语言。

创建数组Java语言使用new操作符来创建数组，语法如下：

arrayRefVar = new dataType[arraySize];

上面的语法语句做了两件事：一、使用dataType[arraySize]创建了一个数组。二、把新创建的数组的引用赋值给变量 arrayRefVar。数组变量的声明，和创建数组可以用一条语句完成，如下所示：

dataType[] arrayRefVar = new dataType[arraySize];

另外，你还可以使用如下的方式创建数组。

dataType[] arrayRefVar = {value0, value1, ..., valuek};

数组的元素是通过索引访问的。数组索引从0开始，所以索引值从0到arrayRefVar.length-1。
实例下面的语句首先声明了一个数组变量myList，接着创建了一个包含10个double类型元素的数组，并且把它的引用赋值给myList变量。

double[] myList = new double[10];

下面的图片描绘了数组myList。这里myList数组里有10个double元素，它的下标从0到9。

处理数组数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，我们通常使用基本循环或者foreach循环。示例该实例完整地展示了如何创建、初始化和操纵数组：

public class TestArray {

   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // 打印所有数组元素
      for (int i = 0; i < myList.length; i++) {
          System.out.println(myList[i] + " ");
       }
       // 计算所有元素的总和
       double total = 0;
       for (int i = 0; i < myList.length; i++) {
          total += myList[i];
       }
       System.out.println("Total is " + total);
       // 查找最大元素
       double max = myList[0];
       for (int i = 1; i < myList.length; i++) {
          if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);
   }
}

以上实例编译运行结果如下：
1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5
foreach循环JDK 1.5 引进了一种新的循环类型，被称为foreach循环或者加强型循环，它能在不使用下标的情况下遍历数组。
示例
该实例用来显示数组myList中的所有元素：

public class TestArray {

   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // 打印所有数组元素
      for (double element: myList) {
         System.out.println(element);
      }
   }
}

以上实例编译运行结

果如下：
1.9
2.9
3.4
3.5
数组作为函数的参数数组可以作为参数传递给方法。
例如，下面的例子就是一个打印int数组中元素的方法。

public static void printArray(int[] array) {
  for (int i = 0; i < array.length; i++) {
     System.out.print(array[i] + " ");
   }
 }

下面例子调用printArray方法打印出 3，1，2，6，4和2：

printArray(new int[]{3, 1, 2, 6, 4, 2});

数组作为函数的返回值

public static int[] reverse(int[] list) {
  int[] result = new int[list.length];

  for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
     result[j] = list[i];
   }
   return result;
 }

Arrays 类java.util.Arrays类能方便地操作数组，它提供的所有方法都是静态的。
具有以下功能：
给数组赋值：通过fill方法。
对数组排序：通过sort方法,按升序。
比较数组：通过equals方法比较数组中元素值是否相等。
查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。
具体说明请查看下表：

序号	方法和说明
1	public static int binarySearch(Object[] a, Object key用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
2	public static boolean equals(long[] a, long[] a2如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
3	public static void fill(int[] a, int val)将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
4	public static void sort(Object[] a)对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

2.3打印数组：

String[] str = s.trim().split(" ");
System.out.println(Arrays.toString(str));

package com.wyw;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

/**
 * @author Administrator
 */
public class ArrayTest {
    public static void main(String[] args) {
        // 1.创建数组
        int[] arr = {1,2,3};
        System.out.println(Arrays.toString(arr));

        int[] arr1 = new int[]{1,2,3};
        System.out.println(Arrays.toString(arr1));

        int[] arr2 = new int[3];
        for (int i = 0; i < arr.length; i++) {
            arr2[i] = i+1;
        }
        System.out.println(Arrays.toString(arr2));

        // 2.通过Arraylist创建数组
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            list.add(i + 1);
        };
        System.out.println(list);

        // 添加元素
        list.add(99);
        System.out.println(list);

        // 特定位置添加元素
        list.add(3,88);
        System.out.println(list);

        // 根据下标查找元素
        int num = arr1[1];
        int num1 = list.get(1);
        System.out.println(num);
        System.out.println(num1);

        // 更新元素
        arr1[1] = 11;
        list.set(1,11);
        System.out.println(Arrays.toString(arr1));
        System.out.println(list);

        // 移除元素
        list.remove(1);
        System.out.println(list);

        // 数组长度
        int length = arr.length;
        int length1 = list.size();
        System.out.println(length);
        System.out.println(length1);

        // 遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        // 查找一个元素
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == 1) {
                System.out.println("we fonud 1 in this string");
            }
        }

        // 从查找一个元素是否正在数组中
        boolean is1 = list.contains(1);
        System.out.println("we are found?" + is1);

        // 对数组进行排序
        int[] c = {2,3,1};
        ArrayList<Integer> list1 = new ArrayList<>();
        list1.add(2);
        list1.add(3);
        list1.add(1);
        System.out.println(Arrays.toString(c));
        System.out.println(list1);

        Arrays.sort(c);
        System.out.println(Arrays.toString(c));

        Collections.sort(list1);
        System.out.println(list1);

        // 使数组倒序
        Collections.sort(list1,Collections.reverseOrder());
        System.out.println(list1);
    }
}