数据结构笔记整理

1.链表

1.1 单链表的介绍

链表是一种物理存储单元上非连续，非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的

1.2 单链表的特点

1. 链表是以结点形式存储的，是链式存储
2. 每个结点包含data区域和next区域
3. 每个结点并不是连续存储的
4. 链表分带头结点链表和没有带头结点链表

1.3 单链表的练习

需求：根据带有头部的链表，实现商品增删改查，并且也可以针对商品已编号进行排序，完成排行榜

/**
 * 商品信息类
 */
public class GoodsNode {
    public int id;
    public String name;
    public double price;
    public GoodsNode node;

    public GoodsNode(int id, String name, double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    @Override
    public String toString() {
        return "GoodsNode{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

/**
 * 链表操作类
 */

public class DLinkedList {
    //链表头
    private GoodsNode node = new GoodsNode(0,"",0.0);

    /**
     * 向链表中添加商品信息
     * @param goodsNode
     */
    public void add(GoodsNode goodsNode){
        //拿到头的地址赋值给变量
        GoodsNode temp = node;
        //判断结点是否为空，为空的话直接添加数据
        while (true){
            if (temp.node == null){
                temp.node = goodsNode;
                break;
            }
            if (temp.node.id == goodsNode.id){
                System.out.println("id不能重复");
                break;
            }
            //如果不为空则还需遍历，则把下一个的地址赋给当前的元素
            temp = temp.node;
        }
    }
    //按商品编号id值进行添加，并且按从小到大顺序排列
    public void addOrder(GoodsNode goodsNode){
        //拿到头结点
        GoodsNode temp = node;
        boolean flag = false;
        while (true){
            if (temp.node == null){
                break;
            }
            //判断当前元素的id是否大于传过来的商品id，如果是的话则更改当前元素的next域
            if (temp.node.id > goodsNode.id){
              break;
            }else if (temp.node.id == goodsNode.id){
                flag = true;
                break;
            }
            temp = temp.node;
        }
        if (flag){
            System.out.println("id不能重复，添加失败");
        }else{
            goodsNode.node = temp.node;
            temp.node = goodsNode;
        }
    }
    //修改商品信息，根据商品编号
    public void updateGoods(GoodsNode goodsNode){
        GoodsNode temp = node;
        boolean flag = false;
        while (true){
            if (temp == null){
                break;
            }
            if (temp.node.id == goodsNode.id){
                flag = true;
                break;
            }
            temp = temp.node;
        }
        if (flag){
            temp.node.name = goodsNode.name;
            temp.node.price = goodsNode.price;
        }else{
            System.out.println("在列表中未找到元素.....");
        }
    }
    //删除商品信息
    public void deleteGoods(int id){
        GoodsNode temp = node;
        boolean flag = false;
        while (true){
            if (temp == null){
                break;
            }
            if (temp.node.id == id){
                flag = true;
                break;
            }
            temp = temp.node;
        }
        if (flag){
            temp.node = temp.node.node;
        }else{
            System.out.println("未找到删除的结点.....");
        }
    }



    public void printGoodsNode() {
        if (node.node == null) {
            System.out.print("空列表");
            return;
        }
        GoodsNode temp = node.node;
        while (true) {
            if (temp == null) {
                break;
            }
            System.out.println(temp);
            temp = temp.node;
        }
    }
}

/**
* 测试类
*/
public class Test {
    public static void main(String[] args) {
        GoodsNode goodsNode1 = new GoodsNode(1,"衣服",22);
        GoodsNode goodsNode2 = new GoodsNode(2,"鞋子",27);
        GoodsNode goodsNode3 = new GoodsNode(3,"帽子",65);
        GoodsNode goodsNode4 = new GoodsNode(4,"裤子",78);
        DLinkedList dl = new DLinkedList();
        //添加
//        dl.add(goodsNode1);
//        dl.add(goodsNode2);
//        dl.add(goodsNode3);
//        dl.add(goodsNode4);
        //顺序添加
        dl.addOrder(goodsNode2);
        dl.addOrder(goodsNode3);
        dl.addOrder(goodsNode1);
        dl.addOrder(goodsNode4);
        //根据id修改
        dl.updateGoods(new GoodsNode(4,"袜子",11));
        //根据id进行删除
        dl.deleteGoods(2);
        dl.printGoodsNode();
    }
}

1.2 双链表的介绍

1.2.1双链表的介绍

双向链表也叫双链表，是链表的一种，它的每一个数据点中都有两个指针，分别指向直接后驱直接前驱，所以，从双向链表中的任意一个结点开始，都可以很方便的访问它的前驱节点和后继结点

1.2.2 双向链表的练习

需求：利用双向链表进行图书的增删改查

/**
*图书实体类
*/
public class BookNode {
    private int id;
    private String name;
    private double price;
    private BookNode next;
    private BookNode pre;

    public BookNode(int id, String name, double price, BookNode next, BookNode pre) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.next = next;
        this.pre = pre;
    }

/**
 * 双向链表的增删改查
 */
public class DLinkedLists {
    //头结点
    private BookNode node = new BookNode(0,"",0.0,null,null);

    /**
     * 添加结点
     * @param bookNode 新结点
     */
    public void add(BookNode bookNode){
        //拿到头结点
        BookNode temp = node;
        //先判断结点是否为空
        while(true){
            if (temp.getNext() == null){
                break;
            }
            temp = temp.getNext();
        }
        temp.setNext(bookNode);
        bookNode.setPre(temp);
    }
    /**
     * 修改操作
     * 通过id进行比对修改，如果id一样则进行修改
     */
    public void updateBN(BookNode bookNode){
        BookNode temp = node;
        //先判断头结点的next是否为空
        if (temp.getNext() == null){
            System.out.println("空链表.......");
        }
        boolean flag = false;
        while(true){
            if (temp.getNext() == null){
                break;
            }
            //比对id是否一样
            if (temp.getId() == bookNode.getId()){
                flag = true;
                break;
            }
            //到这里则说明还没找到结点，则继续循环
            temp = temp.getNext();
        }
        if (flag){
            temp.setName(bookNode.getName());
            temp.setPrice(bookNode.getPrice());
        }else{
            System.out.println("没有找到数据.....");
        }
    }

    /**
     * 双向链表的删除
     * 分析：根据id找到需要删除的结点，通过pre找到前驱地址，通过next找到后继地址
     */
    public void deleteBookNode(int id){
        //拿到头结点
        BookNode temp = node;
        if (temp.getNext() == null){
            System.out.println("空链表.....");
            return;
        }
        boolean flag = false;
        while (true){
            if (temp.getNext() == null){
                break;
            }
            if (temp.getId() == id){
                //说明找到结点，则fanhui
                flag = true;
                break;
            }
            temp = temp.getNext();
        }
        if (flag){
            //删除结点
            temp.getPre().setNext(temp.getNext());
            if (temp.getPre() != null){
                temp.getNext().setPre(temp.getPre());
            }
        }else{
            System.out.println("未找到数据......");
        }
    }
    public void findBookNode(){
        BookNode temp = node;
        if (temp.getNext() == null){
            System.out.println("空链表.....");
            return;
        }
        while (true){
            if (temp.getNext() == null){
                break;
            }
            temp = temp.getNext();
            System.out.println(temp);
        }
    }
}

测试类

    /**
     * 测试双向链表
     */
    public static void main(String[] args) {
        BookNode bk1 = new BookNode(1,"java",10.0,null,null);
        BookNode bk2 = new BookNode(2,"javascript",20.0,null,null);
        BookNode bk3 = new BookNode(3,"数据库应用",30.0,null,null);
        BookNode bk4 = new BookNode(4,"C++",40.0,null,null);
        DLinkedLists dl = new DLinkedLists();
        dl.add(bk1);
        dl.add(bk2);
        dl.add(bk3);
        dl.add(bk4);
        //修改
        dl.updateBN(new BookNode(2,"软件工程",40.0,null,null));
        //删除
        dl.deleteBookNode(2);
        dl.findBookNode();
    }
}

1.2.2 单项环形链表（约瑟夫问题）

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

/**
 * 小孩实体类
 */
public class Boy {
    private int no;
    private Boy next;

/**
 * 环形列表
 */
public class CircleSingleLinkedList {
    private Boy first = new Boy(0);

    /**
     * 初始化环形链表
     * @param num
     */
    public void addLink(int num){
        if (num < 1){
            System.out.println("输入的参数不正确........");
            return;
        }
        Boy temp = first;
        for (int i = 1;i<=num;i++){
            Boy boy = new Boy(i);
            temp.setNext(boy);
            temp = temp.getNext();
        }
       temp.setNext(first.getNext());
    }

    /**
     * 当调用改方法输入第几个小孩子开始数数，数几次，环形链表中一共有几个小孩
     * @param startNo
     * @param countNum
     * @param nums
     */
    public void countBoy(int startNo,int countNum,int nums){
        //先判断参数是否合法
        if (startNo < 1 || countNum > nums || first == null){
            System.out.println("输入的参数不正确...");
            return;
        }
        //定义一个变量,指向末尾
        Boy helper = first.getNext();
        Boy temp = first.getNext();
        while (true){
            if (helper.getNext() == temp){
                //如果相等的话，则说明到了最后一个小孩，则需退出
                break;
            }
            helper = helper.getNext();
        }
        //找到从哪个小孩开始数的位置
        for (int i = 0;i<startNo-1;i++){
            temp = temp.getNext();
            helper = helper.getNext();
        }
        //出列的小孩
        while (true){
            if (helper.getNext() == helper){
                //说明此时只剩一个小孩，则退出
                break;
            }
            for (int j = 0;j<countNum-1;j++){
                //需要出列的小孩
                temp = temp.getNext();
                helper = helper.getNext();
            }
            //把出列的小孩下一位的地址附上给helper
            helper.setNext(temp.getNext());
            System.out.println(temp.getNo()+"号小孩出列");
            temp = temp.getNext();

        }
        System.out.println("最后出列的小孩"+temp.getNo());
    }
}

2. 稀疏数组

2.1 稀疏数组介绍

• 当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。

压缩的条件：

1. 原数组中存在大量的无效数据，占据了大量的存储空间，真正有用的数据很少
2. 压缩存储可以节省储存空间，避免资源的不必要的浪费，在数据序列化到磁盘时，压缩存储可以体高IO效率。

稀疏数组的处理方式是：

1. 记录数组一共有几行几列，有多少个不同值
2. 把具有不同值的元素和行列及值记录在一个小规模数组中，从而缩小程序的规模，如下图
   

2.2.1 稀疏数组练习1（数组存储）

需求：
1.使用稀疏数组来保留如下的数组（棋盘）
2.把稀疏数组存盘可以重新回复原来的二维数组

 public static void main(String[] args) {
        /**
         * 创建棋盘，初始化数据，使用二维数组创建一个行为11，列为11的数组
         */
        int[][] array = new int[11][11];
        //往二维数组里面添加数据
        array[1][2] = 1;
        array[2][3] = 2;
        //查看棋盘
        for (int i = 0;i<11;i++){
            for (int j = 0;j<11;j++){
                System.out.print(array[i][j]+" ");
            }
            System.out.println();
        }
        //压缩成为稀疏数组
        //分析，稀疏数组第一行0行数据11，11，未知
        // 稀疏数组列已知3列，行未知
        //先求有效值的个数
        int count = 0;
        for (int i = 0;i<11;i++){
            for (int j = 0;j<11;j++){
                if (array[i][j] != 0){
                    //则说明此值为有效值
                    count++;
                }
            }
        }
        //总有效值个数为count，则稀疏数组的行为count+1
        int[][] sparseArray = new int[count+1][3];
        //稀疏数组第一行固定值
        sparseArray[0][0] = 11;
        sparseArray[0][1] = 11;
        sparseArray[0][2] = count;
        //定义一个变量存储指针
        int index = 0;
        for (int i = 0;i<11;i++){
            for (int j = 0;j<11;j++){
                if (array[i][j] != 0 ){
                    index++;
                    sparseArray[index][0] = i;
                    sparseArray[index][1] = j;
                    sparseArray[index][2] = array[i][j];
                }
            }
        }
        System.out.println("------------------稀疏数组-------------------------");
        for (int[] row: sparseArray){
            for (int val:row){
                System.out.print(val+" ");
            }
            System.out.println();
        }
        //根据稀疏数组还原棋盘
        //创建棋盘
        int[][] newArray = new int[11][11];
        //根据稀疏数组的指针向新棋盘里面添加数据,i的数据值应该从1开始
        for (int i=1;i<=index;i++){
            newArray[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        //查看新棋盘
        System.out.println("--------------------新棋盘---------------------");
        for (int[] row:newArray){
            for (int val:row){
                System.out.print(val+" ");
            }
            System.out.println();
        }
    }

----------------------运行结果---------------------------------
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 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 0 
------------------稀疏数组-------------------------
11 11 2 
1 2 1 
2 3 2 
--------------------新棋盘---------------------
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 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 0 ```

2.2.2 稀疏数组练习2（链式存储）

需求：通过链表来实现稀疏数组的存储

/**
*实体类
*/
public class Storage {
    private int row;//行
    private int col;//列
    private int val;//值
    private Storage next;//下一个存储的地址

/**
 * 链式存储
 */
public class LinkedStorage {
    //头
    private Storage node;

    public Storage getNode() {
        return node;
    }

    public void setNode(Storage node) {
        this.node = node;
    }

    /**
     * 初始化链表，头结点里面存放的是棋盘总行列数和有效值总数
     * @param node
     */
    public LinkedStorage(Storage node) {
        this.node = node;
    }

    /**
     * 添加存储
     * @param storage
     */
    public void add(Storage storage){
        Storage temp = node;
        while (true){
            if (temp.getNext() == null){
                break;
            }
            temp = temp.getNext();
        }
        temp.setNext(storage);
    }

    /**
     * 查看链表
     */
    public  void findLinked(){
        Storage temp = node;
        while (true){
            if (temp == null){
                System.out.println("链表为空");
                break;
            }
            System.out.println(temp);
            temp = temp.getNext();
        }
    }
}

//测试类
 public static void main(String[] args) {
        //链式添加存储
        //创建一个棋盘
        int[][] array = new int[11][11];
        //添加数据
        array[1][2] = 1;
        array[2][3] = 2;
        array[3][4] = 3;

        //查看棋盘,并且计算有效值个数
        int count=0;
        for(int i=0;i<11;i++){
            for (int j=0;j<11;j++){
                System.out.print(array[i][j]+" ");
                if (array[i][j] != 0 ){
                    count++;
                }
            }
            System.out.println();
        }

        //初始化链表
        LinkedStorage ls = new LinkedStorage(new Storage(11,11,count));
        for (int i=0;i<11;i++){
            for (int j=0;j<11;j++){
                if (array[i][j] !=0 ){
                    Storage sr = new Storage(i,j,array[i][j]);
                    //往链表里添加数据
                    ls.add(sr);
                }
            }
        }
        //查看链表里的数据
        ls.findLinked();

        //通过链表还原数据
        //获取链表头的信息，拿到行列数和有效值
        int row = ls.getNode().getRow();//行
        int col = ls.getNode().getCol();//列
        //创建棋盘
        int[][] newArray = new int[row][col];
        Storage temp = ls.getNode();
        while (true){
            if (temp.getNext() == null){
                break;
            }
            temp = temp.getNext();
            newArray[temp.getRow()][temp.getCol()] = temp.getVal();
        }
        System.out.println("-----------------------链表复原的棋盘-------------------------");
        for(int[] newRow:newArray){
            for (int val:newRow){
                System.out.print(val+" ");
            }
            System.out.println();
        }
    }

2.2 队列

2.2.1 队列的介绍

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作、和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为对头。

1. 队列是一个有序列表，可以用数组和链表来实现
2. 队列先进先出，即是先入队列的数据最先被取出，后入的数据后取出。

2.2.2 数组模拟队列的场景

ArrayQuerue类

/**
 * 模拟队列类
 */
public class ArrayQuerue {
    //定义一个数组
    private int[] array;
    //数组最大容量
    private int maxSize;
    //头指针
    private int front;
    //队尾指针
    private int rear;

    /**
     * 初始化数组容量大小和指针的值
     * @param maxSize
     */
    public ArrayQuerue(int maxSize){
        this.maxSize = maxSize;
        array = new int[maxSize];
        front = -1;
        rear = -1;
    }

    /**
     * 判断队列是否已满
     * @return
     */
    public boolean isFull(){
        return maxSize-1 == rear;
    }

    /**
     * 判断队列是否为空
     * @return
     */
    public boolean isNull(){
        return front == rear;
    }

    /**
     *添加元素
     * @param i
     */
    public void add(int i){
        if (isFull()){
            throw new RuntimeException("队列已满");
        }
        rear++;
        array[rear] = i;
    }

    /**
     * 获取元素
     * @return
     */
    public int get(){
        if (isNull()){
            throw new RuntimeException("队列为空");
        }
        front++;
        return array[front];
    }

    /**
     * 查看所有的元素
     * @return
     */
    public void getAll(){
        for (int i = 0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
    }
}

测试类

  public static void main(String[] args) {
        ArrayQuerue aq = new ArrayQuerue(5);
        //存数据
        aq.add(2);
        aq.add(1);
        aq.add(3);
        aq.add(4);
        aq.add(5);
        //出队列
        System.out.println(aq.get());
        //查看所有元素
        aq.getAll();
    }

3 递归

3.1 递归的介绍

递归就是方法自己去调用自己，每次调用时传入的参数是不同的，递归有助于解决程序中复杂的问题，同时可以让代码更加简介。

3.2 递归的规则

1. 执行一个方法时，就创建一个新的受保护的对立栈空间
2. 方法的局部变量时独立的，不会相互影响
3. 如果方法中使用的是引用型类型变量，不如数组，则会共享引用型的数据
4. 递归必须向退出的递归条件接近，否则就是无线递归，会出现StackOverflowError
5. 一个方法执行完毕后，或者遇到return，就会返回数据，遵守谁调用就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕

3.3 递归解决迷宫问题

分析：用一个二维数组表示迷宫，0表示通路，1表示围墙，2表示已经走过的格子，不允许往回走，3表示路走不通，给定入口和出口，寻找所有可能的通路。

  //定义一个二维数组，模拟迷宫
    public int[][] array = new int[8][7];

    /**
     * 设置迷宫障碍
     */
    public void setMaze(){
        //1代表障碍物
        for (int i=0;i<7;i++){
            array[0][i] = 1;
            array[7][i] = 1;
        }
        for (int j=0;j<8;j++){
            array[j][0] = 1;
            array[j][6] = 1;
        }
        array[3][1] = 1;
        array[3][2] = 1;
        array[2][3] = 1;
        array[5][2] = 1;
        array[5][4] = 1;
        array[5][5] = 1;
    }

    public static boolean road(int map[][],int i,int j) {
        if (map[6][5] == 2) {
            return true;
        } else {
            if (map[i][j] == 0) {
                map[i][j] = 2;
                if (road(map, i, j + 1)) {
                    return true;
                } else if (road(map, i + 1, j)) {
                    return true;
                } else if (road(map, i , j-1)) {
                    return true;
                } else if (road(map, i-1, j )) {
                    return true;
                } else {
                    map[i][j] = 3;
                    return false;
                }
            } else {
                return false;
            }
        }
    }
    /**
     * 查看迷宫
     */
    public void findMaze(){
        for (int i=0;i<8;i++){
            for (int j=0;j<7;j++){
                System.out.print(array[i][j]+" ");
            }
            System.out.println();
        }
    }

    public int[][] getArray() {
        return array;
    }

    public void setArray(int[][] array) {
        this.array = array;
    }

测试类

public class MazeTest {
    public static void main(String[] args) {
        Maze mz = new Maze();
        mz.setMaze();
        mz.findMaze();
        System.out.println("--------------------");
        Maze.road(mz.getArray(),1,1);
        mz.findMaze();
    }
}