自定义实现单链表增删改查、栈的入栈和出栈

最新推荐文章于 2022-08-19 20:03:24 发布

星际迷航‖

最新推荐文章于 2022-08-19 20:03:24 发布

阅读量570

点赞数 4

分类专栏：算法文章标签：链表数据结构单链表算法 java

本文链接：https://blog.csdn.net/weixin_44048140/article/details/113060641

版权

算法专栏收录该内容

9 篇文章 0 订阅

订阅专栏

开心学习算法数据结构的第三天

内容

单链表

单链表的概念

1.什么是单链表？

单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以节点来表示的，每个节点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。存放的数据是不连续的。

以下是链表的指向不连续。
在这里插入图片描述
实际结构：

2.单链表相对于数组有哪些优缺点？

数组：

优点：随机访问性强，查找速度快

缺点:
1、对内存的要求高，必须要连续的内存空间
2、插入和删除的效率比较低
3、数组大小固定，动态拓展性差，而且可能浪费内存

链表

优点：
1、对内存的要求低
2、大小可以不固定，内存的利用率比较高
3、插入和删除方便

缺点：查找效率低，不可以随机查找，每次查找必须从头开始

单链表实现

创建链表结构

使用内部类创建一个Node节点类

class singleLinked<E>{
	//记录头节点
    private Node<E> head;
    //记录元素的个数
    private int size;
    class Node<E>{
        private E val;
        private Node<E> next;
        public Node(E val,Node<E> next){
            this.val = val;
            this.next = next;
        }
    }
    public SingleLinked() {
        this.head = new Node(0,null);
    }
}

尾插法

在这里插入图片描述
这里需要注意的是：临时节点走到最后一个节点然后使之指向新的节点。

	//尾插法
    public void addLast(E val){
        Node<E> node = head;
        Node<E> newNode = new Node<>(val,null);
        while(node.next != null){
            node = node.next;
        }
        node.next = newNode;
        size++;
    }

头插法

在这里插入图片描述
如图让新的这个节点指向第一个节点也就是head指向的节点，其次就是head从新指向newNode。

//头插法
    public void addHead(E val){
        Node<E> newNode = new Node<>(val,null);
        newNode.next = head.next;
        head.next = newNode;
        size++;
    }

指定索引位置插入元素

在这里插入图片描述
如图创建临时节点遍历找到如图的node然后就有了图中的指向连线，原来的连线就会消失。

	//在指定索引处插入元素
    public boolean add(int pos,E val){
        //判断索引的合法性
        if (pos <= 0 || pos > getSize()){
            System.out.println("索引不规范");
            return false;
        }
        //索引合法找到要插入元素前一个位置
        int index = 1;
        Node<E> node = head.next;
        while (index++ < pos-1){
            node = node.next;
        }
        Node<E> newNode = new Node<>(val,null);
        newNode.next = node.next;
        node.next = newNode;
        size++;
        return true;
    }

删除指定位置节点

在这里插入图片描述
如图创建临时节点找到要删除节点的前一个节点然后让当前节点指向下一个节点的节点。

	//删除指定位置节点
    public boolean remove(int pos){
        //判断是否是空链表
        if (head.next == null) {
            System.out.println("此链表为空链表！！！");
            return false;
        }
        //判断索引的合法性
        if (pos <= 0 || pos > getSize()){
            System.out.println("索引异常");
            return false;
        }
        //进行删除操作
        int index = 1;
        Node<E> node = head;
        while (index++ < pos){
            node = node.next;
        }
        Node tmp = node.next;
        node.next = tmp.next;
        size--;
        return true;
    }

获取节点个数

	//获取链表元素个数
    public int getSize(){
        return this.size;
    }

修改指定位置元素

这里不需要画图了找到指定位置直接对其对应的val修改即可。

	//修改指定位置节点的值
    public boolean modifyNode(int pos,E val){
        if (pos <= 0 || pos > getSize()){
            System.out.println("下标异常");
            return false;
        }
        Node<E> node = head.next;
        int index = 1;
        while (index < pos){
            node = node.next;
        }
        node.val = val;
        return true;
    }

显示链表

创建一个临时节点从头到尾遍历。

	//显示链表
    public void showLinked(){
        Node<E> node = head.next;
        if (node == null){
            System.out.println("链表为空");
            return;
        }
        while (node != null){
            System.out.print(node.val+" ");
            node = node.next;
        }
    }

代码汇总

class SingleLinked<E>{

    private Node<E> head;
    private int size;

    class Node<E>{
        private E val;
        private Node<E> next;

        public Node(E val,Node<E> next){
            this.val = val;
            this.next = next;
        }
    }

    public SingleLinked() {
        this.head = new Node(0,null);
    }

    //尾插法
    public void addLast(E val){
        Node<E> node = head;
        Node<E> newNode = new Node<>(val,null);
        while(node.next != null){
            node = node.next;
        }
        node.next = newNode;
        size++;
    }

    //头插法
    public void addHead(E val){
        Node<E> newNode = new Node<>(val,null);
        newNode.next = head.next;
        head.next = newNode;
        size++;
    }

    //在指定索引处插入元素
    public boolean add(int pos,E val){
        //判断索引的合法性
        if (pos <= 0 || pos > getSize()){
            System.out.println("索引不规范");
            return false;
        }
        //索引合法找到要插入元素前一个位置
        int index = 1;
        Node<E> node = head.next;
        while (index++ < pos-1){
            node = node.next;
        }
        Node<E> newNode = new Node<>(val,null);
        newNode.next = node.next;
        node.next = newNode;
        size++;
        return true;
    }

    //删除指定位置节点
    public boolean remove(int pos){
        //判断是否是空链表
        if (head.next == null) {
            System.out.println("此链表为空链表！！！");
            return false;
        }
        //判断索引的合法性
        if (pos <= 0 || pos > getSize()){
            System.out.println("索引异常");
            return false;
        }
        //进行删除操作
        int index = 1;
        Node<E> node = head;
        while (index++ < pos){
            node = node.next;
        }
        Node tmp = node.next;
        node.next = tmp.next;
        //回收内存
        tmp = null;
        size--;
        return true;
    }

    //获取链表元素个数
    public int getSize(){
        return this.size;
    }

    //修改指定位置节点的值
    public boolean modifyNode(int pos,E val){
        if (pos <= 0 || pos > getSize()){
            System.out.println("下标异常");
            return false;
        }
        Node<E> node = head.next;
        int index = 1;
        while (index < pos){
            node = node.next;
        }
        node.val = val;
        return true;
    }

    //显示链表
    public void showLinked(){
        Node<E> node = head.next;
        if (node == null){
            System.out.println("链表为空");
            return;
        }
        while (node != null){
            System.out.print(node.val+" ");
            node = node.next;
        }
    }
}

单链表个别面试题

查询倒数第k个元素

实现思路获取到链表的长度这里需要注意不包括head节点，所以长度减k就是正数的目标值。

	//获取倒数第k个元素
    public E getVal(int k){
        int index = 0;
        if (head.next == null){
            System.out.println("链表为空");
            return null;
        }
        Node node = head.next;
        while (index++ < (getSize() - k)){
            node = node.next;
        }
        return (E)node.val;
    }

这里还有一种算法将所有节点入栈，出栈几次就可以找到目标值。

反转链表

在这里插入图片描述
如图是一次循环的结果

	//反转单链表
    public void reserve(){
        if (head.next == null || head.next.next == null){
            return;
        }
        //定义一个辅助指针
        Node cur = head.next;
        Node next = null;//指向当前节点的下一个节点
        Node pre = null;
        while (cur != null){
            next = cur.next;//保存当前节点的下一个节点
            cur.next = pre;//让当前节点指向前一个节点
            pre = cur;//准备节点后移一个
            cur = next;
        }
        head.next = pre;
    }

栈

什么是栈？

栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

在这里插入图片描述

构造栈

class stack<E>{
    private E[] arr;
    //size指向栈顶上面的一个元素
    private int size;
    public stack(int capacity){
        arr = (E[]) new Object[capacity];
    }
}

push入栈

	//入栈
    public void push(E val){
    	//判满
        if (isFull()){
        	//扩容
            ensureCapacity();
        }
        arr[size++] = val;
    }

pop出栈

这里有个问题就是System.arraycopy函数将arr变成了有效元素个数，下一次push必须要扩容。

	//出栈
    public E pop(){
        //判空
        if (isEmpty()){
            throw new RuntimeException("空栈");
        }
        //出栈一次就要进行元素的移动
        E val = arr[size-1];
        this.size--;
        this.arr = Arrays.copyOf(this.arr,this.arr.length-1);
        return val;
    }

isFull判满

	//判满
    public boolean isFull(){
        return this.size == this.arr.length;
    }

isEmpty判空

	//判空
    public boolean isEmpty(){
        return this.size == 0;
    }

ensureCapacity扩容

	//扩容
    public void ensureCapacity(){
        if (size == arr.length){
        	//1.5倍扩容
            this.arr = Arrays.copyOf(arr, arr.length + arr.length / 2);
        }
    }

代码汇总

class stack<E>{
    private E[] arr;
    private int size;
    public stack(int capacity){
        arr = (E[]) new Object[capacity];
    }

    //入栈
    public void push(E val){
        if (isFull()){
            ensureCapacity();
        }
        arr[size++] = val;
    }

    //出栈
    public E pop(){
        //判空
        if (isEmpty()){
            throw new RuntimeException("空栈");
        }
        //出栈一次就要进行元素的移动
        E val = arr[size-1];
        this.size--;
        this.arr = Arrays.copyOf(this.arr,this.arr.length-1);
        return val;
    }

    //判空
    public boolean isEmpty(){
        return this.size == 0;
    }

    //判满
    public boolean isFull(){
        return this.size == this.arr.length;
    }

    //扩容
    public void ensureCapacity(){
        if (size == arr.length){
            this.arr = Arrays.copyOf(arr, arr.length + arr.length / 2);
        }
    }
}

看完觉得有用点个赞呗~

星际迷航‖

关注

4
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
自定义实现单链表增删改查、栈的入栈和出栈

开心学习算法数据结构的第三天内容单链表单链表的概念1.什么是单链表？单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以节点来表示的，每个节点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。存放的数据是不连续的。以下是链表的指向不连续。实际结构：2.单链表相对于数组有哪些优缺点？数组：优点：随机访问性强，查找速度快缺点:1、对内存的要求高，必须要.
复制链接

扫一扫