Java数据结构与算法 （笔记1）

最新推荐文章于 2023-03-29 13:26:36 发布
最新推荐文章于 2023-03-29 13:26:36 发布
阅读量75 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51092636/article/details/115712225
版权

Java数据结构与算法 （笔记1） 2021-4-8

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

字符串匹配问题：

  1. 有一个字符串str1=”年后到了看了看四点零六，随即离开房间，就两个空间“。Str2=”随即离开房间”
  2. 搬盘子的游戏
  3. 8皇后游戏
  4. 马踏棋盘

数据结构和算法的重要性：

算法是一个程序的灵魂

数据结构+算法=程序 要学习好数据结构就要多多的思考生活中遇到的问题，用程序去解决实际问题。数据结构是算法的基础，想要学习好算法，就需要把数据结构学习到位。

1. 数据结构：线性结构和非线性结构

###1.1 线性结构

  1. 线性结构：结构中的数据元素存在一对一的线性关系。
  2. 非线性结构：结构中的元素不存在一对一的线性关系。例如：一对多的树形结构，多对多的图形结构
  3. 常见的线性结构：数组，队列，链表，栈

1.2 非线性结构

常见的非线性结构：二维数组，多维数组，广义表，树结构，图结构

1.3数据的存储结构

  1. 顺序存储结构 例如：数组

  2. 链式存储结构 例如：链表

1.4 例子：稀疏数组的应用：

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

处理方法:

  1. 记录数组中一共有几行几列，有多少不同的值

  2. 把具有不同元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模

  3. 案例分析：

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Fn8q7suR-1618412920983)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210408135959309.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-APQOEA42-1618412920986)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210408135849964.png)]

  4. 二维数组转变为稀疏数组的思路；
    4.1 遍历二维数组，得到里面的有效数据的个数 sum

    4.2 根据sum可以确定稀疏数组的列数是sum+1

    4.3将二维数组的数据存入到稀疏数组中第一列存行，第二列存列，第三列存值

5.稀疏数组还原成原来数组的思路：

  1. 首先读取稀疏数组的第一行，根据第行的数据创建出原始数组的大小
  2. 再读取稀疏数组后几行的数据，赋值到原始的二维数组
public class SpareArray {
    public static void main(String[] args) {
        int[][] array = new int[7][9];
        array[1][3]=5;
        array[5][7]=19;
        array[4][4]=8;
        //遍历输出原始二维数组，记录一下原始二维数组中的有效值的个数
        int sum=0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]+"\t");
                if (!(array[i][j]==0)){
                    sum++;
                }
            }
            System.out.println();
        }
        System.out.println(sum);
        System.out.println();

        //创建一个稀疏数组
        int[][] spareArray = new int[sum + 1][3];
        spareArray[0][0]=7;
        spareArray[0][1]=9;
        spareArray[0][2]=sum;
           int k=0;//设置spareArray初始指向行为0的位置
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j]!=0){
                    k++;//行＋1
                    spareArray[k][0]=i;//记录有效数据的行
                    spareArray[k][1]=j;//记录有效数据的列
                    spareArray[k][2]=array[i][j];//记录有效数据的值
                }
            }
        }
//遍历出稀疏数组
        for (int[] ints : spareArray) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        //稀疏数组转原始的二维数组的
        int[][] newArray = new int[spareArray[0][0]][spareArray[0][1]];
        for (int i = 1; i < spareArray.length; i++) {
            for (int j = 1; j < spareArray[i].length; j++) {
                newArray[spareArray[i][0]][spareArray[i][1]]=spareArray[i][2];
            }
        }
        for (int[] ints : newArray) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}

#Java数据结构与算法 （笔记2） 2021-4-9

2. 队列的应用场景和介绍

  1. 应用场景：银行的排队办理业务

  2. 队列的介绍：

    队列是一个有序列表，可以用数组或者是链表来实现。遵循先入先出的原则。

    队列（Queue）是只允许在一端进行插入，而在另一端进行删除的运算受限的线性表。

    （1）允许删除的一端称为队头（Front）。

    （2）允许插入的一端称为队尾（Rear）。
    （3）当队列中没有元素时称为空队列。
    （4）队列亦称作先进先出（First In First Out）的线性表，简称为FIFO表。

    ​ 队列的修改是依先进先出的原则进行的。新来的成员总是加入队尾，每次离开的 成员总是队列头上的（不允许中途离队）。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J7OS4WNs-1618412920987)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210408211146889.png)]

  3. 顺序队列的示意图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5V7yMxTH-1618412920989)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210408211501873.png)]

使用数组模拟队列

代码实现思路:

  1. .首先创建一个实现队列的自定义的类，里面包含一个数组，大小为maxsize（就是队列的长度）

  2. 定义一个头部指针front指向队列的头部的前一个位置，用于出队列，定义一个尾部指针rear用来存入数据到队列中

  3. front和rear的默认值都是-1，所以取数据和存数据之前都要＋1。

  4. 定义几个队列的操作方法:

    //判断队列是否已经满
public boolean isFull(){
    return rear==maxSize-1;
}
//判断对列是否为空
public boolean isEmpty(){
    return rear==front;

  //添加数据到队列中去
    public void addQueue(int n){
        //首先判断队列是否已经满了
        if (isFull()){
            System.out.println("队列已经满了，不能再添加数据了");
            return;
        }
        else {
            rear++;
            arr[rear]=n;
        }
    }
    //数据出队列
    public int getQueue(){
        //判断队列是否为空
        if (isEmpty()){
            throw new RuntimeException("队列为空，不能取数据");//直接导致我们的代码终止
        }
        front++;
        return arr[front];
    }
    //显示队列的所有数据
    public void showQueue(){
        if (isEmpty()){
            System.out.println("队列是空的，没有数据！");
        }
        for (int i : arr) {
            System.out.print(i+"\t");
        }
        System.out.println();
    }
    //显示队列的头数据
    public int headQueue(){
        if (isEmpty()){
            throw new RuntimeException("队列是空，没有数据！");
        }
        return arr[front+1];
    }
}

    完整代码：

    package queue;


import java.util.Scanner;

/**
 * @Authoer:duan
 * @Date:2021/04/08/21:17
 * @Description:
 * 使用数组模拟一个队列
 */
public class ArrayQueue {
    public static void main(String[] args) {
       //创建一个队列
        arr arrayqueues= new arr(3);
        char key;//接受用户的输入
        Scanner scanner = new Scanner(System.in);//
        boolean loop=true;
        while (loop){
            System.out.println("s(show):显示队列");
            System.out.println("e(exit):退出队列");
            System.out.println("a(add):添加数据到队列");
            System.out.println("g(get):从队列取出数据");
            System.out.println("h(head):查看队列的头数据");
            key=scanner.next().charAt(0);//接受一个字符
            switch (key)
            {
                case 's':
                    arrayqueues.showQueue();
                    break;
                case 'a':
                    System.out.println("输入一个数");
                    int value=scanner.nextInt();
                    arrayqueues.addQueue(value);
                    break;
                case 'g':
                    try {
                        int res = arrayqueues.getQueue();
                        System.out.println("取出的数据是"+res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case'h':
                    try {
                        int i = arrayqueues.headQueue();
                        System.out.println("队列头的数据是"+i);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case'e'://退出
                    scanner.close();
                    loop=false;
                    break;
                default:
                    System.out.println("输入的字符有误！重新输入" );

            }
        }
        System.out.println("程序退出！");

    }
}
 class arr {
    private int maxSize;//表示数组的最大容量，就是队列的最大容量
    private int front;//指向队列头
    private int rear;//指向队列尾
    private int[] arr;//该数组用来存放数据，模拟队列

    //常见队列的构造器
    public arr(int arrmaxSize){
        maxSize=arrmaxSize;
        arr=new int[maxSize];
        front=-1;//分析出front是指向队列的前一个位置
        rear=-1;//指向队列的尾部，指向队列尾部的数据（即队列的最后一个数据）


    }
    //判断队列是否已经满
    public boolean isFull(){
        return rear==maxSize-1;
    }
    //判断对列是否为空
    public boolean isEmpty(){
        return rear==front;

    }
    //添加数据到队列中去
    public void addQueue(int n){
        //首先判断队列是否已经满了
        if (isFull()){
            System.out.println("队列已经满了，不能再添加数据了");
            return;
        }
        else {
            rear++;
            arr[rear]=n;
        }
    }
    //数据出队列
    public int getQueue(){
        //判断队列是否为空
        if (isEmpty()){
            throw new RuntimeException("队列为空，不能取数据");//直接导致我们的代码终止
        }
        front++;
        return arr[front];
    }
    //显示队列的所有数据
    public void showQueue(){
        if (isEmpty()){
            System.out.println("队列是空的，没有数据！");
        }
        for (int i : arr) {
            System.out.print(i+"\t");
        }
        System.out.println();
    }
    //显示队列的头数据
    public int headQueue(){
        if (isEmpty()){
            throw new RuntimeException("队列是空，没有数据！");
        }
        return arr[front+1];
    }
}

    问题：

    ①“下溢”现象
    当队列为空时，做出队运算产生的溢出现象。“下溢”是正常现象，常用作程序控制转移的条件。

    ② "真上溢"现象
    当队列满时，做进栈运算产生空间溢出的现象。“真上溢”是一种出错状态，应设法避免。

    ③ "假上溢"现象
    由于入队和出队操作中，头尾指针只增加不减小，致使被删元素的空间永远无法重新利用。当队列中实际的元素个数远远小于内存中本分配的空间时，也可能由于尾指针已超越向量空间的上界而不能做入队操作。该现象称为"假上溢"现象。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4xjJrNfa-1618412920990)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210409144547192.png)]

    问题分析和优化：

    1. 目前数组只能使用一次，没有达到复用的效果
    2. 将这个数组使用算法，改成一个环形的队列。使用取模的方式来完成

    思想：

    1. front变量的含义做一个调整：front就是指向队列的第一个元素，也就是arr[front]就是队列的第一个元素，front的初始值就是0；

    2. rear变量的含义做一个调整：rear指向队列的最后一个元素的后一个位置，因为希望空出一个空间作为约定，rear的初始值就是0；

    3. 队列满的时候的条件就是（rear+1）%maxsize=front

    4. 队列空的时候的条件就是rear=front

    5. 队列中的有效元素的个数是（rear+maxsize-front）%maxsize

    6. 我们就可以在原来的队列上修改得到环形队列

      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jmC4uM73-1618412920991)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210409155520654.png)]

    package queue2;
import java.util.Scanner;
/**
 * @Authoer:duan
 * @Date:2021/04/09/15:56
 * @Description:
 package queue2;
*/
public class CircleArrayQueue {
    public static void main(String[] args) {
        System.out.println("测试数组模拟环形队列！！");
        //创建一个队列
        Arrayqueue arrayqueues = new Arrayqueue(4);//其队列的有效数据最大是3，有一个约定为空的空间
        char key;//接受用户的输入
        Scanner scanner = new Scanner(System.in);//
        boolean loop=true;
        while (loop){
            System.out.println("s(show):显示队列");
            System.out.println("e(exit):退出队列");
            System.out.println("a(add):添加数据到队列");
            System.out.println("g(get):从队列取出数据");
            System.out.println("h(head):查看队列的头数据");
            key=scanner.next().charAt(0);//接受一个字符
            switch (key)
            {
                case 's':
                    arrayqueues.showQueue();
                    break;
                case 'a':
                    System.out.println("输入一个数");
                    int value=scanner.nextInt();
                    arrayqueues.addQueue(value);
                    break;
                case 'g':
                    try {
                        int res = arrayqueues.getQueue();
                        System.out.println("取出的数据是"+res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case'h':
                    try {
                        int i = arrayqueues.headQueue();
                        System.out.println("队列头的数据是"+i);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case'e'://退出
                    scanner.close();
                    loop=false;
                    break;
                default:
                    System.out.println("输入的字符有误！重新输入" );

            }
        }
        System.out.println("程序退出！");

    }
}

public class Arrayqueue {
    private int maxSize;//表示数组的最大容量，就是队列的最大容量
    private int front;//指向队列头
    private int rear;//指向队列尾的后面一个位置
    private int[] arr;//该数组用来存放数据，模拟队列

    public Arrayqueue(int maxSize) {
        this.maxSize = maxSize;
        front=0;
        rear=0;
        arr=new int[maxSize];
    }
    //判断队列是否已经满
    public boolean isFull(){
        return (rear+1)%maxSize==front;
    }
    //判断对列是否为空
    public boolean isEmpty(){
        return rear==front;

    }
    //添加数据到队列中去
    public void addQueue(int n){
        //首先判断队列是否已经满了
        if (isFull()){
            System.out.println("队列已经满了，不能再添加数据了");
            return;
        }
        else {
           //直接将数据加入
            arr[rear]=n;
            //将rear后移位,但是这里必须要取模
            rear=(rear+1)%maxSize;
        }
    }
    //数据出队列
    public int getQueue(){
        //判断队列是否为空
        if (isEmpty()){
            throw new RuntimeException("队列为空，不能取数据");//直接导致我们的代码终止
        }
        //这里的需要分析出front指向队列的第一个元素
        //1.首先把front对应的值保留到一个临时的变量中
        //2.将front后移，采用取模的方式
        //3.将临时保存的变量返回
        int value = arr[front];
        front=(front+1)%maxSize;
        return value;
    }
    //显示队列的所有数据
    public void showQueue(){
        if (isEmpty()){
            System.out.println("队列是空的，没有数据！");
        }
     //思路：从front开始遍历，遍历多少个元素    求出当前数组的有效数据

        for (int i=front;i<front+size();i++){
            System.out.print("arr["+i%maxSize+"]"+"="+arr[i%maxSize]+"\t");
        }
        System.out.println();
    }
    //求出当前数组的有效数据
    public int size(){
    return (rear+maxSize-front)%maxSize; }

    //显示队列的头数据
    public int headQueue(){
        if (isEmpty()){
            throw new RuntimeException("队列是空，没有数据！");
        }
        return arr[front];
    }
}

#java数据结构与算法（笔记3）2021-4-14(星期三)

3.链表介绍：

  1. 链表是以节点的方式来存储

  2. 每一个节点包含data域和next域，data域中存放数据，next域中存放下一个节点的地址，用来指向下一个节点。

  3. 如图，链表的各个节点不一定是连续存储

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TN0921E4-1618412920991)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210414081410292.png)]

  4. 链表带有头节点的链表和没有头节点的链表，根据实际需求来确定
  5. 单链表的逻辑结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WxClN5GN-1618412920992)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210414082609729.png)]

4.单向链表的应用实例

使用带有head头的单向链表实现水浒传英雄排行榜的管理

  1. 完成对人物的增删改查，
  2. 第一种方法添加英雄时候，直接添加英雄到链表的尾部
  3. 第二种方法添加英雄的时候，根据英雄的排名插入到指定的位置，如果没有这个排名，就添加失败，给出提示信息

添加（创建）：

  1. 首先，创建一个head头节点，作用是表示单链表的头部
  2. 后面我们每次添加一个节点直接加入到链表的最后

遍历：

  1. 通过一个辅助指针，帮助我们遍历整个链表

【实例，创建一个单向链表，不考虑添加对象的顺序排列和输出】

package linkedList;
/**
 * @Authoer:duan
 * @Date:2021/04/14/8:44
 * @Description:
 */
public class singlelinkedlist {
    public static void main(String[] args) {
     //测试单向链表
        //创建几个节点

        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode hero3= new HeroNode(3, "吴用", "智多星");
        HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
        //创建链表
        single single = new single();
        single.add(hero1);
        single.add(hero2);
        single.add(hero3);
        single.add(hero4);
        //遍历链表
        single.list();
    }
}

//定义一个单向链表
class single{
    //先初始化一个头节点，头节点不要动，不存放具体的数据
    private HeroNode head=new HeroNode(0,"","");

    //添加节点，到单向链表
    //思路：不考虑编号顺序的时候------找到当前链表的最后节点的位置------将最后一个节点的next域指向新的节点

    public void add(HeroNode heroNode){
        //----因为head不能动，我们需要一个辅助变量，指向head节点
        HeroNode temp=head;
        //遍历链表，找到最后
        while(true){
            //temp.next==null;就是链表的最后
            if (temp.next==null){
                break;
            }
            //如果没有找到最后，就让temp后移
            temp=temp.next;
        }
        //当退出while循环后，temp就指向链表的最后
        //将最后这个节点的next指向新的节点
        temp.next=heroNode;
    }
    //显示链表【遍历】
    public void list(){
        //判断链表是否为空
     if (head.next==null){
    System.out.println("链表为空！");
    return;
   }
     //因为head不能动，因此我们需要一个辅助变量来遍历
        HeroNode temp=head.next;
     while (true){
         //判断是否到链表的最后
         if (temp==null){
             break;
         }
         //输出节点的信息
         System.out.println(temp);
         //将temp后移，一定要小心
         temp=temp.next;
     }
    }

}
//定义一个HeroNode 每一个HeroNode对象都是一个节点
 class HeroNode{
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;//指向下一个节点

    public HeroNode(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

[实例，按照排名添加数据]

需要按照编号的顺序添加

  1. 首先，要找到新添加的节点的位置。通过一个辅助变量
  2. 新的节点的next=temp.next
  3. 将temp.next=新的节点的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7FvkvFyv-1618412920993)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210414120613267.png)]

public void add2(HeroNode heroNode){
     //头节点head不能动，通过辅助指针来帮助我们找到添加的位置
     //因为是单链表，因此我们找到的temp，我们找的temp是位于添加位置的前一个节点，否则插入不了
     HeroNode temp=head;
     boolean flag=false;//标识添加的编号是否存在，默认为false
     while(true){
         if (temp.next==null){
             //说明temp已经在链表的最后
             break;
         }
         if (temp.next.no>heroNode.no){
             //位置找到了，就是temp后面的位置
          break;
         }else if (temp.next.no== heroNode.no){
             //说明希望添加的HeroNode的编号已然存在，添加失败
             flag=true;//说明标号存在
             break;
         }
         temp=temp.next;
     }
     //判断flag
     if (flag){
         System.out.println("准备插入的英雄编号已经存在"+heroNode+"不能再加入！");
     }
     else {
         //插入新的数据
         heroNode.next=temp.next;
         temp.next=heroNode;
     }
 }

public class singlelinkedlist {
    public static void main(String[] args) {
     //测试单向链表
        //创建几个节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode hero3= new HeroNode(3, "吴用", "智多星");
        HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
        HeroNode hero6 = new HeroNode(6, "康佳", "小饺子");

        //创建链表
        single single = new single();
       
        System.out.println("========================按照顺序添加测试================");
        single.add2(hero1);
        single.add2(hero2);
        single.add2(hero6);
        single.add2(hero3);
        single.add2(hero4);
        //没有按照顺序添加数据，但是会自动按按照顺序链接成链表
        single.list();

    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Uelp8QVs-1618412920993)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210414214901302.png)]

单向链表修改节点方法：

【思路】：

  1. 判断链表的头节点的next是否为null,如果为null，那么这个链表为空，无法修改

  2. 创建一个辅助变量temp指向head，判断temp的no是不是需要修改变量的no

  3. 如果是那么就修改

    temp.name=newheronode.name;
temp.nickname=newheronode.nickname;

  4. 如果不是就temp=temp.next后移，遍历整个链表，找到为止

  5. 代码实现：

      public void update(HeroNode newheronode){
        if (head.next==null){
            System.out.println("链表为空");
            return;
        }
        //定义一个辅助变量
        HeroNode temp=head.next;
        boolean flag=false;//表示是否找到该节点
        while (true){
            if (temp==null) {//已经遍历完链表
                break;
            }
            if (temp.no==newheronode.no){
                //找到了需要修改的节点
                flag=true;
                break;
            }
            temp=temp.next;
        }
            //根据flag判断是否需要修改的节点
            if (flag){
                temp.name=newheronode.name;
                temp.nickname=newheronode.nickname;
            }else{
                System.out.println("没有找到标号为"+newheronode.no+"节点，修改失败!");
            }


        }

    System.out.println("=====================修改节点测试====================");
HeroNode newheronode = new HeroNode(2, "段睿", "菜鸡");
single.update(newheronode);
single.list();

测试结果；

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-K1tobdwv-1618412920994)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210414214947898.png)]

从链表中删除一个数据节点:

思路:

  1. 创建一个辅助变量temp，找到需要删除节点的前一个位置

  2. temp.next=temp.next.next

  3. 删除后的节点，将不会被其他所指向，会被垃圾回收机制回收

  4. 代码实现:

        System.out.println("===================删除节点测试<使用编号删除>================");
        single.delete(2);
        single.list();
 /*
    思路：
    head头节点不能动，我们需要一个temp辅助节点找到需要删除的节点的前一个节点
    这时候我们需要将temp.next.no和需要删除的no进行比较
     */
    public void delete(int no){
        HeroNode temp=head;
        boolean flag=false;
        while (true){
            if (temp.next==null){
                break;
            }
            if (temp.next.no==no){
                //找到了需要删除的节点的上一个节点
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if (flag){
            temp.next=temp.next.next;
        }
        else{
            System.out.println("没有找到需要删除的节点，无法删除！");
        }

    }

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nj9Sjxr6-1618412920994)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210414215844242.png)]

5. 单向链表面试题（新浪，百度，腾讯）

  1. 求单向链表中的有效节点的个数

  2. 查找单向链表中的倒数第k个节点

  3. 单向链表的反转

  4. 从尾到头打印单向链表，要求：1.反向遍历 2.stack栈

  5. 合并两个有序的单向链表，合并之后单向链表仍然有序

  6. 求单向链表中的有效节点的个数【代码实现】

 //方法：获取单向链表的有效节点的方法（如果带有头节点，需要不统计头节点）
    /*
    head就是链表的头节点
     */
    public static int getlength(HeroNode head){
        if (head.next==null){
            return 0;
        }
        int length=0;
        HeroNode temp=head.next;//这里没有统计头节点
        while (temp!=null){
            length++;
            temp=temp.next;
        }
        return length;
    }

System.out.println("=============统计链表中有效节点测试====================");
System.out.println(single.getlength(single.gethead()));

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NIwa70rA-1618412920995)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210414221945714.png)]

  1. 查找单向链表中的倒数第k个节点
   /*
    查找单向链表中的倒数第k个节点
    思路：倒数第k个就是正数第getlength-k个
    设置一个辅助变量，通过循环移位，找到第getlengh-k个节点，将这个节点找到，返回
     */

public HeroNode findlastIndex(HeroNode head, int k) {
    if (head.next == null) {
        return null;
    }
    HeroNode temp = head.next;
    //调用getlength得到链表中有效节点的个数
    int length = single.getlength(gethead());
    if (k <= 0 || k > length) {
        return null;
    }
    for (int i = 0; i < length - k; i++)//如果是倒数第1个数，那么指针应该向后移动2位
    {
        temp = temp.next;
    }
    return temp;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hAskxkuP-1618412920995)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210414225843688.png)]

while (temp!=null){
length++;
temp=temp.next;
}
return length;
}


```java
System.out.println("=============统计链表中有效节点测试====================");
System.out.println(single.getlength(single.gethead()));

[外链图片转存中…(img-NIwa70rA-1618412920995)]

  1. 查找单向链表中的倒数第k个节点
   /*
    查找单向链表中的倒数第k个节点
    思路：倒数第k个就是正数第getlength-k个
    设置一个辅助变量，通过循环移位，找到第getlengh-k个节点，将这个节点找到，返回
     */

public HeroNode findlastIndex(HeroNode head, int k) {
    if (head.next == null) {
        return null;
    }
    HeroNode temp = head.next;
    //调用getlength得到链表中有效节点的个数
    int length = single.getlength(gethead());
    if (k <= 0 || k > length) {
        return null;
    }
    for (int i = 0; i < length - k; i++)//如果是倒数第1个数，那么指针应该向后移动2位
    {
        temp = temp.next;
    }
    return temp;
}

[外链图片转存中…(img-hAskxkuP-1618412920995)]

weixin_51092636
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java数据结构和算法学习笔记
01-05
中软国际培训的学习笔记，很值得参考。学习java数据结构很有必要看看
韩顺平老师尚硅谷Java数据结构与算法194集笔记
10-12
这是我从B站上看韩老师讲的数据结构与算法后整理的笔记 代码经过运行，欢迎批评指正 有些地方我感觉还是挺难的 大都经过我自己的语言进行描述，韩老师中期的表达可能或多或少也影响可阅读性，望先生们见谅
Java数据结构与算法学习笔记【队列】
番茄Salad
09-13 108
线性结构和非线性结构 常见的线性结构：数组（稀疏数组）、队列（单项队列、环形队列）、链表（单链表、环形链表、双链表）、栈（数组实现或链表实现）。 常见的非线性结构：二维数组、多维数组、广义表、树结构、图结构 队列 队列是一个有序列表，可以用数组或是链表来实现。 遵循先进先出的原则。 ...
数据结构与算法（Java版）学习笔记（一）
qq_31754355的博客
07-25 148
一、什么是数据结构和算法 数据结构是指数据在计算机存储空间（或磁盘）中的安排方式。算法是指软件程序 用来操作这些结构中的数据的过程。 例如： package Demo01; public class DemoTest01 { public static void main(String[] args) { int[] arr = new int[5]; for (int i = 0; i < arr.length; i++) {
Java数据结构与算法笔记_day01(上)
m0_51119239的博客
01-08 439
一、数据结构概述 数据：信息的载体，它是描述客观事物的数，字符以及所有的输入到计算机中被计算机程序识别加工处理的信息的集合。 数据项：字段或域。 数据元素：是数据的基本单元，是对一个客观实体的数据描述(信息或成绩一整条)。数据元素有一个或多个数据项组成。 数据对象：由相同性质的数据元素组成的，如集合{1,2,3…},{a,b,c…}(可以无限和有限)。 数据类型：具有相同性质的计算机数据的集合及定义在这个数据集合上的一组操作的总称（整型，实型。字符型，指针型等）。 数据结构：数据之间的相互关系（即数据的组织
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 33万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
Java数据结构和算法学习笔记
zth13015409853的博客
01-05 878
Java程序员必须要掌握的几种数据结构和算法
【尚硅谷】Java数据结构与算法笔记03 - 链表
知不足而奋进，望远山而前行
12-07 1万+
链表是有序的列表，它在内存中的存储如下：单链表(带头结点) 逻辑结构示意图如下：使用带 head 头的单向链表实现 - 水浒英雄排行榜管理完成对英雄人物的增删改查操作 输出： 2.3 面试题（新浪、百度、腾讯） 求单链表中有效节点的个数 查找单链表中的倒数第k个结点 单链表的反转 从尾到头打印单链表 合并两个有序链表 三、双向链表 3.1 思路分析 使用带 head 头的双向链表实现 - 水汻英雄排行榜管理单向链表的缺点分析:分析 双向链表的遍历, 添加, 修改, 删除的操作思路 ===>===>===
【尚硅谷】Java数据结构与算法笔记13 - 图
知不足而奋进，望远山而前行
03-29 4216
前面我们学了线性表和树线性表局限于一个直接前驱和一个直接后继的关系树也只能有一个直接前驱也就是父节点当我们需要表示多对多的关系时，这里我们就用到了图。
Java 数据结构与算法 （尚硅谷Java数据结构与算法）笔记目录
小白鼠丶
08-08 9755
红色的表示重要，绿色的表示暂时还不懂而且很重要 线性结构和非线性结构 队列 顺序队列 循环队列 链表 链表(Linked List)介绍 链表是有序的列表，但是它在内存中是存储如下 小结: 1) 链表是以节点的方式来存储,是链式存储 2)每个节点包含 data 域， next 域：指向下一个节点. 3)如图：发现链表的各个节点不一定是连续存储. 4)链表分带头节点...
Java数据结构和算法笔记.pdf
03-16
sgg数据结构和算法笔记
Java数据结构与算法-笔记-代码-课件-资料
05-17
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、...
Java数据结构和算法详细笔记
07-09
原博文指路：https://xiaoqistudy.blog.csdn.net/article/details/121134905?spm=1001.2014.3001.5502
数据结构与算法学习笔记（一）
Zhang_hongxin的博客
07-05 763
   本篇主要内容为数据结构与算法的入门和基本概念的了解      自学Java有了一段时间了，也参加了几个公司的笔试，结果发现，对于校招的同学来说，笔试中对于数据结构与算法的考察还是比较多的，这一系列的博客是对最近学习的数据结构与算法的记录，算是一个小小的读书笔记吧。       数据结构是计算机中存储、组织数据的方式。精心选择的数据结构可以带来最优效率的算法。学习之前先来看几个例子：   1、...
Java开发案例-springboot-66-自定义starter-源代码+文档.rar
05-31
Java开发案例-springboot-66-自定义starter-源代码+文档.rar Java开发案例-springboot-66-自定义starter-源代码+文档.rar Java开发案例-springboot-66-自定义starter-源代码+文档.rar Java开发案例-springboot-66-自定义starter-源代码+文档.rar Java开发案例-springboot-66-自定义starter-源代码+文档.rar Java开发案例-springboot-66-自定义starter-源代码+文档.rar
单家独院式别墅图纸D027-三层-12.80&10.50米-施工图.dwg
05-31
单家独院式别墅图纸D027-三层-12.80&10.50米-施工图.dwg
啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦
最新发布
05-31
啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦
java数据结构与算法笔记
07-25
Java数据结构与算法笔记是在学习B站尚硅谷Java数据结构与算法视频时所做的记录。\[1\]这个笔记包括了稀疏数组的作用和一个代码实例，以及不同时间复杂度的案例和空间复杂度的概念。\[2\]\[3\]在这个笔记中，你可以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值