数据结构与算法：顺序表和链表的学习

已于 2023-01-08 16:07:19 修改
阅读量211 收藏 2
点赞数 3
分类专栏： 0基础学算法 文章标签： 链表 学习 数据结构
于 2022-11-11 18:16:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66030479/article/details/127675834
版权

1.线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

在这里插入图片描述

2.顺序表

1.概念及结构

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。

顺序表一般可以分为：

  • 静态顺序表：使用定长数组存储。
  • 动态顺序表：使用动态开辟的数组存储。

静态顺序表适用于确定知道需要存多少数据的场景.

静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用.

相比之下动态顺序表更灵活, 根据需要动态的分配空间大小.

2.接口实现

我们来实现一个动态顺序表. 以下是需要支持的接口.

public class SeqList {
	// 打印顺序表
	public void display() { }
	// 在 pos 位置新增元素
	public void add(int pos, int data) { }
	// 判定是否包含某个元素
	public boolean contains(int toFind) { return true; }
	// 查找某个元素对应的位置
	public int search(int toFind) { return -1; }
	// 获取 pos 位置的元素
	public int getPos(int pos) { return -1; }
	// 给 pos 位置的元素设为 value
	public void setPos(int pos, int value) { }
	//删除第一次出现的关键字key
	public void remove(int toRemove) { }
	// 获取顺序表长度
	public int size() { return 0; }
	// 清空顺序表
	public void clear() { }
}

3.顺序表功能实现

public class TestDemo {
    public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
    }
}

 public class MyArrayList {

    public int[] elem;
    public int useSize;//当前有效的数据个数

    public MyArrayList() {
        this.elem = new int[10];
    }

1.打印顺序表

public void display() {
    for (int i = 0; i < this.useSize; i++) {
        System.out.print(this.elem[i] + " ");
    }
    System.out.println();
}

public class TestDemo {
    public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add(0,1);
        myArrayList.add(1,2);
        myArrayList.add(2,3);
        myArrayList.add(3,4);
        myArrayList.display();
    }
}

在这里插入图片描述

2.获取顺序表的有效数据长度

public int size() {
    return this.useSize;
}

public class TestDemo {
    public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add(0,1);
        myArrayList.add(1,2);
        myArrayList.add(2,3);
        myArrayList.add(3,4);
        myArrayList.display();
        System.out.println(myArrayList.size());
    }
}

在这里插入图片描述

3. 在 pos 位置新增元素

在这里插入图片描述
实现过程：

1.判断位置是否合法。

2.判断数据满没满，没满进行扩容。

3.数组往后移，空出插入的位置。

4.在空出的位置进行插入。

具体代码如下：

public void add(int pos, int data) {
    if(pos < 0 || pos > useSize) {
        System.out.println("pos位置不合法");
        return;
    }
    if(isFull()) {
        this.elem = Arrays.copyOf(this.elem,2 * this.elem.length);
    }
    for (int i = this.useSize - 1; i >= pos; i--) {
        this.elem[i + 1] =this.elem[i];
    }
    this.elem[pos] = data;
    this.useSize++;
}
//判断数组是否已满
public boolean isFull() {
    return useSize == elem.length;
}

public class TestDemo {
    public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add(0,1);
        myArrayList.add(1,2);
        myArrayList.add(2,3);
        myArrayList.add(3,4);
        myArrayList.display();
    }
}

在这里插入图片描述

4.判断是否包含某元素

public boolean contains(int toFind) {
  	for (int i = 0; i < this.useSize; i++) {
        if(this.elem[i] == toFind) {
            return true;
        }
    }
    return false;
}

public class TestDemo {
    public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add(0,1);
        myArrayList.add(1,2);
        myArrayList.add(2,3);
        myArrayList.add(3,4);
        myArrayList.display();
        System.out.println(myArrayList.contains(3));
    }
}

在这里插入图片描述

5.查找某个元素对应的位置

public int search(int toFind) {
    for (int i = 0; i < this.useSize; i++) {
        if(this.elem[i] == toFind) {
            return i;
        }
    }
    return -1;
}

public class TestDemo {
    public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add(0,1);
        myArrayList.add(1,2);
        myArrayList.add(2,3);
        myArrayList.add(3,4);
        myArrayList.display();
        System.out.println(myArrayList.search(2));
    }
}

在这里插入图片描述

6.获取 pos 位置的元素

public int getPos(int pos) {
    if(pos < 0 || pos >= this.useSize) {
        System.out.println("pos位置不合法");
        return -1;//所以这里说下，业务上的处理这里不考虑，后期可以抛异常
    }
    if(isEmpty()) {
        System.out.println("顺序表为空！");
        return -1;
    }
    return this.elem[pos];
}

//判断是否为空
public boolean isEmpty() {
    return this.useSize == 0;
}

public class TestDemo {
    public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add(0,1);
        myArrayList.add(1,2);
        myArrayList.add(2,3);
        myArrayList.add(3,4);
        myArrayList.display();
        System.out.println(myArrayList.getPos(3));
    }
}

在这里插入图片描述

7. 给 pos 位置的元素设为/更新 value

public void setPos(int pos, int value) {
    if(pos < 0 || pos >= this.useSize) {
        System.out.println("pos位置不合法");
        return;
    }
    if(isEmpty()) {
        System.out.println("顺序表为空！");
        return;
    }
    this.elem[pos] = value;
}

public class TestDemo {
    public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add(0,1);
        myArrayList.add(1,2);
        myArrayList.add(2,3);
        myArrayList.add(3,4);
        myArrayList.display();
        myArrayList.setPos(0,99);
        myArrayList.display();
    }
}

在这里插入图片描述

8.删除第一次出现的关键字key

在这里插入图片描述

public void remove(int toRemove) {
  	if(isEmpty()) {
        System.out.println("顺序表为空！");
        return;
    }
    int index = search(toRemove);
    if(index == -1) {
        System.out.println("没有你要删除的数字");
        return;
    }
    for (int i = index; i < this.useSize - 1; i++) {
        this.elem[i] = this.elem[i+1];
    }
    this.useSize--;
    //this.elem[useSize] == null;如果数组当中是引用数据类型
}

public class TestDemo {
    public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add(0,1);
        myArrayList.add(1,2);
        myArrayList.add(2,3);
        myArrayList.add(3,4);
        myArrayList.display();
        myArrayList.remove(3);
        myArrayList.display();
    }
}

在这里插入图片描述

9.清空顺序表

public void clear() {
    this.useSize = 0;
    //如果数组当中是引用数据类型
   /* for (int i = 0; i < useSize; i++) {
       	this.elem[i] = null;
      }
      this.useSize = 0;
     */

    }

public class TestDemo {
    public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add(0,1);
        myArrayList.add(1,2);
        myArrayList.add(2,3);
        myArrayList.add(3,4);
        myArrayList.display();
        myArrayList.clear();
        myArrayList.display();
    }
}

在这里插入图片描述

4.顺序表的问题

  1. 顺序表中间/头部的插入删除，时间复杂度为O(N)。
  2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
  3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。

在这里插入图片描述

如何解决以上问题呢？下面给出了链表的结构来看看。

3.链表

1.链表的概念及结构

链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。
在这里插入图片描述

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

  • 单向、双向
  • 带头、不带头
  • 循环、非循环

在这里插入图片描述
在这里插入图片描述

虽然有这么多的链表的结构，但是我们重点掌握两种:

  • 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。

在这里插入图片描述
在这里插入图片描述

  • 无头双向链表：在Java的集合框架库中LinkedList底层实现就是无头双向循环链表。

在这里插入图片描述

2.无头单向非循环链表

在这里插入图片描述

在这里插入图片描述

public class MyLinkedList {

    public ListNode head;//链表的头引用

    public void creatList() {
        ListNode listNode1 = new ListNode(12);
        ListNode listNode2 = new ListNode(23);
        ListNode listNode3 = new ListNode(34);
        ListNode listNode4 = new ListNode(45);
        ListNode listNode5 = new ListNode(56);
    }

}

此时链表的状态如下图：
在这里插入图片描述
在代码中加入 ：

listNode1.next = listNode2;
listNode2.next = listNode3;
listNode3.next = listNode4;
listNode4.next = listNode5;

链表就会变为下图：
在这里插入图片描述
代码中加入：

this.head = listNode1;

在这里插入图片描述
所有节点被回收，链表就变成了：
在这里插入图片描述

打印val的值:

public void display() {
   	while (this.head != null) {
        System.out.print(this.head.val + " ");
        this.head = this.head.next;
    }
}

class ListNode {
    public int val;
    public ListNode next;

    public ListNode(int val) {
        this.val = val;
    }
}
public class MyLinkedList {

    public ListNode head;//链表的头引用

    public void creatList() {
        ListNode listNode1 = new ListNode(12);
        ListNode listNode2 = new ListNode(23);
        ListNode listNode3 = new ListNode(34);
        ListNode listNode4 = new ListNode(45);
        ListNode listNode5 = new ListNode(56);
        listNode1.next = listNode2;
        listNode2.next = listNode3;
        listNode3.next = listNode4;
        listNode4.next = listNode5;
        this.head = listNode1;

    }

     public void display() {
        ListNode cur = this.head;
        while (cur!= null) {
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }
}


public class TestDemo {
    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.creatList();
        myLinkedList.display();
    }
}

在这里插入图片描述

3.无头单向非循环链表的实现

1.查找是否包含关键字key是否在单链表当中

public boolean contains(int key) {
   

public class TestDemo {
    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.creatList();
        myLinkedList.display();
        boolean flg = myLinkedList.contains(34);
        System.out.println(flg);
    }
}

在这里插入图片描述

2.得到单链表的长度

public int size() {
    int count = 0;
    ListNode cur = this.head;
    while (cur != null) {
        count++;
        cur = cur.next;
    }
    return count;
}

public class TestDemo {
    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.creatList();
        myLinkedList.display();
        boolean flg = myLinkedList.contains(34);
        System.out.println(myLinkedList.size());
    }
}

在这里插入图片描述

3.头插法

在这里插入图片描述

public void addFirst(int data) {
    ListNode node = new ListNode(data);
    if(this.head == null) {
        this.head = node;
    }else {
        node.next = this.head;
        this.head = node;
    }
}

public class TestDemo {
    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.addFirst(12);
        myLinkedList.addFirst(23);
        myLinkedList.addFirst(34);
        myLinkedList.addFirst(45);
        myLinkedList.addFirst(56);
        myLinkedList.display();
    }
}

在这里插入图片描述

4.尾插法

在这里插入图片描述

public void addLast(int data) {
    ListNode node = new ListNode(data);
    if(this.head == null) {
        this.head = node;
    }else {
        ListNode cur = this.head;
        while (cur.next != null) {
            cur = cur.next;
        }
        cur.next = node;
    }
}

public class TestDemo {
    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.addLast(12);
        myLinkedList.addLast(23);
        myLinkedList.addLast(34);
        myLinkedList.addLast(45);
        myLinkedList.addLast(56);
        myLinkedList.display();
    }
}

在这里插入图片描述

5.任意位置插入,第一个数据节点为0号下标

具体思路如下图所示：
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

public void addIndex(int index,int data) {
    if(index < 0 || index > size()) {
        System.out.println("index位置不合法！");
        return;
    }
    if(index == 0) {
        addFirst(data);
        return;
    }
    if (index == size() ) {
        addLast(data);
        return;
    }
    ListNode cur = findIndex(index);
    ListNode node = new ListNode(data);
    node.next = cur.next;
    cur.next = node;
}

public class TestDemo {
    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.creatList();
        myLinkedList.addIndex(1,99);
        myLinkedList.display();
    }
}

在这里插入图片描述

6.删除第一次出现关键字为key的节点

具体思路如下：

1.判断头结点
this.head.val == key;
2.放在中间时
cur.next.val == key;
3.放在末尾时进行判断
while(cur.next != null)

在这里插入图片描述

   /**
     * 找到要删除关键字的前驱
     * @param key
     * @return
     */
    public ListNode searchPerv(int key) {
        ListNode cur = this.head;
        while (cur.next != null) {
            if(cur.next.val == key) {
                return cur;
            }
            cur = cur.next;;
        }
        return null;
    }

    //删除第一次出现关键字为key的节点
    public void remove(int key) {
        if (this.head == null) {
            System.out.println("单链表为空，不能删除");
            return;
        }
        if(this.head.val == key) {
            this.head = this.head.next;
            return;
        }
        ListNode cur = searchPerv(key);
        if (cur == null) {
            System.out.println("没有你要删除的节点");
            return;
        } 
        ListNode del = cur.next;
        cur.next = del.next;
    }

public class TestDemo {
    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.creatList();
        myLinkedList.display();
        myLinkedList.remove(12);
        myLinkedList.display();
        myLinkedList.remove(56);
        myLinkedList.display();
        myLinkedList.remove(34);
        myLinkedList.display();
    }
}

在这里插入图片描述

7.删除所有值为key的节点

    //删除所有值为key的节点
    public ListNode removeAllKey(int key) {
        if(this.head == null) {
            return null;
        }
        ListNode prev = this.head;
        ListNode cur = this.head.next;
        while (cur != null) {
            if(cur.val == key) {
                prev.next = cur.next;
                cur = cur.next;
            }else {
                prev = cur;
                cur = cur.next;
            }
        }

        //最后处理头
        if (this.head.val == key) {
            this.head = this.head.next;
        }
        return this.head;
    }

注意：头结点的处理方式就是在全部删除完毕的时候进行判断，然后再进行删除。

8.清除链表

public void clear() {
    //this.head == null;
    while (this.head != null) {
        ListNode curNext = head.next;
        this.head.next = null;
        this.head = curNext;
    }
}

4.无头双向链表

在这里插入图片描述

5.无头双向链表的实现

public class MyLinkedList {
    static class ListNode {
        public int val;
        public ListNode prev;//前驱
        public ListNode next;//后继

        public ListNode(int val) {
            this.val = val;
        }
    }

    public ListNode head;
    public ListNode last;
}

1.头插法

public void addFirst(int data){
    ListNode node = new ListNode(data);
    if (head == null) {
        head = node;
        last = node;
    }else {
        node.next = head;
        head.prev = node;
        head = node;
    }
}

public class Test {
    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.addFirst(1);
        myLinkedList.addFirst(2);
        myLinkedList.addFirst(3);
        myLinkedList.addFirst(4);
        myLinkedList.addFirst(5);
        myLinkedList.display();
    }
}

在这里插入图片描述

2.尾插法

注意事项：相比于无头单向链表多了尾结点last，相对应的时间复杂度变为了O(1).

public void addLast(int data){
    ListNode node = new ListNode(data);
    if (head == null) {
        head = node;
        last = node;
    }else {
        last.next = node;
        node.prev = last;
        last = node;
    }
}

public class Test {
    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.addFirst(1);
        myLinkedList.addFirst(2);
        myLinkedList.addFirst(3);
        myLinkedList.addFirst(4);
        myLinkedList.addFirst(5);
        myLinkedList.display();
        myLinkedList.addLast(0);
        myLinkedList.display();
    }
}

在这里插入图片描述

3.任意位置插入,第一个数据节点为0号下标

public void addIndex(int index,int data){
    if (index < 0 || index > size()) {
        throw new ListIndexOutOfException("插入位置错误！");
    }
    if (index == 0) {
        addFirst(data);
        return;
    }
    if (index == size()) {
        addLast(data);
        return;
    }
    ListNode cur =findIndex(index);
    ListNode node = new ListNode(data);
    node.next = cur;
    cur.prev.next = node;
    node.prev = cur.prev;
    cur.prev = node;
}
private ListNode findIndex(int index) {
    ListNode cur = head;
    while (index != 0) {
        cur = cur.next;
        index--;
    }
    return cur;
}

public class ListIndexOutOfException extends RuntimeException{

    public ListIndexOutOfException() {

    }

    public ListIndexOutOfException(String message) {
        super(message);
    }
}

public class Test {
    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.addFirst(1);
        myLinkedList.addFirst(2);
        myLinkedList.addFirst(3);
        myLinkedList.addFirst(4);
        myLinkedList.addFirst(5);
        myLinkedList.display();
        myLinkedList.addIndex(6,3);
    }
}

在这里插入图片描述

public class Test {
    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.addFirst(1);
        myLinkedList.addFirst(2);
        myLinkedList.addFirst(3);
        myLinkedList.addFirst(4);
        myLinkedList.addFirst(5);
        myLinkedList.display();
        myLinkedList.addIndex(2,3);
        myLinkedList.display();
    }
}

在这里插入图片描述

4.查找是否包含关键字key是否在链表当中

public boolean contains(int key){
    ListNode cur = this.head;
    while (cur != null) {
        if(cur.val == key) {
            return true;
        }
        cur = cur.next;
    }
    return false;
}

public class Test {
    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.addFirst(1);
        myLinkedList.addFirst(2);
        myLinkedList.addFirst(3);
        myLinkedList.addFirst(4);
        myLinkedList.addFirst(5);
        myLinkedList.display();
        System.out.println(myLinkedList.contains(3));
        System.out.println(myLinkedList.contains(55));
    }
}

在这里插入图片描述

5.删除第一次出现关键字为key的节点

public void remove(int key){
    ListNode cur = head;
    while (cur != null) {
        if (cur.val == key) {
            //1.删除的是头结点
            if (cur == head) {
                head = head.next;
                //只有一个节点
                if (head != null) {
                    head.prev = null;
                }
            }else {
                //中间 尾巴
                cur.prev.next = cur.next;
                //不是尾巴节点
                if(cur.next != null) {
                    cur.next.prev = cur.prev;
                }else {
                    //是尾巴节点
                    last = last.prev;
                }
            }
            return;
        }
        cur = cur.next;
    }
}

public class Test {
    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.addFirst(1);
        myLinkedList.addFirst(2);
        myLinkedList.addFirst(3);
        myLinkedList.addFirst(4);
        myLinkedList.addFirst(5);
        myLinkedList.display();
        myLinkedList.remove(3);
        myLinkedList.display();
    }
}

在这里插入图片描述

6.删除所有值为key的节点

public void removeAllKey(int key){
    ListNode cur = head;
    while (cur != null) {
        if (cur.val == key) {
            //1.删除的是头结点
            if (cur == head) {
                head = head.next;
                //只有一个节点
                if (head != null) {
                    head.prev = null;
                }
            }else {
                //中间 尾巴
                cur.prev.next = cur.next;
                //不是尾巴节点
                if(cur.next != null) {
                    cur.next.prev = cur.prev;
                }else {
                    //是尾巴节点
                    last = last.prev;
                }
            }
        }
        cur = cur.next;
    }
}

public class Test {
    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.addFirst(1);
        myLinkedList.addFirst(2);
        myLinkedList.addFirst(3);
        myLinkedList.addFirst(3);
        myLinkedList.addFirst(5);
        myLinkedList.display();
        myLinkedList.removeAllKey(3);
        myLinkedList.display();
    }
}

在这里插入图片描述

7.得到链表的长度

public int size(){
    int len = 0;
    ListNode cur = head;
    while (cur != null) {
        len++;
        cur = cur.next;
    }
    return len;
}

public class Test {
    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.addFirst(1);
        myLinkedList.addFirst(2);
        myLinkedList.addFirst(3);
        myLinkedList.addFirst(4);
        myLinkedList.addFirst(5);
        myLinkedList.display();
        System.out.println(myLinkedList.size());
    }
}

在这里插入图片描述

8.打印链表

public void display(){
    ListNode cur = head;
    while (cur != null) {
        System.out.print(cur.val + " ");
        cur = cur.next;
    }
    System.out.println();
}

public class Test {
    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.addFirst(1);
        myLinkedList.addFirst(2);
        myLinkedList.addFirst(3);
        myLinkedList.addFirst(4);
        myLinkedList.addFirst(5);
        myLinkedList.display();
    }
}

在这里插入图片描述

9.清除链表

public void clear() {
    ListNode cur = head;
    while (cur != null) {
        ListNode curNext = head.next;
        cur.prev = null;
        cur.next = null;
        cur = curNext;
    }
    head = null;
    last = null;
}

public class Test {
    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.addFirst(1);
        myLinkedList.addFirst(2);
        myLinkedList.addFirst(3);
        myLinkedList.addFirst(4);
        myLinkedList.addFirst(5);
        myLinkedList.display();
        myLinkedList.clear();
        myLinkedList.display();
    }
}

在这里插入图片描述

6.LinkedList的遍历

public static void main(String[] args) {
	LinkedList<Integer> list = new LinkedList<>();
	list.add(1); // add(elem): 表示尾插
	list.add(2);
	list.add(3);
	list.add(4);
	list.add(5);
	list.add(6);
	list.add(7);
	System.out.println(list.size());
	// foreach遍历
	for (int e:list) {
		System.out.print(e + " ");
	}
	System.out.println();
	// 使用迭代器遍历---正向遍历
	ListIterator<Integer> it = list.listIterator();
	while(it.hasNext()){
		System.out.print(it.next()+ " ");
	}
	System.out.println();
	// 使用反向迭代器---反向遍历
	ListIterator<Integer> rit = list.listIterator(list.size());
	while (rit.hasPrevious()){
		System.out.print(rit.previous() +" ");
	}
	System.out.println();
}

4.顺序表和链表的区别和联系

顺序表：一白遮百丑

白：空间连续、支持随机访问。

丑：1.中间或前面部分的插入删除时间复杂度O(N) 2.增容的代价比较大。

链表：一(胖黑)毁所有

胖黑：以节点为单位存储，不支持随机访问。

所有：1.任意位置插入删除时间复杂度为O(1) 2.没有增容问题，插入一个开辟一个空间。

5.ArrayList和LinkedList的区别

在这里插入图片描述

Monody·
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
单链表c#语言实现
qiushubo的博客
09-30 443
我们要知道一点：单链表是由无数个结点组成的。 故单链表实现必须有两个类：结点类（存数据域和指针域） 链表类（统筹每个结点） 结点类： class listnode<T> { public T value;//数据域 public listnode<T> nextnode;//指针域 public listnode(T value)//构造函数给结点赋值 { ...
C#中List泛型集合引用问题（深度拷贝）
Hito的博客
04-06 9339
List 集合引用问题这段时间公司有个Silverlight项目要加几个报表模块，之前从未接触过这个叫“银光”的东西，之前在学校也是做的Net，迫于无赖就接手了，说说这个把月的心得以及遇到的问题。 首先说下什么是Silverlight，官网的解释是：Microsoft Silverlight 是一个跨浏览器、跨平台的 .NET Framework 实现，用于生成 Web、桌面和 Windo
ListNode
BKKBjams的博客
02-20 1407
ListNode:在节点ListNode定义中，定义为节点为结构变量。 public class ListNode{ int val; ListNode next; //链表指向的下一个值的指针 ListNode(int x){val = x;} //这个方式赋值 } ListNode在定义时： 首个值不能为0，当第一个参数为0时，代表着链表为空。 节点存储了两个变量：value 和 next。value 是这个节点的值，next 是指向下一节点的指针，当 ne
【数据结构】顺序表和单链表所有知识点（附带面试题）
龙跃十二
02-06 3017
一、顺序表 顺序表定义 ：顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。
队列的应用、栈的应用
微信公众号: 后端码匠
12-06 1066
实验一：队列的应用、栈的应用 一． 实验目的 1、掌握队列的特点(先进先出 FIFO)及基本操作，如入队、出队等。 2、利用循环队列的特点解决实际问题，提高编程能力。 3、掌握栈的特点(先进后出 FILO)及基本操作，如入栈、出栈等。 4、利用栈的特点解决实际问题，提高编程能力。 二． 实验内容 1、编写一个程序实现循环队列的各种基本运算，并在此基础上设计一个主程序，完成如下功能： (1)初始化循环队列； (2)给定一个元素，将此元素插入此队列中； (3)将队头一个元素出队。 2、编程实现顺序栈的各种基本运
数据结构与算法-顺序表（链表篇）
09-09
代码资源
JavaScript中数据结构与算法(三)：链表
12-02
我们可以看到在javascript概念中的队列与栈都是一种特殊的线性表的结构，也是一种比较简单的基于数组的顺序存储结构。由于javascript的解释器针对数组都做了直接的优化，不会存在在很多编程语言中数组固定长度的问题...
顺序表和单向链表练习
qq_38175059的博客
02-04 315
顺序表和链表练习题
C# List的引用
pretty_h的博客
12-31 2495
初次了解ListNode，针对ListNode的理解
热门推荐
qq_38271904的博客
03-02 4万+
关于ListNode public class ListNode{ int val; ListNode next; //链表指向的下一个值的指针 ListNode(int x){val = x;} //这个方式赋值 } 我想到的几点事项 定义链表ListNode时， 链表的首个值不能为0，当首个参数为0时，代表着链表为空。 只需要定义一个List...
C#实现泛型列表List
qq_41886896的博客
05-08 2742
前言：入行快一年了第一次写博客。其实寻思了一下也没啥能写的，毕竟学艺不精，不过看了好多本数据结构的书，总结一下，也是很好的，顺便帮助一下比我更菜的人...如有问题请指出，不胜感激。 其实网上关于类似的博客很多，但是好多大神会、懂，但是不一定会讲，因为他们早已忘了菜是什么感觉了。 = =，而我不一样，我会把我学习过程中遇到问题都拿出了，希望对你们有帮助。 一，什么是列表？ 1，列表是什么意思？...
C# List深拷贝和浅拷贝的简单案例说明
luke2834的专栏
04-14 8015
基本说明 当List的元素类型是复杂类型时，使用它的拷贝函数拷贝出来的内容是浅拷贝的，不会自动再去调用元素的拷贝构造函数，如下例子： using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace DTATest { class Program {
线性表的两种存储结构：顺序表VS链表
weixin_46515988的博客
10-12 1753
导言：写程序解决实际问题时，或者在考试题面试题中，经常会遇到选择数据结构的问题。如果要用线性表，那么什么时候选择顺序表？什么时候选用链表作为线性表的存储结构？在学校写C和C++作业题，用到线性表时，没什么是一个数组解决不了的好吧—_—。考虑到开头提到的情况，现总结几点顺序表与链表的选择依据： 1.存取方式。当对线性表主要进行查找操作，很少进行插入与删除操作时，采用链表较好。（顺序表是随机存储结构，获取任意元素的时间复杂度都是O(1)；而链表是顺序存储结构，存取某个结点的时间复杂度为O(n) 2.插入与删
顺序表（顺序存储结构）与 链表（单链表）
dong134679011的博客
09-07 2519
顺序表与链表详解 基本操作
数据结构-线性表的两种实现方式：顺序表和链表
a2352159950的博客
07-16 1133
顺序表就是在内存中按顺序连续开辟一段空间来存储数据的结构，在java中就是数组，如a所示 链表就是在内存中随机开辟内存一段段存储数据的结构，如图b所示 线性表的接口 使用一个接口表明基本操作的需求： public interface Ilist { //清空线性表 public void clear(); //判断线性表是否为空 public boolean isEmpty(); //获取线性表的长度 public int length(); /.
FME学习之旅---day27
最新发布
summer_corner的博客
05-17 191
我们付出一些成本，时间的或者其他，最终总能收获一些什么。
使用多实例学习进行乳腺癌组织病理学图像分类和定位
qq_47896523的博客
05-16 1086
乳腺癌是女性最主要的死亡原因，病理学家根据病理切片中观察到的各种视觉特征（例如细胞核的形态特征、细胞核的微观和宏观结构等）做出决定。计算机辅助诊断（CAD）系统可以帮助病理学家自动做出决策。卷积神经网络是最广泛使用的深度学习框架，用于学习图像类别之间的复杂判别特征。多年来，VGG16 [3] 和 ResNet18 [4] 等各种 CNN 架构在海量 ImageNet 数据集上产生了出色的结果。CNN 被用于医学图像以产生最先进的结果。为图像中存在的所有类别提供了定位信息。
数据结构与算法约瑟夫环之循环链表
12-03
循环链表是一种特殊的链表，它的最后一个节点指向头节点，形成一个环。约瑟夫环问题是一个经典的问题，它的描述是：n个人围成一圈，从第k个人开始报数，报到m的人出圈，然后从出圈的下一个人开始重新报数，直到所有...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值