第四节 线性表的链式结构——链表

最新推荐文章于 2022-04-06 22:12:15 发布
最新推荐文章于 2022-04-06 22:12:15 发布
阅读量347 收藏
点赞数
分类专栏： 算法笔记 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46245504/article/details/122545458
版权

第四节 线性表的链式结构——链表

1. 链表的定义

链表 （Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。

使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。

2. 单向链表
（1）单向链表的定义

单链表是链表中结构最简单的。一个单链表的 节点(Node) 分为两个部分，第一个部分 数据域(data) 保存或者显示关于节点的信息，另一个部分为 指针域(next) 存储下一个节点的地址。最后一个节点存储地址的部分指向空值。

单向链表只可向一个方向遍历，一般查找一个节点的时候需要从第一个节点开始每次访问下一个节点，一直访问到需要的位置。而插入一个节点，对于单向链表，我们只提供在链表头插入，只需要将当前插入的节点设置为头节点，next指向原头节点即可。删除一个节点，我们将该节点的上一个节点的next指向该节点的下一个节点。

（2）单向链表的代码实现
package p3.linked;

import p1.interfaces.List;

import java.util.Comparator;
import java.util.Iterator;

public class LinkedSingleList<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 LinkedSingleList() {
        head = null;
        tail = null;
        size = 0;
    }

    public LinkedSingleList(E[] arr) {
        if (arr == null || arr.length == 0) {
            throw new IllegalArgumentException("arr is null");
        }
        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("add index out of range");
        }
        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("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;
        } 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("get index out of range");
        }
        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("get index out of range");
        }
        E ret = null;
        if (index == 0) {
            ret = head.data;
            head.data = element;
        } else if (index == size - 1) {
            ret = tail.data;
            tail.data = element;
        } 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 == null) {
                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("comparator can not be null");
        }
        //此处的插入排序O(n^3)
        /*
        for (int i = 1; i < size; i++) {
            E e = get(i);
            int j = 0;
            for (j = i; j > 0 && c.compare(get(j - 1), e) > 0; j--) {
                set(j, get(j - 1));
            }
            set(j, e);
        }
        */
        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) {
        //0 <= fromIndex <= toIndex <= size - 1    [fromIndex,toIndex]
        if (fromIndex < 0 || toIndex >= size || fromIndex > toIndex) {
            throw new IllegalArgumentException("must 0 <= fromIndex <= toIndex <= size - 1");
        }

        LinkedSingleList<E> list = new LinkedSingleList<>();
        /*
        for (int i = fromIndex; i <= toIndex; i++) {    //O(M)
            list.add(get(i));   //O(N) * O(M) = O(NM) ~ O(N^2)
        }
        */
        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;
        }
    }
}
3. 单向循环链表
（1）单项循环链表的定义

如果把单链表的最后一个节点的指针指向链表头部，而不是指向NULL，那么就构成了一个 单向循环链表

（2）代码实现：
package p3.linked;

import p1.interfaces.List;

import java.util.Comparator;
import java.util.Iterator;

public class LinkedSingleLoopList<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 LinkedSingleLoopList() {
        head = null;
        tail = null;
        size = 0;
    }

    public LinkedSingleLoopList(E[] arr) {
        if (arr == null || arr.length == 0) {
            throw new IllegalArgumentException("arr is null");
        }
        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("add index out of range");
        }
        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;
        } else if (index == size - 1) {
            Node p = head;
            while (p.next != tail) {
                p = p.next;
            }
            ret = tail.data;
            p.next = tail.next;
            tail.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("get index out of range");
        }
        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("get index out of range");
        }
        E ret = null;
        if (index == 0) {
            ret = head.data;
            head.data = element;
        } else if (index == size - 1) {
            ret = tail.data;
            tail.data = element;
        } 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) {
                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("comparator can not be null");
        }
        //此处的插入排序O(n^3)
        /*
        for (int i = 1; i < size; i++) {
            E e = get(i);
            int j = 0;
            for (j = i; j > 0 && c.compare(get(j - 1), e) > 0; j--) {
                set(j, get(j - 1));
            }
            set(j, e);
        }
        */
        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) {
        //0 <= fromIndex <= toIndex <= size - 1    [fromIndex,toIndex]
        if (fromIndex < 0 || toIndex >= size || fromIndex > toIndex) {
            throw new IllegalArgumentException("must 0 <= fromIndex <= toIndex <= size - 1");
        }

        LinkedSingleLoopList<E> list = new LinkedSingleLoopList<>();
        /*
        for (int i = fromIndex; i <= toIndex; i++) {    //O(M)
            list.add(get(i));   //O(N) * O(M) = O(NM) ~ O(N^2)
        }
        */
        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 LinkedSingleLoopListIterator();
    }

    class LinkedSingleLoopListIterator 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;
        }
    }
}
（5）约瑟夫环问题

问题描述： 据说著名犹太历史学家Josephus有过一下的故事：

​ 在罗马人占领乔塔帕特后，39个犹太人与Josephus及他的朋友躲在一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3个人该人必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。

​ 然而Josephus和他的朋友并不想遵从，Josephus要他的朋友先假装遵从，他将朋友与自己安排在了第16个与第31个位置，于是逃过了这场死亡游戏。

通过单项循环链表内部代码解决：

public void josephRing(){
        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 --;
        }
}

通过main函数中代码解决：

public static void main(String[] args) {
        LinkedSingleLoopList<Integer> list = new LinkedSingleLoopList<>();
        for(int i = 1;i<=41 ; i ++){
            list.add(i);
        }
        //list.josephRing();



        int index = 0;
        while (list.size() != 2){
            index = (index + 2) % list.size();
            list.remove(index);
        }
        System.out.println(list);
    }
（6）逢七过游戏

问题描述：

  1. 好友围坐在酒桌前，从任意一人开始轮流报数，数字从1开始。
  2. 凡是遇到任何7的倍数，如14、21或含7的数字如17、27均喊“过”。
  3. 遇到反应慢了没有敲zhi打桌面的人则失败。失败的惩罚就是罚酒或者表演节目。
  4. 接下来，被惩罚过的人重新开始报数，可以从10以下任意一个数字开始。

问题目标： 输入玩家人数、开始数字、最大数字、开始玩家编号等信息，打印出每个玩家需要说出的值

代码实现：

package test;

import p2.array.lists.ArrayList;
import p3.linked.LinkedSingleLoopList;

import java.util.Scanner;

//逢七过
public class SevenGames {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print(">>>请输入玩家数量:");
        int playerCount = input.nextInt();

        System.out.print(">>>请输入从哪个玩家开始:");
        int beginPlayer = input.nextInt();

        System.out.print(">>>请输入从哪个数字开始:");
        int beginNum = input.nextInt();

        System.out.print(">>>请输入最大值:");
        int maxNum = input.nextInt();

        LinkedSingleLoopList<ArrayList> list = new LinkedSingleLoopList<>();
        for (int i = 0; i < playerCount; i++) {
            list.add(new ArrayList());
        }

        int index = beginPlayer - 1;//将玩家编号转换为对应下标
        for(int  num = beginNum ; num <= maxNum ; num ++){
            list.get(index ++ % playerCount).add(getAnswer(num));
        }
        for (int i = 0 ; i < list.size();i++){

            System.out.println("第" + (i+1) + "位玩家" + list.get(i));
        }
    }

    private static String getAnswer(int num) {
        if ((num + "").contains("7") || num % 7 == 0){
            return "过";
        }else{
            return num + "";
        }
    }
}
4.双向循环链表
（1）双向循环链表的定义

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

（2）代码实现
package p3.linked;

import p1.interfaces.List;

import java.util.Comparator;
import java.util.Iterator;

public class LinkedList<E> implements List<E> {
    private class Node{
        E data;
        Node pre;
        Node next;
        public Node(){
            this(null,null,null);
        }
        public Node(E data){
            this(data,null,null);
        }
        public Node(E data , Node pre , Node next){
            this.data = data;
            this.next = next;
            this.pre = pre;
        }

        @Override
        public String toString() {
            return data.toString();
        }
    }
    private Node head;
    private Node tail;
    private int size;

    public LinkedList(){
        head = null;
        tail = null;
        size = 0;
    }
    public LinkedList(E[] arr){
        if(arr == null){
            throw new IllegalArgumentException("array can not be null");
        }
        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("index out of range");
        }
        Node n = new Node(element);
        if(size == 0){
            head = n;
            tail = n;
            tail.next = head;
            head.pre = tail;
        }else if(index == 0){
            n.next = head;
            head.pre = n;
            head = n;
            tail.next = head;
            head.pre = tail;
        }else if(index == size){
            tail.next = n;
            n.pre = tail;
            tail = n;
            tail.next = head;
            head.pre = tail;
        }else{
            Node p , q;
            if(index <= size /  2){
                p = head;
                for (int i = 0 ; i < index - 1; i++){
                    p = p.next;
                }
                q = p.next;
            }else {
                q = tail;
                for (int i = size - 1; i > index; i--) {
                    q = q.pre;
                }
                p = q.pre;
            }
            p.next = n;
            n.pre = p;
            n.next = q;
            q.pre = 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("index out of range");
        }
        E ret = null;
        Node n ;
        if(size == 1){
            head = null;
            tail = null;
        }else if(index == 0){
            ret = head.data;
            n = head.next;
            head.next = null;
            n.pre = head.pre;
            head.pre = null;
            head = n;
            tail.next = head;
        }else if(index == size - 1){
            ret = tail.data;
            n = tail.pre;
            tail.pre = null;
            n.next = tail.next;
            tail.next = null;
            tail = n;
            head.pre = tail;
        }else{
            Node p ,q,r;
            if(index <= size / 2){
                p = head;
                for (int i = 0; i < index - 1; i++) {
                    p = p.next;
                }
                q = p.next;
                r = q.next;
            }else{
                r = tail;
                for (int i = size - 1; i > index + 1; i--) {
                    r = r.pre;
                }
                q = r.pre;
                p = q.pre;
            }
            ret = q.data;
            p.next = r;
            r.pre = p;
            q.next = null;
            q.pre = null;
        }
        size --;
        return ret;
    }

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

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

            }else{
                p = tail;
                for (int i = size - 1; i > index ; i--) {
                    p = p.pre;
                }
            }
            ret = p.data;
            p.data = element;
        }
        return ret;
    }

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

    @Override
    public int indexOf(E element) {
        int index = 0;
        Node p = head;
        while(!p.data.equals(element)){
            p = p.next;
            index ++;
            if (p == head){
                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("comparator can not be null");
        }
            //此处的插入排序
        if (size == 0 || size == 1){
            return;
        }
        for (Node nodeA = head.next;nodeA != head;nodeA = nodeA.next){
            E e = nodeA.data;
            Node nodeB , nodeC;
            for (nodeB = nodeA,nodeC = nodeB.pre; nodeC != tail &&c.compare(nodeC.data, e) > 0; nodeB = nodeB.pre , nodeC = nodeC.pre) {
                nodeB.data = nodeC.data;
            }
            nodeB.data = e;
        }
    }

    @Override
    public List<E> subList(int fromIndex, int toIndex) {
        if (fromIndex < 0 ||toIndex >= size || fromIndex > toIndex){
            throw new IllegalArgumentException("index out of range");
        }
        Node nodeA = head;
        for (int i = 0; i < fromIndex; i++) {
            nodeA = nodeA.next;
        }
        Node nodeB = nodeA.next;
        for (int i = fromIndex ; i < toIndex; i ++){
            nodeB = nodeB.next;
        }
        Node p = nodeA;
        LinkedList<E> list = new LinkedList<>();
        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 LinkedListIterator();
    }
    class LinkedListIterator 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;
        }
    }
}
一只平平无奇的小白
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构c版（1）-线性表之双向带头循环链表代码
11-19
在本篇文章中，我们将深入探讨一个特定的数据结构——双向带头循环链表，它是线性表的一种实现方式。在C语言中，这种数据结构尤其常见，因为C语言提供底层内存管理和指针操作的能力，使得我们能够直接构建复杂的链式...
数据结构实验一线性表的基本操作.docx
03-28
* 查找：按序号查找——返回线性表中第 i(0)个元素，按值查找——返回线性表中值为 x 的元素，不存在返回 NULL * 输出：输出线性表的基本信息 三、链式存储结构 链式存储结构是指用一组结点组成的链表，每个结点...
链式链表
weixin_34107955的博客
03-27 99
#include<iostream> using namespace std; typedef int ElemType; struct Node { ElemType date; Node *next; }; struct LinkQueue { Node *front ,*rear; void Init(); ...
java实现简单的链式结构二（双向链表）
我来杀ai的博客
04-26 262
双向链表必要性 ：单链表，不管是头插还是尾插都只是在增加头尾节点的时候能达到O（1），在知道某个具体中间节点的时候既不能直接增加节点，也不能 直接删除节点。原因就在于我们不知道该节点的前驱，导致不能修改前驱的next属性，如果在每一个节点加入前驱属性，就能在单独拿到一个节点的时候直接进行新增或删除操作，将新增删除已知任意节点的时间复杂度控制到O(1)。ps：表前驱元（previous）就是一个元素...
链式单链表
星空
10-07 442
题目：     构造一个单链表，实现创建、删除、插入、查找等功能。 解析： 初始化单链表，即单链表的表头指针为空 void initlist(node **pnode) { *pnode = NULL; printf("初始化成功!\n"); }  打印链表元素,遍历链表  //打印链表元素,遍历链表 void printinfo(linklist list) { lnod...
数据结构之链式链表
zxjzlj的专栏
05-28 655
学习数据结构已经很久了，一直没有用上，最近时间有点空闲，所以翻出来炒一炒。子曰：温故而知新。当初学习数据结构的时候，买的是国嵌唐老师的视频，所以这些代码很唐老师写的几乎一模一样，若转载请注明出自国嵌唐老师数据结构教程。 首先来看第二个例子，链式lian'bi： 头文件
链式存储（链表）
m0_67349760的博客
04-06 945
有头单向链表 #include<stdio.h> #include<stdlib.h> typedef struct node { int data; struct node* next; }link_node_t; /* 创建空单向链表 */ link_node_t* createEmptynode () { link_node_t* p = malloc(sizeof(link_node_t)); if(p == NULL) { printf("goto ba
实验一——链式结构实现线性表.doc
10-12
在这个实验中，学生可以选择五种不同的链式结构来实现线性表，分别是带头结点的单链表、不带头结点的单链表、循环链表、双链表和静态链表。实验要求实现线性表的基本功能，包括构造、插入、删除、查找、获取链表长度...
数据结构——线性表(选择题).docx
07-11
总结来说，线性表是数据结构的基础，理解其概念、性质以及在顺序存储和链式存储下的操作对于学习数据结构至关重要。顺序存储便于随机访问但插入和删除操作可能涉及大量元素的移动，而链式存储虽然插入和删除更灵活，...
数据结构——线性表分享.pdf
01-01
数据结构——线性表分享 一、顺序存储结构 在数据结构中，顺序存储结构是一种常用的存储方式，它将线性表的每个元素存储在一块连续的存储空间中。这种存储方式的优点是可以快速访问任意一个元素，但缺点是插入或...
第四天-线性表 ----链表
Bkhole的博客
01-22 133
今天主要对链表的创建进行了深入理解---头插以及尾插法 今天只是对前六种基本操作进行了回顾（有点遗憾没弄完 ~好困) 今天330行！！！ 明天继续加油。 !!! #define _CRT_SECURE_NO_WARNINGS #define MAXSIZE 5 #include<stdio.h> #include<Windows.h> #include<string.h> #include<malloc.h> //结点类型说明 typedef
【2.3】链式单链表
yeler082的博客
04-16 391
一、单链表的结构特征1、采用指针链接一些列的存储单元来存储数据2、动态分配存储空间3、插入或删除元素效率高4、查找元素效率低下单链表常见结构：2、文件组织方式3、linkList.h单链表函数声明文件#ifndef _YE_LELE_01 #define _YE_LELE_01 typedef int ElemType; typedef int Status; typedef struct LN...
数据结构(4)---线性表(链表)
李憨憨
07-17 152
链表 文章目录链表链表的概念及结构单链表(无头单向非循环链表)链表的实现 链表的概念及结构 概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。 链表中的数据, 包含了数据的本身, 也包含下一个数据的指针的指向, 所以它本身也是一种新的类型 因为链表中的数据在内存中的存放是不连续的, 所以数据不仅包含数据本身还有一个指针的指向, 如果没有指针, 那这个数据就找不到. 它是一个逻辑上连续的, 物理上不连续的结构 实际中链表的结构非常多样，以下情
线性链表--链式链表实现（c语言）
架构师之路，举步维艰。
03-08 1262
练习了一下数据结构线性链表的链式结构，测试了一下函数还都通过了，最后整理了一下子，也不知道放到哪儿，应用暂时也没有地方，纯属练习大脑呢。放到这里吧，挺整齐的代码。以后也留一个纪念，也给参考的人触发点启发，谢谢关顾。 #include #include typedef struct linked_list { int data; struct linked_list *next; }li
04-线性表
林帆的博客
04-11 557
1.线性表的定义及逻辑结构 线性表（LinearList）是由n(n$ \geq 0)个属于同一个数据对象的数据元素(节点)0)个属于同一个数据对象的数据元素(节点)0)个属于同一个数据对象的数据元素(节点)a_1,a_2,a_3,…,a_n$组成的有限序列。 线性表中每个元素必须具有相同的结构(即拥有相同的数据项)。线性表是线性结构中最常用而又最简单的一种数据结构。 线性表中每个数据元素其实可以...
链式链表的基本实现
qq_26467059的博客
11-13 277
链式链表的基本实现
线性链表与链式链表
DataH
03-31 533
线性链表与链式链表 在做项目的时候,需要保存多个对象,为了方便查询,我刚开始使用了线性链表的方式,把同一个对象都保存到一个线性链表中,但是由于stm32的内存很小,每个对象类型都定义一个线性链表,后面内存都爆满了,检测了一下,原理是因为定义了很多的全局变量的线性链表,线性链表的一般结构如下, typedef struct //定义顺序表结构 { DATA Li...
基本数据结构 —— 链式表的认识及不同链表的代码实现
阿坤~的博客
09-20 819
PS：本文将介绍什么是链表，以及单链表、双向链表、循环链表的认识和代码实现 什么是链表？ 链表是一种常见的数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer）。由于不必按顺序存储，链表在插入的时候可以达到O⑴的复杂度，比顺序表快很多，但是查询一个节点或访问特定下标的节点则需要O(n)的时间，而顺序表相应的时间复杂度为 O(1) ...
线性表的链式表式-------有序单链表插入结点与两个有序单链表的合并
qq_52896055的博客
07-27 123
一、有序单链表插入结点 插入结点的过程其实就是一个遍历链表的过程，在遍历过程中判断是否到达尾结点以及判断待插入的数据大小和结点数据谁大，当然我我这里没有考虑特殊情况，比如插入的数据如果正好是最大或者最小的情况 #include<stdio.h> #include<stdlib.h> typedef struct lianbiao { int data; struct lianbiao *next; }hh; void charu(hh *next,int e) { hh *x

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值