顺序表和链表的基本操作（Java实现）

最新推荐文章于 2022-03-22 15:47:55 发布
最新推荐文章于 2022-03-22 15:47:55 发布
阅读量1.3k 收藏 17
点赞数 4
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/smell201611010513/article/details/89353407
版权 
线性表
头插/尾插/中间插入   头删/尾删
1.顺序表
  想细节，写伪代码。
难点：循环边界
2.链表（*****）
结点和结点之间的逻辑关系

一、顺序表

逻辑上有前后关系，物理存储也是前后相连的。

1、插入操作

头插：
思考：（伪代码）
1.需要后移size个元素
2.为避免数据被覆盖，从后往前移
3.空间[size,1]  数据[size-1,0]
4.array[空间的下标]=array[数据的下标]
5.空间的下标=数据的下标+1

插入：(在下标为index的位置上插入item)
思考：（伪代码）
1.需要后移size-index个元素
2.为避免数据被覆盖，从后往前移
3.空间[size,index+1]  数据[size-1,index]
4.array[空间的下标]=array[数据的下标]
5.空间的下标=数据的下标+1

在插入和头插的时候，要注意从后往前插。

尾插：直接插入

2、删除操作

头删：
1.需要移动size-1个数据
2.为避免数据覆盖，从前往后移。
3.空间[0,size-1],数据[1,size]
4.array[空间的下标]=array[数据的下标]
5.空间的下标=数据的下标+1
删除：下标是index的数据
1.需要移动size-index-1个数据
2.为避免数据覆盖，从前往后移。
3.空间[index,size-2],数据[1+index,size-1]
4.array[空间的下标]=array[数据的下标]
5.空间的下标=数据的下标+1

3、时间复杂度

	尾插/尾删		O(1) 均摊O(1),在扩容时是O(n)
	头插/头删		O(n)  数据搬移是耗时的
	中间插入/删除	      O(n)  数据搬移是耗时的
        查找的时间复杂度         O(1)直接通过下标

4、扩容

假如我们的数组放不下了，扩容
this.array  住的老房子
this.size    房子里住的人
应该搬家    this.size==this.array.length
1)先找新房子
2)搬家
3)this.array=新房子的地址
4)退掉老房子

5、顺序表的代码实现

package com.company.DataStruct.list.arraylist;

public interface IArrayList {
    //增 删

    /**
     * 把item插入到线性表的前面
     * @param item 要插入的数据
     */
    void pushFront(int item);

    /**
     * 把item插入到线性表的最后
     * @param item
     */
    void pushBack(int item);

    /**
     * 把item插到index下标位置处，index后的数据后移
     * @param item
     * @param index
     */
    void add(int item,int index);

    /**
     * 删除前面的数据
     */
    void popFront();

    /**
     * 删除最后的数据
     */
    void popBack();

    /**
     * 删除index处的数据，index后的数据前移
     * @param index
     */
    void remove(int index);

    /**
     * 查找关键字key是否在链表中
     * @param key
     * @return 如果在，返回下标；不在，返回-1.
     */
    int search(int key);

    /**
     * 判断关键字key是否在链表中
     * @param key
     * @return
     */
    boolean contains(int key);

    /**
     * 得到pos位置的值
     * @param pos
     * @return
     */
    int getPos(int pos);

    /**
     * 打印顺序表
     */
    void display();

    /**
     * 清空顺序表
     */
    void clear();
}

package com.company.DataStruct.list.arraylist;

public class MyArrayList implements IArrayList {
    private int[] array;//保存数据的空间
    private int size;//保存有效数据个数(数据规模）

    MyArrayList(int capacity){
        this.array=new int[capacity];
        this.size=0;
    }


    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    /**
     * 返回下标是index的数据
     * @param index
     * @return
     */
    public int getIndex(int index){
        return array[index];
    }
    @Override

    //头插  T(n)=O(n)
    public void pushFront(int item) {
        ensureCapacity();
    //将已有的数据后移一格(从后往前）
        for(int i=this.size;i>0;i--){
            this.array[i]=this.array[i-1];
        }
        this.array[0]=item;
        this.size++;
    }

    @Override
    public void pushBack(int item) {
        ensureCapacity();
        if(this.array.length>this.size) {
            this.array[size++] = item;
        }else{
            System.out.println("空间不够，插入失败");
        }
    }

    @Override
    public void add(int item, int index) {
        ensureCapacity();
//        i代表空间的下标
//        for(int i=this.size;i>index;i--){
//            this.array[i]=this.array[i-1];
//        }
        if(index<0||index>this.size){
            throw new Error();
        }
        //index=0时是最坏情况，
//        i代表数据的下标
        for(int i=this.size-1;i>=index;i--){
            this.array[i+1]=this.array[i];
        }
//        i代表循环的次数
//        for(int i=0;i<this.size-index;i++){
//            this.array[size-i]=this.array[size-i-1];
//        }

        this.array[index]=item;
        this.size++;
    }

    @Override
    public void popFront() {
        for(int i=0;i<this.size-1;i++){
            this.array[i]=this.array[i+1];
        }
        this.size--;
    }

    @Override
    public void popBack() {
        if(this.size==0){
            throw new Error();//抛出异常
        }
        this.size--;
    }

    @Override
    public void remove(int index) {
        if(index<0||index>=this.size){
            throw new Error();
        }
        if(this.size==0){
            throw new Error();
        }
        for(int i=index;i<this.size-1;i++){
            this.array[i]=this.array[i+1];
        }
        this.size--;
    }

    @Override
    public int search(int key) {
        for(int i=0;i<this.array.length;i++){
            if(key==this.array[i]){
                return i;
            }
        }
        return -1;
    }

    @Override
    public boolean contains(int key) {
        for(int i=0;i<this.array.length;i++){
            if(key==this.array[i]){
                return true;
            }
        }
        return false;
    }

    @Override
    public int getPos(int pos) {
        if(pos<0||pos>=this.size){
            throw new Error();
        }
        return this.array[pos];
    }

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

    @Override
    public void clear() {
        for(int i=0;i<this.size;i++){
            this.array[i]=0;
        }
    }

    /**
     * 扩容，保证数组容量够用  T(n)=O(n)
     */
    private void ensureCapacity(){
        if(this.size<this.array.length){//当前容量够用来存放新的数据，直接返回。
            return;
        }
        //1.找新房子，找原来的两倍大。
        int capacity=this.array.length*2;
        int[] newArray=new int[capacity];

        //2.搬家
        for(int i=0;i<this.size;i++){
            newArray[i]=this.array[i];
        }

        //3.登记新房子的位置，推掉老房子
        this.array=newArray;//原来的数组用于没有引用，JDK会自动回收。

    }
}

测试代码：

package com.company.DataStruct.list.arraylist;

import com.company.DataStruct.list.arraylist.MyArrayList;

public class Test {
    public static void main(String[] args) {
        MyArrayList arrayList=new MyArrayList(10);
        arrayList.pushBack(1);
        arrayList.pushBack(2);
        arrayList.pushBack(3);

        arrayList.pushFront(6);
        arrayList.pushFront(5);//5 6 1 2 3

        arrayList.add(4,2);//5 6 4 1 2 3
        for(int i=0;i<arrayList.getSize();i++){
            System.out.print(arrayList.getIndex(i)+" ");
        }
        System.out.println();
        System.out.println("=======================================");
        arrayList.popFront();//6 4 1 2 3
        arrayList.remove(2);//6 4 2 3
        arrayList.popBack();
        System.out.println("=======================================");
        for(int i=0;i<arrayList.getSize();i++){
            System.out.print(arrayList.getIndex(i)+" ");
        }
        System.out.println();
        System.out.println("=======================================");
        System.out.println(arrayList.search(2));//2
        System.out.println("=======================================");
        System.out.println(arrayList.contains(9));//false
        System.out.println(arrayList.getPos(1));//4
        //插入10个数
        for(int i=0;i<10;i++) {
            arrayList.pushBack(i*100);
        }
        //打印
        arrayList.display();
        //清空
        arrayList.clear();
        //打印
        arrayList.display();//10个0 清空之后，数组又变为原来的容量
    }
}

结果：

二、链表

逻辑上有线性关系  但是物理存储不保证连续（前后相连）。
结点类{值，下一个结点的引用}
链表类  第一个结点的引用

1.链表结点间的关系

引用{value,next},如：
@0xFF{1.@0xCC}
@0xCC{2,@0x33}
@0x33{3,@0x99}
@0x99{4,@0xAA}
@0xAA{5,null}
分析下面的每句代码代表什么意思？
Node p1=//@0xFF
Node p2=//@0xAA
Node p3=//0x@CC
p1.next=p2; <=>@0xFF{1,@0xAA}
p2=p1.next;   <=> p2=//@0xCC;
p1.next.next=p2;<=> @0xCC{2,@0xAA}
p1.next.next=p3.next.next;<=> @0xCC{3,@0x99}
p1=p2;<=>p1=@0xAA

2.头删与头插

头插：
1）先创建一个结点
2）设置结点的下一个结点是原来的头结点
3）修改原来链表的头结点为新结点
头删：
1）首先判断链表是否为空
2）如果链表为空，抛出异常
3）如果链表不为空，则修改原来的头结点为原头结点的下一个结点

3.尾删与尾插

尾插：
1）先创建一个结点
2）如果链表为空，则将该结点赋值给链表的头结点。
3）否则获取到链表的最后一个结点，修改最后一个结点的next为新结点。
尾删：
1）先判断链表是否为空。
2）如果为空，则直接抛出异常。
3）如果不为空，寻找链表的倒数第二个结点，修改该结点的next为null。
4）如果链表只有一个结点，则将链表的头结点设置为null。

4、链表的代码实现

package com.company.DataStruct.list.linkedlist;

public class MyLinkedList {
    /**
     * 链表中的一个结点(内部类)
     */
    public class Node{
        public int value;//保存的是有效数据
        public Node next;//下一个结点的线索（引用）
        Node(int v){
            this.value=v;
            this.next=null;
        }
    }

    //    如果一个结点都没有，head=null
    private Node head;//保存链表中第一个结点的引用

    public Node getHead() {
        return head;
    }

    MyLinkedList(){
        this.head=null;

    }


    /**
     * 头插  将item值的结点插入到链表的最前面
     * @param item
     */
    public  void pushFront(int item){
        //先创建一个新结点
        Node node=new Node(item);
        node.next=head;
        this.head=node;
    }

    /**
     * 获取链表的最后一个结点
     * @return
     */
    private Node getLast(){
        Node cur=this.head;
        while(cur.next!=null){
            cur=cur.next;
        }
        return cur;
    }
    /**
     * 尾插
     * @param item
     */

    public void pushBack(int item){
        Node node=new Node(item);
        if(this.head==null){
            this.head=node;
        }else{
            Node last=getLast();
            last.next=node;
        }
    }

    /**
     * 头删  T(n)=O(1)
     */
    public  void popFront(){
        if(this.head==null){//链表为空
            throw new Error();
        }
        this.head=this.head.next;
    }

    /**
     * 查找倒数第二个结点
     * @return
     */
    private Node getSecondLast(){
        Node pNode=this.head;
        while(pNode.next.next!=null){
            pNode=pNode.next;
        }
        return pNode;
    }
    /**
     * 尾删
     */
    public  void popBack(){
        if(this.head==null){
            throw new Error();
        }
        if(this.head.next==null){//链表中只有一个结点
            this.head=null;
        }
        Node pNode=getSecondLast();
        //此时pNode是倒数第二个结点
        pNode.next=null;
    }

    /**
     * 如何通过循环，遍历链表的每个结点
     */
    void display(){
       Node cur=this.head;
       while(cur!=null){
           System.out.format("%d-->",cur.value);
           cur=cur.next;
       }
       System.out.println("null");
    }
}

测试代码：

package com.company.DataStruct.list.linkedlist;

public class TestLinkedList {
    public static void main(String[] args) {
        MyLinkedList myLinkedList=new MyLinkedList();
        myLinkedList.pushFront(1);
        myLinkedList.pushFront(2);
        myLinkedList.pushBack(3);
        myLinkedList.pushBack(4);
        myLinkedList.pushBack(5);//2 1 3 4 5
        myLinkedList.popBack();
        myLinkedList.popFront();//1 3 4
        //遍历打印
        myLinkedList.display();
    }
}

结果：

 

寻瀑
关注
专栏目录
Java 实现顺序表的基本操作
近未来
06-08 7303
顺序表 静态顺序表：使用定长数组存储。 动态顺序表：使用动态开辟的数组存储。 接口 package com.github.sqlist; public interface ISequence { // 在 pos 位置插入 val boolean add(int pos, Object data); // 查找关键字 key 找到返回 key 的下表，没有返回 -1 ...
Java基础之顺序表和链表的实现
qq_49912778的博客
01-14 234
由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。其中数组是一种特殊的线性结构，在数组中保存的元素允许出现空的，线性结构不能出现空洞。顺序表对象是在数组对象的基础上构建的，在构建顺序表时，我们首先要初始化容量，在数据元素个数与容量相等时，进行容量扩充，使该顺序表不会出现溢出的现象。在数组不在能够放入新的元素时，进行扩容操作，保证数组容量够用。
数据结构笔记（四）顺序表和链表的基本操作
weixin_45541911的博客
08-20 504
线性表 线性表又分为顺序储存和链式储存，分别称为顺序表和链表。 顺序表 在计算机中申请一块连续的空间，将元素按存入,是一种随机存取的方式，这种方式可以随时读取，其时间复杂度为O(1)，但需要做增删操作时，需要移动大量元素，时间复杂度是O（n）。因为是连续的空间，因此会造成空间浪费或溢出的现象。 删除顺序表的第 i 个元素时，需要移动 n - i 个元素； 插入到第 i 个位置时，需要移动 n - i + 1个元素。 顺序表有静态分配与动态分配，这里记录最常用的动态分配 #include<stdlib
Java-实现顺序表的基本操作
weixin_34248849的博客
04-28 347
2019独角兽企业重金招聘Python工程师标准>>> ...
Java顺序表和链表
awsl8694的博客
08-03 326
Java顺序表和链表线性表顺序表链表顺序表与链表的区别和联系 线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见 的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构,也就说是连续的一条直线。但是在物理结构上并不一定是连续的,线性表在物理上存储时,通常以数组和链式结构的形式存储。 顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数 据的增删查改。
顺序表和链表基本操作
qq_44929652的博客
05-26 397
顺序表（底层是数组） 1.打印 public void display(){ //打印顺序表 String result="["; for(int i=0;i<size;i++){ result+=datas[i]; if(i<size-1){ result+=","; } } result+="]";
Java实现顺序表和链表（单链表、双链表）
weixin_50922984的博客
03-22 1375
简单介绍顺序表和链表 并用Java实现顺序表和链表（单链表、双链表）的一些操作 如头插法 尾插法等
基于Java实现的单链表基本操作之链表合并.zip
04-26
本项目聚焦于Java实现的单链表基本操作，特别是链表的合并这一关键操作。下面将详细介绍单链表的概念、基本操作以及如何在Java中实现链表合并。 单链表是一种线性数据结构，每个节点包含两部分：数据域，用于存储...
基于Java实现的单链表基本操作之链表反转.zip
最新发布
04-26
在这个基于Java实现的单链表基本操作中，我们将重点关注链表反转这一特定操作。 链表反转是编程面试中常见的问题，它要求我们改变链表中节点的顺序，使得原链表的最后一个节点成为新链表的第一个节点，原链表的第一...
基于Java实现的单链表基本操作之获取链表长度.zip
04-26
本教程主要探讨的是如何在Java编程语言中实现单链表的基本操作，特别是如何获取链表的长度。下面我们将深入讨论相关知识点。 首先，我们需要理解单链表的概念。单链表是由一系列节点构成的，每个节点包含两部分：...
顺序表，链表的基本操作
lyuBetina的博客
05-27 479
#include<stdio.h> #inclide<malloc.h> #include<stdlib.h> #include<stfbool.h> #include using namespace std; //顺序表的静态分配 #define MaxSize 50 typedef struct{ ElemType data[MaxSize]; int length; }SqList; //顺序表的动态分配 #define MaxSize 100 type
c++实现顺序表和链表的基本操作
mydreamy的博客
10-09 822
c++实现顺序表和链表的基本操作。文章包括数据结构线性表的定义以及基本操作方法，如Init(),insert(),Locate(),Delete()等。并给出了顺序表和链表两种类型的操作
Java 数据结构 （顺序表和单链表）
以终为始
02-02 280
顺序表底层的数据结构是什么？ 顺序表的增删改查操作。 单链表的结构 单链表的增删改查操作（单链表删除的两种方法实现，进行方法对比（一种课堂实现，一种留作作业）） 带头结点的循环单链表结构和带头结点的双向循环链表 单链表的作业 5.1 单链表与顺序表在存储结构的时候应该如何选择 5.2 如何判断一个单链表是否有环 5.3 找出两个单链表的相交节点 5.3 两个有序单链表合并成一个有序的单链表 ...
Java 顺序表的基本操作（增删查改，扩容，冒泡排序，逆序）
m0_56315670的博客
02-19 1542
数组的初始化 package list; public class Seqlist { private Object[] elements; private static int size ;//将size作为数组elements容器 public Seqlist(int capacity){ size = 0; elements = new Object[capacity]; } public Seqlist() { this(10);
java-顺序表基本操作
weixin_42440457的博客
01-22 835
顺序表功能: 1.getSize 获取长度 2.display 依次打印出每个元素 3.add 指定位置插入元素 4.contains 判定是否包含某个元素 5.search 查找某个元素对应的位置 6.getPos 获取pos位置的元素 7.setPos 给pos位置的元素设为value 8.remove 删除指定的值 package SeqList; public c...
顺序表基本操作(Java)
zhaozhiwei_001的专栏
11-26 626
package com.zzw; public interface IList { public void clear(); public boolean isEmpty(); public int length(); public Object get(int i); public void insert(int i,Object x); public void remove(
Java-顺序表的基础操作（增、删、改、查等）
weixin_42392831的博客
10-08 206
import java.util.Arrays; public class SeqList { private int[] data = new int[10];//这个数组的最大容量是10，初始情况下，这10个元素并不都是有效元素 private int size = 0;//size表示当前数组中有多少个有效元素 public void display(){ //System.out.prin...
Java顺序表的基本操作
spark_x的博客
04-22 803
Java顺序表的操作 1，在pos位置新增元素 2，打印顺序表 3，判断是否包含某个元素 4，查找某个元素的位置 5，获取pos位置的元素 6，获取顺序表长度 7，删除给定的关键词key import java.util.Arrays; public class MyArrayList { public int[] elem; //数组 public int usedSi...
java顺序表和链表的基本操作
06-10
顺序表和链表是两种常见的数据结构，它们都可以用来实现线性表，但是在实现上有所不同。 1. 顺序表的基本操作： - 初始化：创建一个定长的数组，用来存储数据。 - 插入：在指定位置上插入一个元素，需要将该位置及其后面的元素全部后移，时间复杂度为O(n)。 - 删除：删除指定位置上的元素，需要将该位置后面的元素全部前移，时间复杂度为O(n)。 - 查找：根据元素的值或者下标查找指定元素，时间复杂度为O(n)。 - 修改：修改指定位置上的元素，时间复杂度为O(1)。 2. 链表的基本操作： - 初始化：创建一个头节点，头节点不存储数据，用来标识链表的起始位置。 - 插入：在指定位置上插入一个元素，需要先找到该位置的前一个节点，然后将该节点的next指针指向新节点，新节点的next指针指向该节点后面的节点，时间复杂度为O(n)。 - 删除：删除指定位置上的元素，需要先找到该位置的前一个节点，然后将该节点的next指针指向该节点后面的节点，时间复杂度为O(n)。 - 查找：根据元素的值或者下标查找指定元素，需要从头节点开始遍历整个链表，时间复杂度为O(n)。 - 修改：修改指定位置上的元素，需要先找到该节点，然后修改该节点存储的数据，时间复杂度为O(n)。 总体而言，顺序表适用于频繁访问元素，而不频繁修改和删除的场景，链表适用于频繁修改和删除元素的场景。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值