1. 上一道题的另一种解法（最大连续子序列和）

可以引入前缀和的概念，传建一个比原数组长度大一的原数组。只需要找出其中，最大的数字和最大数字左边最小的数字，两两相减就可以得到最大前缀和

  1.     原数组 = (1,2,3,-6,1)
  2. 前缀和数组 = (0,1,3, 6,0,1)
  3. 这里只需要找到最大的数字再减去最大数字左边最小的数字就可以得到最大连续子序列和  
  4. 6 - 0 = 6
  6. 同理：
  7.     原数组 = (1,-1,-3, 2, 3,4)
  8. 前缀和数组 = (0, 1, 0,-3,-1,2,6)
  9. 6 - (-3) = 9

2. 判断二维数组中对应的位置是否有值

  1. Node.java
  2. public class Node {
  3.     private int value;
  4.     private int key;
  5.     private Node next;
  7.     public Node() {
  8.     }
  10.     public Node(int key,int value) {
  11.         this.key = key;
  12.         this.value = value;
  13.     }
  15.     public int getValue() {
  16.         return value;
  17.     }
  19.     public void setValue(int value) {
  20.         this.value = value;
  21.     }
  23.     public int getKey() {
  24.         return key;
  25.     }
  27.     public void setKey(int key) {
  28.         this.key = key;
  29.     }
  31.     public Node getNext() {
  32.         return next;
  33.     }
  35.     public void setNext(Node next) {
  36.         this.next = next;
  37.     }
  38. }
  40. Paixu.java
  41. public class Paixu {
  42.     public static void main(String[] args) {
  43.         //初始条件
  44.         int[][] arr = new int[10][10];
  45.         arr[1][1] = 6;
  47.         Scanner sc = new Scanner(System.in);
  48.         System.out.println("请输入x轴坐标：");
  49.         int x = sc.nextInt();
  50.         System.out.println("请输入y轴坐标：");
  51.         int y = sc.nextInt();
  53.         boolean result = cha(arr,x,y);
  54.     }
  56.     /**
  57.      * 1. 普通查找
  58.      * @param arr
  59.      * @param x
  60.      * @param y
  61.      * @return
  62.      */
  63.     private static boolean cha(int[][] arr, int x, int y) {
  64.         if (arr[x][y]!=0){
  65.             return true;
  66.         }
  67.         return false;
  68.     }
  70.     /**
  71.      * 2. 数组加链表查找
  72.      * @param x
  73.      * @param y
  74.      * @return
  75.      */
  76.     private static boolean linke_cha(int x,int y){
  77.         /**
  78.          * 相当于HashMap源码中containsValue的书写
  79.          * 1. 首先先遍历查找x
  80.          * 2. 在x所对应的链表中查找y位置
  81.          * 3. 判断值是否为0
  82.          */
  83.         ArrayList<LinkedList> array_head = new ArrayList<LinkedList>(10);
  84.         LinkedList linkedList = array_head.get(x);
  85.         Node value = (Node)linkedList.get(y);
  86.         if (value.getValue()!=0){
  87.             return true;
  88.         }
  89.         return false;
  90.     }
  92.     /**
  93.      * 稀疏矩阵没有理解太清楚，随后补上
  94.      */
  96. }