【线性表的链式储存结构】数据结构与算法Java

最新推荐文章于 2022-11-21 10:15:27 发布
最新推荐文章于 2022-11-21 10:15:27 发布
阅读量453 收藏
点赞数 1
文章标签： 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_58297531/article/details/122515858
版权

目录

单链表的存储结构

头结点VS头指针

单链表的实现：

循环单链表

​ 

 双向循环链表的实现：

单链表的存储结构

        单链表是用一组任意的储存单元存放线性表的元素，这组储存单元可以是连续的也可以是不连续的，甚至可以是零散分布在内存中的任意位置。

        单链表存储结构为了能正确表示元素之间的逻辑关系，每个存储单元在存储数据元素的同时，还必须存储其后继元素所在的地址信息（指针域），将这两部分信息叫做节点 如图：

        单链表通过每一个节点的后继指针域将线性表的元素数据按照逻辑次序连接到了一起。由于每一个结点只有一个后继指针域，所以称为单链表。

结点结构的定义：

//定义节点对象
    private class Node{
        E data;     //数据域
        Node next;   //指针域

        //构造空结点
        public Node(){
            this(null, null);
        }

        //构造数据域为data值得结点
        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();
        }
    }

头结点VS头指针

        头结点是指链表中的第一个元素，有真实头节点和虚拟头节点之分。

  • 真实头节点：其第一个节点用于存储数据

  •  虚拟头节点：其第一个结点不许储存数据

 头指针（head）:仅仅就是一个应用变量，储存头结点地址的指针而已。

尾指针(tail)：同头指针，不过是链表中最后一个结点的指针而已。

单链表的实现：

        因为单链表也是线性表，所以继承List接口：

package p2.线性结构;

import p1.接口.List;

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

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

    private class Node{
         E data;
         Node next;

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

        public Node(E element){
            this(element, 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 LinkedSingList(){
        head = null;
        tail = null;
        size = 0;

    }
    public LinkedSingList(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("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 ){
            head = null;
            tail  = null;
        }else if (index == 0){
            Node p = head;
            ret = head.data;
            head = head.next;
            p.next = null;
        }else if(index == size - 1){
            ret  = tail.data;
            Node p = head;
            while (p.next != tail){
                p =  p.next;
            }
            p.next = null;
            tail = p;
        }
        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("set 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 0;
    }

    @Override
    public int indexOf(E element) {
        Node p = head;
        for (int i = 0; i < size; i ++){
            if (p.data == element){
                return i + 1;
            }
            p = p.next;
        }
        return -1;
    }

    @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 bull");
        }
        //此 处的插入排序为O(n^3)
//        for (int i = 0; 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 = nodeA.data;
    }

    @Override
    public List<E> subList(int fromIndex, int toIndex) {
        if (fromIndex < 0 || toIndex >=size || fromIndex > toIndex){
            throw new IllegalArgumentException("must 0 <= fromIndex <= toIndex <= size - 1");
        }
        LinkedSingList<E> list = new LinkedSingList<>();
        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;
        }
    }
}

循环单链表

在单链表中，如果将终端节点的指针域由空改为头结点引用，则使整个单链表形成一个环，这种头尾相接的单链表称为循环单列表

循环单链表的实现：
 

package p3.链式结构;

import p1.接口.List;

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

//单向循环链表
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("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;   //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++;
    }

    @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("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) {    //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("comparator can not be null");
        }
        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("must 0 <= fromIndex <= toIndex <= size - 1");
        }

        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;
        }
    }

   
}

双向循环链表：


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

 双向循环链表的实现：

package p3.链式结构;

import p1.接口.Dequeue;
import p1.接口.List;
import p1.接口.Stack;

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

//双向循环链表
public class LinkedList<E> implements List<E>, Dequeue<E>, Stack<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.pre = pre;
            this.next = next;
        }

        @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("arr can not be null");
        }
        for (E e : arr) {
            add(e);
        }
    }

    @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;
            head.pre = tail;
        } else if (index == 0) {
            n.pre = head.pre;
            n.next = head;
            head.pre = n;
            head = n;
            tail.next = head;
        } else if (index == size) {
            n.next = tail.next;
            tail.next = n;
            n.pre = tail;
            tail = n;
            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;
                p.next = n;
                n.pre = p;
                q.pre = n;
                n.next = q;
            } else {
                p = tail;
                for (int i = size - 1; i > index; i--) {
                    p = p.pre;
                }
                q = p.pre;
                q.next = n;
                n.pre = q;
                n.next = p;
                p.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("remove index out of range");
        }
        E ret = null;
        Node node;
        if (size == 1) {
            ret = head.data;
            head = null;
            tail = null;
        } else if (index == 0) {
            ret = head.data;
            node = head.next;
            head.next = null;
            node.pre = head.pre;
            head.pre = null;
            head = node;
            tail.next = head;
        } else if (index == size - 1) {
            ret = tail.data;
            node = tail.pre;
            tail.pre = null;
            node.next = tail.next;
            tail.next = null;
            tail = node;
            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;
                ret = q.data;
                p.next = r;
                r.pre = p;
                q.next = null;
                q.pre = null;
            } else {
                p = tail;
                for (int i = size - 1; i > index + 1; i--) {
                    p = p.pre;
                }
                q = p.pre;
                r = q.pre;
                ret = q.data;
                r.next = p;
                p.pre = r;
                q.next = null;
                q.pre = 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("set 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");
        }
        //插入排序来做
        if (size == 0 || size == 1) {
            return;
        }
        for (Node nodeA = head.next; nodeA != head; nodeA = nodeA.next) {
            E e = nodeA.data;
            Node nodeB;
            Node 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("0 <= fromIndex <= toIndex < size");
        }
        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;
        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;
        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;
        }
    }

    //双端队列的方法
    @Override
    public void addFirst(E element) {
        add(0, element);
    }

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

    @Override
    public E removeFirst() {
        return remove(0);
    }

    @Override
    public E reomveLast() {
        return remove(size - 1);
    }

    @Override
    public E getFirst() {
        return get(0);
    }

    @Override
    public E getLast() {
        return get(size - 1);
    }

    //栈的方法
    @Override
    public void push(E element) {
        addLast(element);
    }

    @Override
    public E pop() {
        return reomveLast();
    }

    @Override
    public E peek() {
        return getLast();
    }

    //队列的方法
    @Override
    public void offer(E element) {
        addLast(element);
    }

    @Override
    public E poll() {
        return removeFirst();
    }

    @Override
    public E element() {
        return getFirst();
    }
}

维生素E
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构与算法学习总结-线性表的链式存储与实现
空谷回响的编码史
02-21 875
　　实现线性表的另一种方法时链式存储，即用指针将存储线性表中数据元素的那些单元依次串联在一起。这种方法避免了再数组中用练习的单元存储元素的缺点，因而在执行插入或删除运算时，不再需要移动元素来腾出空间或填补空缺。相应的，我们需要再每个单元中设置指针来表示表中元素之间的逻辑关系，因而增加了额外的存储空间的开销。 1.单链表 　　链表是一系列的存储数据元素的单元通过指针串接起来形成的，因此每个单元至...
【数据结构】线性表的顺序储存结构（java实现）
最新发布
m0_49425260的博客
12-17 647
首先新增元素。我们只需要找到顺序表的最后一个元素，然后再最后一个元素新增元素即可。新增完后，顺序表的长度要加1。因此这里写了usedSize++但是要注意。如果新增元素的时候数组正好满了怎么办？因此我们需要判定数组是否满了，如果满了我们需要去扩容整个数组。判定数组是否已满的思路很简单：当线性表的长度等于数组长度的时候，就满了。扩容。我们扩容的时候就用到了Arrays中的函数copyof，这里实现了两倍扩容。//如果满了得扩容}}// 判断线性表是否为满。
线性表的链式存储结构Java
宋七夏的博客
12-17 406
线性表的链式存储结构 我们接着上次的顺序表来讲这次的链表。 n个结点链结成一个链表，即为线性表的链式存储结构，因为此链表的每个结点中只包含一个指针域，所以叫做单链表。 我们将链表中的第一个结点的存储位置叫做头指针。为了方便对链表进行操作，会在单链表的第一个结点前附设一个结点，叫做头结点。 上图是一个带有虚头结点的单链表。 首先看一下单链表的存储实现。 /** * @author 七夏 * @...
java建立线性表的链式结构_Java实现线性表的链式存储
weixin_39805998的博客
02-26 176
本文实例为大家分享了Java实现线性表的链式存储，供大家参考，具体内容如下链表：一种物理存储结构上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。package algorithm.datastructure.linklist;import java.util.NoSuchElementException;/** 链表* 物理存储上非连续的存储结构，数据元素的逻辑顺序...
线性表的链式存储结构（java版）
小学徒成长专栏
02-27 175
在前面，我们已经讲了线性表的顺序存储结构（java版） ，我们也知道了他的代码实现，在了解之后，我们很容易就能够发现他有一个最大的缺点，就是插入和删除需要移动大量的元素，这显然是很耗费时间的，于是，为了解决这个问题，就出现了链式存储结构。   我学习的时候是看程杰的《大话数据结构》的，同时结合我们的经典教材清华出版社的《数据结构》，但是在学习过程中，我不小心把“插入到第i个位置之后”理解成了...
java实现线性表链式存储结构
m0_37860420的博客
11-08 380
定义结点 public class Node { private int data; private Node next; public Node() {} public Node(int data){ this.data= data; } public Node(int data,Node next) { this.data=data; this.n...
JAVA实现线性表的链式存储结构LinkedList
Timmy_zzh的博客
11-24 1175
线性表的链式存储结构，实现思路是默认持有一个空节点，且每个节点持有前继节点和后继节点的索引 linkedlist使用的是双向循环链表，同时也是队列结构 优点：方便增加和删除元素。缺点：不易查找元素 /** * 双向链表结构处理:增删改查->链表结构初始保存一个空结点 * * @author admin * */public class MyLinkedListE>
java线性表的存储结构及其代码实现
08-29
Java 线性表是一种基本的数据结构，它的存储结构可以分为顺序存储结构和链式存储结构两种。在 Java 中，ArrayList 类就是线性表的数组实现。下面是 Java 线性表的存储结构和代码实现。 一、顺序存储结构 顺序存储...
数据结构实验线性表实验报告（代码是java编写的）
05-10
实验报告涉及的知识点主要集中在数据结构中的线性表，包括顺序表和循环链表的实现与操作。线性表是一种逻辑结构，其中的数据元素按照线性顺序排列，可以通过顺序存储或链式存储来实现。 1. **顺序表**：顺序表是用...
漫话数据结构-线性表的链式存储.pptx
11-03
线性表是计算机科学中一种基础且重要的数据结构，它由有限个相同类型的数据元素构成，元素之间存在着一对一的线性关系。线性表的链式存储是相对于顺序存储的一种方式，尤其适用于动态变化的数据集合。 在链式存储中...
JAVA数据结构之线性表的链式存储结构——双向链表
Gold_Roc的博客
07-06 267
1、结点类Node的代码如下所示： public class Node { public Object data;//结点中的数据 public Node pre;//指向前一个结点的指针域 public Node next;//指向下一个结点的指针域 public Node(Object data){ this.data = data; } } 2、双向链表的实现类DLink
java数据结构，线性表链式存储（单链表）的实现
m0_63622279的博客
11-21 756
结合上一篇的顺序存储的总结java数据结构，线性表顺序存储（数组）的实现对于顺序存储，按顺序放在一起，相邻元素通过内存地址相邻产生联系，”随机存取“。而链式存储，元素随机放置在内存中任意位置，每个元素除了存放数据，也保存了其相邻元素的内存地址，来实现线性关系，“随机存取”。单链表的存储空间会比相同元素个数的线性表多，原因是单链表中包括了数据域data和指针域next,所以其存储密度是小于1的。
java 实现链式储存结构的线性表
weixin_46085748的博客
11-13 314
java 实现链表 用节点类储存数据。 代码 /** * 链表储存结构实现顺序表 * @param <E> */ public class LinkedList<E> { // 头节点 private LinkedNode<E> first; // 尾节点 private LinkedNode<E> last; // 顺序表内储存的数据个数 private int size = 0; // 初始化
图解线性表的链式存储
吾竹清风2017
09-09 252
#ifndef _MYLINKLIST_H_ #define _MYLINKLIST_H_ //链表 typedef void LinkList; //链表节点 typedef struct _tag_LinkListNode { struct _tag_LinkListNode *next; }LinkListNode; LinkList* LinkList_Create(); void LinkList_Destroy(LinkList* list); ...
用Java描述数据结构之线性表的链式存储（链表），模拟LinkedList实现
qq_46209845的博客
03-29 325
上一篇介绍了顺序表：用Java描述数据结构之线性表的顺序存储（顺序表），ArrayList及其方法的介绍 上一篇博客中说明了什么是线性表——线性表就是一个个数据元素逻辑上以一对一的相邻关系（但是在物理结构上并不一定是连续得到）组织起来的有限序列。 根据物理存储方式的不同可以将线性表分为两种，一种叫顺序表，一种叫链表，这篇博客主要介绍链表。 链表和顺序表不同，链表在存储时并不是连续的，大家可以这么理解：内存上被使用的一段段空间之间会有小段的未被使用的，链表在使用时就可以使用这些小段的未被使用的空间去存储数据，
算法&数据结构 - 线性表及其链式存储结构
爱意随风起，风止意难平
07-16 1633
本篇主要介绍线性表另一种存储形式，链式存储结构及其操作方法，本篇中量代码。
数据结构和算法:线性表链式存储的简单实现
weixin_30291791的博客
03-04 163
一、先定义简单的线性表规则，然后实现 1、接口 /** * [Project]:moy-gradle-project <br/> * [Email]:moy25@foxmail.com <br/> * [Date]:2018/1/24 <br/> * [Description]: 简单的线性表定义<br/> * ...
链表 java 保存_线性表的Java实现--链式存储（单向链表）
weixin_26846533的博客
02-26 131
单向链表(单链表)是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。链式存储结构的线性表将采用一组任意的存储单元存放线性表中的数据元素。由于不需要按顺序存储，链表在插入、删除数据元素时比顺序存储要快，但是在查找一个节点时则要比顺序存储要慢使用链式存储可以克服顺序线性表需要预先知道数据大小的缺点，链表结构可以充分利用内存空间，实现灵活的内存动态管理。但是链式存储失去...
java建立线性表的链式结构,JAVA数据结构 线性表的链式存储及其实现
weixin_35038173的博客
03-15 224
2线性表的链式存储及其实现虽然顺序表具有随机存取的特点是一种有用的存储结构但是也有缺陷：(1)若需要给顺序表增加存储空间首先必须开辟一个更大的存储空间然后把数据复制到现在这个表当中(2)因为顺序表的数据元素在存储结构上相邻素要删除元素就要移动平均一半的数据元素所以顺序表适合静态的线性表，表一旦形成就很少进行插入操作，对于要进行平凡的插入或者删除操作的“动态的”线性表通常采用链式存储结构，与此同时链...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值