1.数组

数据结构（1）数组

0.概述

分为线性结构：数据元素一对一线性关系

数组、队列、链表、栈

顺序存储、链式存储；

非线性结构：图、树等

 

1.数组

1.1稀疏数组

数组中大部分为0或某定值

处理方法：

1）记录数组几行几列，有多少个值；

2）对应元素及其行列号用数组记录。

public class SparseArray {
    public static void main(String[] args) {
        //创建原始数组
        int[][] chessArr = new int[11][11];
        chessArr[2][1] = 1;
        chessArr[1][9] = 4;
        chessArr[8][3] = 33;
        chessArr[5][5] = 2;
​
        //遍历原始数组
        System.out.println("原始数组：");
        int sum = 0;
        for (int[] arr : chessArr) {
            for (int a : arr) {
                System.out.print(a + " ");
                if (a != 0) sum++;
            }
            System.out.println();
        }
​
        //创建稀疏数组
        int[][] sparseArr = new int[sum + 1][3];
        //记录行列数和元素数
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = sum;
        //遍历原始数组添加元素
        int count = 1;//记录元素个数
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (chessArr[i][j] != 0) {
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = chessArr[i][j];
                    count++;
                }
            }
        }
​
        //输出稀疏数组
        System.out.println("稀疏数组：");
        for (int i = 0; i < sparseArr.length; i++) {
            System.out.printf("%d\t%d\t%d\n", sparseArr[i][0], sparseArr[i][1], sparseArr[i][2]);
        }
​
        //恢复原始数组
        int[][] chessArr1 = new int[sparseArr[0][0]][sparseArr[0][1]];
        for (int i = 1; i < sparseArr.length; i++) {
            chessArr1[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }
        //输出恢复后的数组
        System.out.println("恢复后的数组：");
        for (int[] arr : chessArr1) {
            for (int a : arr) {
                System.out.print(a + " ");
            }
            System.out.println();
        }
    }
}

1.2 数组旋转问题

1.2.1 螺旋矩阵

import java.util.*;
public class Solution {
    /**
     * 
     * @param n int整型 
     * @return int整型二维数组
     */
    public int[][] generateMatrix (int n) {
        // write code here
        int[][] mat = new int[n][n];
        int var = 1;
        int mbegin = 0,mend = n-1;
        int nbegin = 0,nend = n-1;
        //从外层依次遍历，设置4个边界，每一轮循坏走一圈，同时缩小边界
        while(mbegin <= mend && nbegin <= nend){
            for(int i = nbegin;i <= nend;i++){
                mat[mbegin][i] = var++;
            }
            mbegin++;
            for(int i = mbegin;i <= mend;i++){
                mat[i][nend] = var++;
            }
            nend--;
            //
            for(int i = nend;i >= nbegin && mend >= mbegin;i--){
                mat[mend][i] = var++;
            }
            mend--;
            for(int i = mend;i >= mbegin && nend >= nbegin;i--){
                mat[i][nbegin] = var++;
            }
            nbegin++;
        }
        return mat;
    }
}

1.3 哈希问题

1.3.1 两数之和

/**
*   给出一个整数数组，请在数组中找出两个加起来等于目标值的数
*   返回这两个数字的下标（index1，index2），需要满足 index1 小于index2
*   注意：下标是从1开始的
*   假设给出的数组中只存在唯一解
*/
import java.util.*;
public class Solution {
    /**
     * @param numbers int整型一维数组 
     * @param target int整型 
     * @return int整型一维数组
     */
    public int[] twoSum (int[] numbers, int target) {
        // write code here
        int[] ans = new int[2];
        //利用哈希，对已遍历的内容进行记录
        Map<Integer,Integer> map = new HashMap();
        for(int i = 0;i < numbers.length;i++){
            if(map.get(target - numbers[i]) != null){
                ans[0] = map.get(target - numbers[i]) + 1;
                ans[1] = i + 1;
                break;
            }
            map.put(numbers[i],i);
        }
        return ans;
    }
}