数据结构与算法-01 数组、链表

原创

已于 2025-06-30 19:10:55 修改 · 1.1k 阅读

标签

#数据结构与算法 #数组、链表

于 2020-05-06 11:09:20 首次发布

数据结构与算法

数据结构与算法介绍
稀疏数组和队列
链表

数据结构与算法介绍

先看几个经典的算法面试题

字符串匹配问题

有一个字符串 str1= ““硅硅谷尚硅谷你尚硅尚硅谷你尚硅谷你尚硅你好””，和一个子串 str2=“尚硅谷你尚硅你”；
现在要判断 str1 是否含有 str2, 如果存在，就返回第一次出现的位置, 如果没有，则返回-1；
要求用最快的速度来完成匹配；
你的思路是什么？

思路一：暴力匹配
思路二：KMP算法《部分匹配表》

汉诺塔游戏

在这里插入图片描述

将A塔的所有圆盘移动到C塔，规定：① 小圆盘上不能放大圆盘；② 在三根柱子之间一次只能移动一个圆盘。

使用分治算法

八皇后问题

是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出：在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即：任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。
游戏演示：http://www.7k7k.com/swf/49842.htm
使用到回溯算法。
高斯认为有76种方案。1854年在柏林的象棋杂志上不同的作者发表了40种不同的解，后来有人用图论的方法解出92种结果。计算机发明后，有多种计算机语言可以解决此问题。

马踏棋盘

马踏棋盘算法也被称为骑士周游问题；
将马随机放在国际象棋的8×8棋盘，Board[0～7][0～7]的某个方格中，马按走棋规则(马走日字)进行移动。要求每个方格只进入一次，走遍棋盘上全部64个方格；
游戏演示: http://www.4399.com/flash/146267_2.htm
会使用到图的深度优化遍历算法(DFS) + 贪心算法优化

数据结构和算法的重要性

算法是程序的灵魂，优秀的程序可以在海量数据计算时，依然保持高速计算。
一般来讲，程序会使用了内存计算框架(比如Spark)和缓存技术(比如Redis等)来优化程序，再深入的思考一下，这些计算框架和缓存技术，它的核心功能是哪个部分呢？
拿实际工作经历来说, 在Unix下开发服务器程序，功能是要支持上千万人同时在线，在上线前，做内测一切OK,可上线后，服务器就支撑不住了，公司的CTO对代码进行优化，再次上线坚如磐石。你就能感受到程序是有灵魂的，就是算法。
目前程序员面试的门槛越来越高，很多一线IT公司(大厂)，都会有数据结构和算法面试题(负责的告诉你，肯定有的)。
如果你不想永远都是代码工人，那就花时间来研究下数据结构和算法。

数据结构和算法的关系

数据data结构(structure)是一门研究组织数据方式的学科，有了编程语言也就有了数据结构。学好数据结构可以编写出更加漂亮，更加有效率的代码。
要学习好数据结构就要多多考虑如何将生活中遇到的问题，用程序去实现解决。
程序 = 数据结构 + 算法。
数据结构是算法的基础，换言之，想要学好算法，需要把数据结构学到位。

几个实际编程中遇到的问题

字符串替换

public static void main(String[] args) {
   
   
	String str = "Java,Java, hello,world!";
	String newStr = str.replaceAll("Java", "尚硅谷~"); //算法
	System.out.println("newStr=" + newStr);
}

Q：试写出用单链表表示的字符串类及字符串结点类的定义，并依次实现它的构造函数、以及计算串长度、串赋值、判断两串相等、求子串、两串连接、求子串在串中位置等7个成员函数。

五子棋程序

在这里插入图片描述

Q：如何判断游戏的输赢，并可以完成存盘退出和继续上局的功能。
棋盘 => 二维数组 => (稀疏数组) => 写入文件【存档功能】
读取文件 => 稀疏数组 => 二维数组 => 棋盘【接上局】

约瑟夫(Josephu)问题

设编号为1，2，… n的n个人围坐一圈，约定编号为k（1<=k<=n）的人从1开始报数，数到m 的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。

用一个不带头结点的循环链表来处理Josephu 问题：先构成一个有n个结点的单循环链表（单向环形链表），然后由k结点起从1开始计数，计到m时，对应结点从链表中删除，然后再从被删除结点的下一个结点又从1开始计数，直到最后一个结点从链表中删除算法结束。

其它常见问题

修路问题 => 最小生成树(加权值)【数据结构】+ 普利姆算法；
最短路径问题 => 图+弗洛伊德算法；
汉诺塔 => 分支算法；
八皇后问题 => 回溯法。

线性结构和非线性结构

线性结构

线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系。
线性结构有两种不同的存储结构，即顺序存储结构和链式存储结构。顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的。
链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息。
线性结构常见的有：数组、队列、链表和栈。

非线性结构

二维数组，多维数组，广义表，树结构，图结构。

稀疏数组和队列

稀疏数组SparseArray

基本介绍：当一个数组中大部分元素为０，或者为同一个值时，可以使用稀疏数组来保存该数组。
稀疏数组的处理方法是：记录数组一共有几行几列，有多少个不同的值；把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模。
代码实现：

import java.io.*;

/**
 * 原始数组
 * 0	0	0	0	0	0	0	0	0	0	0
 * 0	0	1	0	0	0	0	0	0	0	0
 * 0	0	0	2	0	0	0	0	0	0	0
 * 0	0	0	0	0	0	0	0	0	0	0
 * 0	0	0	0	0	1	0	0	0	0	0
 * 0	0	0	0	0	0	0	0	0	0	0
 * 0	0	0	0	0	0	0	0	0	0	0
 * 0	0	0	0	0	0	0	0	0	0	0
 * 0	0	0	0	0	0	0	0	0	0	0
 * 0	0	0	0	0	0	0	0	0	0	0
 * 0	0	0	0	0	0	0	0	0	0	0
 * <p>
 * 稀疏数组
 * 11	11	3
 * 1	2	1
 * 2	3	2
 * 4	5	1
 */
public class T01SparseArray {
   
   
    private static int[][] chessArr;
    private static final String FILENAME = "classpath:sparse.arr";

    public static void main(String[] args) throws IOException {
   
   
        // 1、初始化二维数组
        initOrgTwoDimArr();
        // 2、二维数组 转 稀疏数组
        int[][] sparseArr = twoDim2Sparse();
        // 3、稀疏数组写入文件
        writeArrToFile(sparseArr);
        // 4、将文件恢复成稀疏数组
        int[][] newSparseArr = readArrFromFile();
        // 5、稀疏数组 转 二维数组
        sparse2twoDim(newSparseArr);
    }

    /**
     * 1、初始化原始的二维数组
     */
    private static void initOrgTwoDimArr() {
   
   
        // 1、创建一个原始的二维数组 11 * 11
        // 0：表示没有值，1：黑子，2：蓝子
        chessArr = new int[11][11];
        chessArr[1][2] = 1;
        chessArr[2][3] = 2;
        chessArr[4][5] = 1;

        System.out.println("原始的二维数组：");
        printTwoDimArr(chessArr);
    }

    /**
     * 2、二维数组 转 稀疏数组
     */
    private static int[][] twoDim2Sparse() {
   
   
        // 2、将二维数组 转为 稀疏数组
        // 2.1、遍历二维数组
        int sum = 0;
        for (int i = 0; i < 11; i++) {
   
   
            for (int j = 0; j < 11; j++) {
   
   
                if (chessArr[i][j] != 0) {
   
   
                    sum++;
                }
            }
        }
        // 2.2、创建对应的稀疏数组
        int[][] sparseArr = new int[sum + 1][3];
        // 给稀疏数组赋值
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = sum;
        // 2.3、遍历二维数组，将非0的值放入到sparseArr
        // 定义 count 用于记录是第几个非0数据
        int count = 0;
        for (int i = 0; i < 11; i++) {
   
   
            for (int j = 0; j < 11; j++) {
   
   
                if (chessArr[i][j] != 0) {
   
   
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = chessArr[i][j];
                }
            }
        }

        System.out.println("得到的稀疏数组：");
        printTwoDimArr(sparseArr);
        return sparseArr;
    }

    /**
     * 3、将稀疏数组 写入 文件 sparse.arr
     */
    private static void writeArrToFile(int[][] sparseArr) throws IOException {
   
   
        Writer out = new FileWriter(new File(FILENAME));
        for (int i = 0; i < sparseArr.length; i++) {
   
   
            for (int j = 0; j < 3; j++) {
   
   
                out.write(sparseArr[i][j] + "\t");
            }
            out.write("\r\n");
        }
        System.out.println("保存文件成功");
        out.close();
    }

    /**
     * 4、将文件中的数据 恢复成 稀疏数组
     */
    private static int[][] readArrFromFile() throws IOException {
   
   
        FileReader fr = new FileReader(new File(FILENAME));
        BufferedReader br = new BufferedReader(fr);
        // 读取文件，看一下有多少行，以便初始化稀疏数组
        int line = 0;
        while (br.readLine() != null) {
   
   
            line++;
        }
        int[][] sparseArr = new int[line][3];

        // 再次读物每一行数据，拆分数据并给数组赋值
        fr = new FileReader(new File(FILENAME));
        br = new BufferedReader(fr);
        int count = 0;
        String s;
        while ((s = br.readLine()) != null) {
   
   
            String[] strArr = s.split("\t");
            sparseArr[count][0] = Integer.parseInt(strArr[0]);
            sparseArr[count][1] = Integer.parseInt(strArr[1]);
            sparseArr[count][2] = Integer.parseInt(strArr[2]);
            count++;
        }
        br.close();
        fr.close();
        System.out.println("从文件中恢复稀疏数组：");
        printTwoDimArr(sparseArr);
        return sparseArr;
    }

    /**
     * 5、稀疏数组 转 二维数组
     */
    private static void sparse2twoDim(int[][] sparseArr) {
   
   
        // 5、将稀疏数组 转为 原始的二维数组
        // 5.1、读取稀疏数组的第0行数据，创建原始的二维数组
        int[][] orgArr = new int[sparseArr[0][0]][sparseArr[0][1]];
        // 5.2、遍历稀疏数组的第后几行数据，并赋值给原始的二维数组
        for (int i = 1; i < sparseArr.length; i++) {
   
   
            orgArr[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }
        System.out.println("恢复得到二维数组：");
        printTwoDimArr(orgArr);
    }

    /**
     * 打印二维数组
     *
     * @param twoDimArr
     */
    private static void printTwoDimArr(int[][] twoDimArr) {
   
   
        for (int[] arr : twoDimArr) {
   
   
            for (int data : arr) {
   
   
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }
    }
}

队列

队列的一个使用场景

银行排队的案例

队列的介绍

队列是一个有序列表，可以用数组或是链表来实现。
遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出。

数组模拟队列

思路

队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中 maxSize 是该队列的最大容量。
因为队列的输出、输入是分别从前后端来处理，因此需要两个变量 front及 rear分别记录队列前后端的下标，front 会随着数据输出而改变，而 rear则是随着数据输入而改变。
当我们将数据存入队列时称为”addQueue”，addQueue 的处理需要有两个步骤

将尾指针往后移：rear+1 , 当front == rear 【空】
若尾指针 rear 小于队列的最大下标 maxSize-1，则将数据存入 rear所指的数组元素中，否则无法存入数据。 rear == maxSize - 1[队列满]

代码实现

定义一个队列接口：定义队列的相关操作

/**
 * 定义一个队列接口
 */
public interface Queue {
   
   
    /**
     * 判断队列是否满
     */
    boolean isFull();
    /**
     * 判断队列是否为空
     */
    boolean isEmpty();
    /**
     * 添加数据到队列
     */
    void addQueue(int n);