动态链表的实现

最新推荐文章于 2023-03-03 14:54:33 发布
最新推荐文章于 2023-03-03 14:54:33 发布
阅读量192 收藏
点赞数
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54232564/article/details/122895106
版权

动态链表

这种链表在初始时不一定分配足够的空间, 但是在后续插入的时候需要动态申请存储空间，并且存储空间不一定连续, 在进行插入和删除时则不需要移动元素, 修改指针域即可,所以仍然具有链表的主要优点，链表结构可以是动态地分配存储的，即在需要时才开辟结点的存储空间，实现动态链接

单向链表

添加元素
在这里插入图片描述

public void add(int index, E element) {
    if(index < 0 || index > size){
        throw new IllegalArgumentException("下标越界");
    }
    Node n = new Node(element);

    if(size == 0){
        head = n;
        tail = n;
    }else if(index == 0){
        n.next = head;
        head = n;
    }else if(index == size){
        tail.next = n;
        tail = n;
    }else {
        Node p = head;
        for(int i = 0; i < index - 1; i++){
            p = p.next;
        }
        n.next = p.next;
        p.next = n;
    }
    size++;
}

删除元素
在这里插入图片描述

public E remove(int index) {
    if(index < 0 || index > size){
        throw new IllegalArgumentException("下标越界");
    }
    E ret = null;
    if(size == 1){
        ret = head.data;
        head = null;
        tail = null;
    }else if(index == 0){
        Node n = head;
        ret = n.data;
        head = n.next;
        n.next = null;
    }else if(index == size - 1){
        Node p = head;
        while(p.next != tail){
            p = p.next;
        }
        ret = tail.data;
        p.next = null;
        tail = p;
    }else{
        Node p = head;
        for(int i = 0; i < index - 1; i++){
            p = p.next;
        }
        Node n = p.next;
        ret = n.data;
        p.next = n.next;
        n.next = null;
    }
    size--;
    return ret;
}

单向链表实现

public class LinkedSinglyList<E> implements List<E> {

    //定义结点对象
    private class Node {
        E data;
        Node next;

        public Node() {
            this(null, null);
        }

        public Node(E data) {
            this(data, null);
        }

        public Node(E data, Node next) {
            this.data = data;
            this.next = next;
        }

        @Override
        public String toString() {
            return data.toString();
        }
    }

    private Node head;  //头指针
    private Node tail;  //尾指针
    private int size;   //元素个数

    public LinkedSinglyList() {
        head = null;
        tail = null;
        size = 0;
    }

    public LinkedSinglyList(E[] arr) {
        if (arr == null || arr.length == 0) {
            throw new IllegalArgumentException("数组为空");
        }
        for (int i = 0; i < arr.length; i++) {
            add(arr[i]);
        }
    }

    @Override
    public void add(E element) {
        add(size, element);
    }

    @Override
    public void add(int index, E element) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("下标越界");
        }
        Node n = new Node(element);

        if (size == 0) {
            head = n;
            tail = n;
        } else if (index == 0) {
            n.next = head;
            head = n;
        } else if (index == size) {
            tail.next = n;
            tail = n;
        } else {
            Node p = head;
            for (int i = 0; i < index - 1; i++) {
                p = p.next;
            }
            n.next = p.next;
            p.next = n;
        }
        size++;
    }

    @Override
    public void remove(E element) {
        int index = indexOf(element);
        if (index != -1) {
            remove(index);
        }
    }

    @Override
    public E remove(int index) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("下标越界");
        }
        E ret = null;
        if (size == 1) {
            ret = head.data;
            head = null;
            tail = null;
        } else if (index == 0) {
            Node n = head;
            ret = n.data;
            head = n.next;
            n.next = null;
        } else if (index == size - 1) {
            Node p = head;
            while (p.next != tail) {
                p = p.next;
            }
            ret = tail.data;
            p.next = null;
            tail = p;
        } else {
            Node p = head;
            for (int i = 0; i < index - 1; i++) {
                p = p.next;
            }
            Node n = p.next;
            ret = n.data;
            p.next = n.next;
            n.next = null;
        }
        size--;
        return ret;
    }

    @Override
    public E get(int index) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("下标越界");
        }
        if (index == 0) {
            return head.data;
        } else if (index == size - 1) {
            return tail.data;
        } else {
            Node p = head;
            for (int i = 0; i < index; i++) {
                p = p.next;
            }
            return p.data;
        }
    }

    @Override
    public E set(int index, E element) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("下标越界");
        }
        E ret = null;
        if (index == 0) {
            ret = head.data;
            head.data = element;
            return ret;
        } else if (index == size - 1) {
            ret = tail.data;
            tail.data = element;
            return ret;
        } else {
            Node p = head;
            for (int i = 0; i < index; i++) {
                p = p.next;
            }
            ret = p.data;
            p.data = element;
            return ret;
        }
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public int indexOf(E element) {
        Node p = head;
        int index = 0;
        while (!p.data.equals(element)) {
            p = p.next;
            index++;
            if (index == size) {
                return -1;
            }
        }
        return index;
    }

    @Override
    public boolean contains(E element) {
        return indexOf(element) != -1;
    }

    @Override
    public boolean isEmpty() {
        return size == 0 && head == null && tail == null;
    }

    @Override
    public void clear() {
        head = null;
        tail = null;
        size = 0;
    }

    @Override
    public void sort(Comparator<E> c) {
        if (c == null) {
            throw new IllegalArgumentException("比较器为空");
        }
        
        if (size == 0 || size == 1) {
            return;
        }
        Node nodeA = head;
        Node nodeB = nodeA.next;
        while (true) {
            while (true) {
                if (c.compare(nodeA.data, nodeB.data) > 0) {
                    swap(nodeA, nodeB);
                }
                if (nodeB == tail) {
                    break;
                }
                nodeB = nodeB.next;
            }
            if (nodeA.next == tail) {
                break;
            }
            nodeA = nodeA.next;
            nodeB = nodeA.next;
        }

    }

    private void swap(Node nodeA, Node nodeB) {
        E temp = nodeA.data;
        nodeA.data = nodeB.data;
        nodeB.data = temp;
    }

    @Override
    public List<E> subList(int fromIndex, int toIndex) {
        if (fromIndex < 0 || toIndex >= size || fromIndex > toIndex) {
            throw new IllegalArgumentException();
        }
        LinkedSinglyList<E> list = new LinkedSinglyList<>();
        Node nodeA = head;
        for (int i = 0; i < fromIndex; i++) {
            nodeA = nodeA.next;
        }

        Node nodeB = head;
        for (int i = 0; i < toIndex; i++) {
            nodeB = nodeB.next;
        }
        Node p = nodeA;
        while (true) {
            list.add(p.data);
            if (p == nodeB) {
                break;
            }
            p = p.next;
        }
        return list;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        if (isEmpty()) {
            sb.append(']');
        } else {
            Node p = head;
            while (true) {
                sb.append(p.data);
                if (p == tail) {
                    sb.append(']');
                    break;
                }
                sb.append(',');
                sb.append(' ');
                p = p.next;
            }
        }
        return sb.toString();
    }

    @Override
    public Iterator<E> iterator() {
        return new LinkedSinglyListIterator();
    }

    class LinkedSinglyListIterator implements Iterator<E> {
        private Node cur = head;

        @Override
        public boolean hasNext() {
            return cur != null;
        }

        @Override
        public E next() {
            E ret = cur.data;
            cur = cur.next;
            return ret;
        }
    }
}

单向循环列表

把单链表的最后一个节点的指针指向链表头部，而不是指向NULL，就构成了一个单向循环链表
在这里插入图片描述

增加删除元素

单向循环列表的增加和删除就是在单向链表的基础上保证尾指针的下一跳始终指向头指针

增加元素

 public void add(int index, E element) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("下标越界");
        }
        Node n = new Node(element);

        if (size == 0) {
            head = n;
            tail = n;
            tail.next = head;  //new code
        } else if (index == 0) {
            n.next = head;
            head = n;
            tail.next = head;   //new code
        } else if (index == size) {
            n.next = tail.next; //new code
            tail.next = n;
            tail = n;
        } else {
            Node p = head;
            for (int i = 0; i < index - 1; i++) {
                p = p.next;
            }
            n.next = p.next;
            p.next = n;
        }
        size++;
    }

删除元素

public E remove(int index) {
    if (index < 0 || index >= size) {
        throw new IllegalArgumentException("remove index out of range");
    }
    E ret = null;
    if (size == 1) {
        ret = head.data;
        head = null;
        tail = null;
    } else if (index == 0) {
        Node n = head;
        ret = n.data;
        head = n.next;
        n.next = null;
        tail.next = head; //new code
    } else if (index == size - 1) {
        Node p = head;
        while (p.next != tail) {
            p = p.next;
        }
        ret = tail.data;
        p.next = tail.next; //change code
        tail = p;
    } else {
        Node p = head;
        for (int i = 0; i < index - 1; i++) {
            p = p.next;
        }
        Node n = p.next;
        ret = n.data;
        p.next = n.next;
        n.next = null;
    }
    size--;
    return ret;
}

实现

public class LinkedSinglyCircularList<E> implements List<E> {
    private class Node {
        E data;
        Node next;

        public Node() {
            this(null, null);
        }

        public Node(E data) {
            this(data, null);
        }

        public Node(E data, Node next) {
            this.data = data;
            this.next = next;
        }

        @Override
        public String toString() {
            return data.toString();
        }
    }

    private Node head; 
    private Node tail; 
    private int size;   

    public LinkedSinglyCircularList() {
        head = null;
        tail = null;
        size = 0;
    }

    public LinkedSinglyCircularList(E[] arr) {
        if (arr == null || arr.length == 0) {
            throw new IllegalArgumentException("数组为空");
        }
        for (int i = 0; i < arr.length; i++) {
            add(arr[i]);
        }
    }

    @Override
    public void add(E element) {
        add(size, element);
    }

    @Override
    public void add(int index, E element) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("下标越界");
        }
        Node n = new Node(element);

        if (size == 0) {
            head = n;
            tail = n;
            tail.next = head;
        } else if (index == 0) {
            n.next = head;
            head = n;
            tail.next = head;  
        } else if (index == size) {
            n.next = tail.next; 
            tail.next = n;
            tail = n;
        } else {
            Node p = head;
            for (int i = 0; i < index - 1; i++) {
                p = p.next;
            }
            n.next = p.next;
            p.next = n;
        }
        size++;
    }

    @Override
    public void remove(E element) {
        int index = indexOf(element);
        if (index != -1) {
            remove(index);
        }
    }

    @Override
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("remove index out of range");
        }
        E ret = null;
        if (size == 1) {
            ret = head.data;
            head = null;
            tail = null;
        } else if (index == 0) {
            Node n = head;
            ret = n.data;
            head = n.next;
            n.next = null;
            tail.next = head; //new code
        } else if (index == size - 1) {
            Node p = head;
            while (p.next != tail) {
                p = p.next;
            }
            ret = tail.data;
            p.next = tail.next; //change code
            tail = p;
        } else {
            Node p = head;
            for (int i = 0; i < index - 1; i++) {
                p = p.next;
            }
            Node n = p.next;
            ret = n.data;
            p.next = n.next;
            n.next = null;
        }
        size--;
        return ret;
    }

    @Override
    public E get(int index) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("下标越界");
        }
        if (index == 0) {
            return head.data;
        } else if (index == size - 1) {
            return tail.data;
        } else {
            Node p = head;
            for (int i = 0; i < index; i++) {
                p = p.next;
            }
            return p.data;
        }
    }

    @Override
    public E set(int index, E element) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("下标越界");
        }
        E ret = null;
        if (index == 0) {
            ret = head.data;
            head.data = element;
            return ret;
        } else if (index == size - 1) {
            ret = tail.data;
            tail.data = element;
            return ret;
        } else {
            Node p = head;
            for (int i = 0; i < index; i++) {
                p = p.next;
            }
            ret = p.data;
            p.data = element;
            return ret;
        }
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public int indexOf(E element) {
        Node p = head;
        int index = 0;
        while (!p.data.equals(element)) {
            p = p.next;
            index++;
            if (p == head) {  //change code
                return -1;
            }
        }
        return index;
    }

    @Override
    public boolean contains(E element) {
        return indexOf(element) != -1;
    }

    @Override
    public boolean isEmpty() {
        return size == 0 && head == null && tail == null;
    }

    @Override
    public void clear() {
        head = null;
        tail = null;
        size = 0;
    }

    @Override
    public void sort(Comparator<E> c) {
        if (c == null) {
            throw new IllegalArgumentException("比较器为空");
        }
        if (size == 0 || size == 1) {
            return;
        }
        Node nodeA = head;
        Node nodeB = nodeA.next;
        while (true) {
            while (true) {
                if (c.compare(nodeA.data, nodeB.data) > 0) {
                    swap(nodeA, nodeB);
                }
                if (nodeB == tail) {
                    break;
                }
                nodeB = nodeB.next;
            }
            if (nodeA.next == tail) {
                break;
            }
            nodeA = nodeA.next;
            nodeB = nodeA.next;
        }

    }

    private void swap(Node nodeA, Node nodeB) {
        E temp = nodeA.data;
        nodeA.data = nodeB.data;
        nodeB.data = temp;
    }

    @Override
    public List<E> subList(int fromIndex, int toIndex) {
        if (fromIndex < 0 || toIndex >= size || fromIndex > toIndex) {
            throw new IllegalArgumentException();
        }
        LinkedSinglyList<E> list = new LinkedSinglyList<>();
        Node nodeA = head;
        for (int i = 0; i < fromIndex; i++) {
            nodeA = nodeA.next;
        }

        Node nodeB = head;
        for (int i = 0; i < toIndex; i++) {
            nodeB = nodeB.next;
        }
        Node p = nodeA;
        while (true) {
            list.add(p.data);
            if (p == nodeB) {
                break;
            }
            p = p.next;
        }
        return list;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        if (isEmpty()) {
            sb.append(']');
        } else {
            Node p = head;
            while (true) {
                sb.append(p.data);
                if (p == tail) {
                    sb.append(']');
                    break;
                }
                sb.append(',');
                sb.append(' ');
                p = p.next;
            }
        }
        return sb.toString();
    }

    @Override
    public Iterator<E> iterator() {
        return new LinkedSinglyCircularListIterator();
    }

    class LinkedSinglyCircularListIterator implements Iterator<E> {
        private Node cur = head;
        private boolean flag = true;

        @Override
        public boolean hasNext() {
            if (isEmpty()) {
                return false;
            }
            return flag;
        }

        @Override
        public E next() {
            E ret = cur.data;
            cur = cur.next;
            if (cur == head) {
                flag = false;
            }
            return ret;
        }
    }

    public void josephusLoop() {
        if (size <= 2) {
            return;
        }
        Node p = head;
        while (size != 2) {
            p = p.next;
            Node del = p.next;
            if (del == head) {
                head = del.next;
            } else if (del == tail) {
                tail = p;
            }
            p.next = del.next;
            del.next = null;
            p = p.next;
            size--;
        }
    }
}
weixin_54232564
关注
动态链表实现冒泡排序.c
11-25
动态链表实现冒泡排序.c
动态链表的实现（C语言）
weixin_46726346的博客
05-03 4112
记录学习第四天 今天复习一下动态链表的实现 C语言实现链表 一定会有着结构体和结构体指针； 那什么是动态链表； 打个比方，如果我想做一个学生成绩管理系统，但我不确定学生的人数，学生的信息可以用一个结构体来表示，由于不确定人数，我们如果用结构体数组，那数组的大小一定要够大，才能不出现数组元素不够用的情况，但是，剩下的结构体占着内存又是一种浪费，所以，就有了链表； 链表就是，我要记录一个学生的信息...
动态链表的建立（简版）
weixin_72479477的博客
03-03 990
1.在建立动态链表之前，我们得先了解单链表的结构。用结构体（student）建立，并且分为数据域和指针域（student）。 2.在主函数中为头结点head开创一个大小为student的空间。并且将头结点head赋给临时头结点pre。 3.用一个for循环创建一个长度为n的链表。 4.在for循环中:先为普通结点p开创空间，然后为p的数据域赋值，再将p的地址存在pre的指针域中（per->next＝p），而后将p赋予pre让当前节点成为临时头结点（pre＝p），最后将p的指针域置
C语言动态链表的实现
Alexanderyy的博客
11-18 1242
首先呢，我们考虑下链表的定义，我单纯的采用了单项动态链表。（事实上这个动态链表并不好，我在弹出链表的地方没有处理的很合理，没有free（懒了））。 由于个人能力限制，发现链表的表头很难采用void类函数进行更改（很麻烦）。 萌新在此采用了表头特殊化处理，表头元素直接丢进主函数，在主函数中进行处理。 我个人将函数的功能写在注释里了。 链表的思想很像你去玩铁索。如果各位见过铁链的加工过程的话，会很容易的理解，就是在原有的铁链上加一个环节。那么我们只需要在储存数据的结构体中加上下一链的地址就能轻松寻找到我
动态链表详解：
wwx1239021388的博客
09-04 5054
详细讲解动态链表的建立过程与链表的原理，深度理解链表的基本组成结构
静态链表和动态链表的区别
热门推荐
我的博客
10-10 5万+
静态链表和动态链表的区别： 静态链表和动态链表是线性表链式存储结构的两种不同的表示方式。 1、静态链表是用类似于数组方法实现的，是顺序的存储结构，在物理地址上是连续的，而且需要预先分配地址空间大小。所以静态链表的初始长度一般是固定的，在做插入和删除操作时不需要移动元素，仅需修改指针。 2、动态链表是用内存申请函数（malloc/new）动态申请内存的，所以在链表的长度上没有限制。动态链表
C++数据结构动态链表实现
04-08
建议精炼实现动态链表 数据结构课程设计 欢迎交流
077创建动态链表_动态链表_
09-30
动态链表是一种在计算机科学中常见的数据结构，它在运行时动态地分配内存，并且能够灵活地添加或删除元素。动态链表与静态数组不同，数组在声明时必须指定大小，而链表则可以在程序执行过程中按需增长或收缩。 在...
c++ 动态链表实现黑杰克（21点）
01-05
利用动态链表实现黑杰克（21点） 其中Creat()函数利用动态链表实现的一整副牌 可供其他纸牌游戏开发
数据结构动态数组实现链表
最新发布
05-12
本文将深入探讨如何使用动态数组来实现链表，这是数据结构课程中常见的一个实践课题。动态数组和链表虽然都是数据结构，但它们各自具有不同的特性和用途，理解它们之间的交互可以增强我们对数据结构设计的理解。 ...
C语言实现动态链表
weixin_42617375的博客
12-21 2863
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 动态链表的C语言实现 结构体定义已经函数声明 节点结构体定义 typedef struct SNode{ void *pdata; ...
数据结构——动态链表（GIF图解）
weixin_43294413的博客
12-19 7397
一、链表的定义 为了表示每个数据元素a1与其直接后继元素ai+1之间的逻辑关系，对数据元素a1来说，除了存储其本身的信息之外，还需存储一个指示其直接后继的信息。我们把存储数据元素信息的域称为数据域，把存储直接后继位置的域称为指针域。指针域存储的信息称作链。这两部分信息组成数据元素ai的存储映像，称为结点。 n个结点链结成一个链表，即为线性表的链式存储结构，因为此链表的每个结点中只包含一个指针域，所...
动态单链表的实现
Sky的专栏
04-15 765
最近本人开始为找工作做准备，
c学习笔记--5 结构体实现动态链表
iamsongyu的博客
09-29 1282
这里不得不多说一句，对于c来说指针我认为最好用的就是链表，有很多实用的地方 #include&lt;string.h&gt; #include&lt;stdio.h&gt; //C语言 链表篇 //结构体实现单向链表 struct MyStruct { char name[20]; struct MyStruct *before; }; void test6() { int a = 0...
动态链表的基本实现
目标架构师
03-27 1414
动态链表的基本实现
动态链表的创建
wangjinjing1984的博客
11-26 4633
 #include &lt;stdio.h&gt; //List结构样式 typedef struct node { int data; struct node *next; }Node; //创建head的空链 Node *createList() { Node *head = (Node *)malloc(sizeof(Node))...
动态链表和静态链表的实现
qq_36684096的博客
02-22 258
线性表分为顺序表和链表，顺序表可以简单理解成“数组”，而链表又可以划分为动态链表和静态链表。 这里主要讲解动态、静态链表的数据结构和实现。 动态链表 动态链表是通过指针来连接位置的，所以其数据结构应该包含数据域和指针域， 可以定义如下： struct node{ node *next; datatype data; }; 定义完之后，需要创建链表和删除、插入结点下面就要介绍这几个函数，由于链...
C语言 实现动态链表实现
dengjili的专栏
10-09 381
实现 #include <stdio.h> #include <stdlib.h> #define PERSON_SIZE sizeof(struct Person) struct Person { int num; float score; struct Person * next; }; struct Person * create() { struct...
静态链表和动态链表的实现
Do Better
12-03 1038
静态链表 使用静态链表存储数据，需要预先申请足够大的一整块内存空间，也就是说，静态链表存储数据元素的个数从其创建的那一刻就已经确定，后期无法更改。 比如，如果创建静态链表时只申请存储 10 个数据元素的空间，那么在使用静态链表时，数据的存储个数就不能超过 10 个，否则程序就会发生错误。 不仅如此，静态链表是在固定大小的存储空间内随机存储各个数据元素，这就造成了静态链表中需要使用另一条链表（...
C语言动态链表实现多项式加减乘操作
本篇文章主要介绍了如何使用C语言编程来实现多项式的加法和乘法，其中涉及到动态链表的数据结构。首先，我们定义了一个名为`PLOY`的结构体，用于表示多项式的系数（coef）和指数（expn），以及一个指向下一个节点的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值