顺序表链表小结

最新推荐文章于 2023-01-15 23:52:10 发布
最新推荐文章于 2023-01-15 23:52:10 发布
阅读量226 收藏 3
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/webstudy12/article/details/102841180
版权

一.顺序表

  1. 顺序表是基于数组实现的
  2. 顺序表上的数据在物理内存和逻辑结构上都是连续的
    在这里插入图片描述

顺序表代码如下：

import java.util.Arrays;

class MyArrayList {
    public int usedSize;//有效数据个数
    public int[] elem;
    public final int CAPACITY=10;//容量定为10
    public  MyArrayList(){//构造方法，初始化成员属性
        this.usedSize=0;
        this.elem=new int[CAPACITY];
    }
    //判断是否为空
    private boolean isFull(){
        if (this.usedSize==this.elem.length){
            return true;
        }
        return false;
    }
    //判断是否未满
    private boolean isEmpty(){
        return this.usedSize==0;//为空返回true，不为空返回false
    }
    // 在 pos 位置新增元素
    public void add(int pos, int data) {
        if (isFull()){
            this.elem=Arrays.copyOf(this.elem,this.elem.length*2);
        }
        //1.判断POS是否合法
        if(pos<0||pos>this.usedSize){
            throw new IndexOutOfBoundsException("pos位置不合法");
            //System.out.println("pos位置不合法");
            //return;
        }
        //2.挪数据
        for (int i=this.usedSize-1;i>=pos;i--){
            this.elem[i+1]=this.elem[i];
        }
        //3.插入数据
        this.elem[pos]=data;
        //4.usedSize++
        this.usedSize++;
    }
    // 判定是否包含某个元素
    public boolean contains(int toFind) {
        for (int i = 0; i <this.usedSize ; i++) {
            if (this.elem[i]==toFind){
                return true;
            }
        }
        return false;
    }
    // 查找某个元素对应的位置
    public int search(int toFind) {
        for (int i = 0; i <this.usedSize ; i++) {
            if (this.elem[i]==toFind){
                return i;
            }
        }
        return -1;
    }
    // 获取 pos 位置的元素
    public int getPos(int pos) {
        if (pos<0||pos>this.usedSize){
            return -1;
        }
     return this.elem[pos];
     }
    // 给 pos 位置的元素设为 value
//    public void setPos(int pos, int value) {
//
//    }
    //删除第一次出现的关键字key
    public void  remove(int toRemove) {
        //1.顺序表是否为空
        if (isEmpty()){
            System.out.println("为空");
        }
         //2查找toRemove下标.
        int index=search(toRemove);
        if (index==-1){
            System.out.println("没有你想删除的数字");
            return ;
        }

        //3.删除
        for (int i = index; i <this.usedSize-1 ; i++) {
            this.elem[i]=this.elem[i+1];
        }
        this.usedSize--;
    }
    // 获取顺序表长度
    public int size() {
        return this.usedSize;
    }
    // 清空顺序表
    public void clear() {
        this.usedSize=0;
    }
    // 打印顺序表
    public void display() {
        for (int i = 0; i <this.usedSize ; i++) {
            System.out.print(this.elem[i]+" ");
        }
        System.out.println();
    }
}

测试类如下：

package 顺序表和链表;

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

二.链表

1.链表的分类：
单向，双向；带头，不带头；循环，非循环
2.链表特点：
· 链表在物理结构上不一定连续，但在逻辑结构上一定连续
·链表中的节点除第一个节点无直接前驱，最后一个节点无直接后继外，其余节点都有唯一的前驱和唯一的直接后继

三.实现链表：这里主要说无头单向链表和无头双向链表
1.单链表
在这里插入图片描述
单链表的实现代码如下：

//节点类
class ListNode1 {
    public int data;
    public ListNode1 next;

    public ListNode1(int data) {
        this.data = data;
        this.next = null;
    }
}
//链表类
public class SingleList2 {
        public ListNode1 head;
        public SingleList2 (){
            this.head=null;
        }
        //头插法
    public void addFirst(int data){
            ListNode1 node=new ListNode1(data);//创建一个节点
            //首先判断链表是否为空，为空直接让head指向节点
        if (this.head==null){
            this.head=node;
        }else{
            node.next=this.head;
            this.head=node;
        }
    }
    //尾插法
    public void addLast(int data){
            ListNode1 node=new ListNode1(data);
            ListNode1 cur=this.head;
            if (this.head==null){
                this.head=node;
            }else {
                while (cur!=null){
                    cur=cur.next;
                }
                cur.next=node;
            }
    }
    //找到index-1的位置
    private ListNode1 searchIndex(int index){
            ListNode1 cur=this.head;
            //cur->index-1
        while (index-1>0){
            cur=cur.next;
            index--;
        }
        return cur;
    }
    //任意位置插入
    public boolean addIndex(int index,int data){
            ListNode1 node= new ListNode1(3);
            if (index<0||index>getLength()){
                System.out.println("插入位置不合法");
                return false;
            }
            if (index==0){
                addFirst(data);
                return true;
            }else{
                ListNode1 cur=searchIndex(index);
                node.next=cur.next;
                cur.next=node;
            }
            return true;
    }

    //得到链表长度
    public int  getLength(){
            ListNode1 cur=this.head ;
             int count=0;
             while(cur!=null){
                 count++;
                 cur=cur.next;
             }
             return count;
    }
    //反转链表
    public ListNode1 reverseList(){
            ListNode1 pre=null;
            ListNode1 newHead=null;
            ListNode1 cur=this.head;
            while(cur!=null){
                ListNode1 curNext=cur.next;
                if (curNext==null){
                    newHead=cur;
                }
                cur.next=pre;
                pre=cur;
                cur=curNext;
            }
            return newHead;
    }
    //单链表的中间节点
    public ListNode1 middleNode() {//定义快慢指针
        ListNode1 fast=this.head;
        ListNode1 slow=this.head;
        while (fast!=null&&fast.next!=null){
            fast=fast.next.next;
            slow=slow.next;
        }
        return slow;
    }

    //找到倒数第k个节点
    public ListNode1 findKthToTail(int k){
        // k > getLength()
        if(k <= 0) {
            return null;
        }
        ListNode1 fast = this.head;
        ListNode1 slow = this.head;
        while (k-1>0) {
            if(fast != null) {
                fast = fast.next;
                k--;
            }else {
                System.out.println("没有这个节点");
                return null;
            }
        }
        while (fast.next != null) {
            fast = fast.next;
            slow = slow.next;
        }
        return slow;

    }
    //显示链表
    public void display(){
            ListNode1 cur=this.head;
            while(cur!=null){
                System.out.print(cur.data+" ");
                cur=cur.next;
            }
        System.out.println();
    }
    public void display2(ListNode1 newHead){
        ListNode1 cur=newHead;
        while(cur!=null){
            System.out.print(cur.data+" ");
            cur=cur.next;
        }
        System.out.println();
    }
}

测试类代码如下：

public class TestSingleList2 {
    public static void main(String []args){
        SingleList2 singleList2=new SingleList2();
        singleList2.addFirst(1);
        singleList2.addFirst(2);
        singleList2.addFirst(3);
        singleList2.addFirst(4);
        singleList2.addFirst(5);
        singleList2.addFirst(6);
        singleList2.addFirst(7);
        singleList2.addFirst(8);
//        singleList2.display();
//        ListNode1 node=singleList2.middleNode();
//        System.out.println(node.data);
//        ListNode1 head=singleList2.reverseList();
//        singleList2.display2(head);
        ListNode1 node=singleList2.findKthToTail(5);
            System.out.println(node.data);
            int length=singleList2.getLength();
        System.out.println("单链表长度为: "+length);
    }
}

头插法：
在这里插入图片描述
尾插法：
在这里插入图片描述
任意插：
在这里插入图片描述
反转链表：
在这里插入图片描述
注意：上述代码中所有方法必须通过画图才能理解，不然很是抽象
找中间结点：
在这里插入图片描述
找到倒数第k个节点
在这里插入图片描述
未完待续…

哈德森
关注
2014广工数据结构期末考试试卷(B)
04-27
- **选项解析**：通过观察给定的二叉树结构，可以确定后序遍历的顺序为4526731。 - **正确答案**：C。4526731。 13. **哈夫曼树的带权路径长度** - **选项解析**：哈夫曼树的带权路径长度WPL等于各个叶子结点的...
数据结构---顺序表和链表的总结
weixin_44518702的博客
05-14 939
数据结构—顺序表和链表的总结 线性表（linear list）：是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常 见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存 储时，通常以数组和链式结构的形式存储。 顺序表（数组） **定义：**是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成 数据的增删查改。 顺序表一般可以分为： 静态顺序
顺序表&链表超全大总结
yue152152的博客
03-29 1775
线性表 线性表是n个具有形同特性的数据元素的有限序列。常见的线性表：顺序表、链表、栈，队列、字符串……本文重点讲解顺序表和链表，其他结构可见数据结构专栏的其他内容 注意：线性表在逻辑上是线性结构，也就是说是连续的但在物理结构上。但是在物理结构上并不一定是连续的，线性表在物 理上存储时，通常以数组和链式结构的形式存储。 顺序表 概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般可分为静态顺序表和动态顺序表
顺序表和链表学习小结
Llinxi的博客
11-08 1063
顺序表和链表小总结
数据结构--顺序表简单实现(总结)
weixin_48084293的博客
07-11 1420
文章目录顺序表特点功能实现定义函数初始化重置表获取表长判断是否为空表访问元素遍历顺序表获取元素查找元素头插尾插指定位置插入元素头删尾删指定位置删除元素指定元素删除合并表测试代码 顺序表 特点 顺序表是有序、有限，且元素数据类型相同的集合。 除第一个元素外，其他元素都有唯一的前驱元素。 除最后一个元素外，其他的元素都有唯一的后继元素。 顺序表中的元素总数n(n ≥ 0)即为顺序表的长度，n = 0时，顺序表的长度为0，为空表。 功能实现 定义 #define SUC 1 // 定义SUC 作为状
顺序表的总结
m0_73268549的博客
01-15 225
顺序表
c 语言 数据结构 算法实现
12-05
"图的邻接表.c"和"图的邻接矩阵.c"分别展示了两种常见的图存储方式：邻接表节省空间，适合稀疏图；邻接矩阵适用于表示稠密图，直观且操作简便。图的常见算法如深度优先搜索（DFS）和广度优先搜索（BFS）可能会在这两...
数据结构答案
03-21
此外，还涉及了一些具体数据结构操作的细节，如顺序栈满的条件、链表后继结点的判断、树的结点数、深度、度、有向图的拓扑排序、完全二叉树的结点数、下三角矩阵的存储、散列表的冲突解决方法、简单选择排序和直接...
顺序表和链表 相关知识点总结
sakeww的博客
08-19 2147
顺序表和链表 【目录】 1.线性表 2.顺序表 3.链表 4.顺序表和链表的区别和联系 5.顺序表和链表的相关选择题 1.线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串… 延申：什么是数组？ 相同类型元素的一个有限集合，里面放的元素和数据，和线性表是一样的 数组和线性表的其中一个结构类似 线性表相当于在数组的基础之上绑定了一些 增删查改 等其他操作 数组只是一种存储数据的一种方式，没有其他
总结写顺序表与链表
yiqqYi的博客
11-23 168
语法 如何定义类： 属性/方法/构造方法（初始化属性） 顺序表： int[] array; int size; 链表： int val; ListNode next; 构造方法： 无参/有参 顺序表初始容量size = 0； 如何构造对象 new类（构造方法的实参） 例如： ListNode nHead = new ListNode(实参); 如何访问普通的属性 如何调用普通的方法 ...
数据结构：顺序表和链表学习小结
qq_67931344的博客
09-21 2487
数据结构，顺序表与链表学习小结。单链表的例题和双链表，循环链表之间的区别。
顺序表总结
weixin_43448286的博客
10-28 214
顺序表的操作 import java.util.Arrays; public class SeqList { //设置一个长度为10，有效元素个数为0的顺序表 private int[] data = new int[10]; //长度 private int size = 0; //有效元素个数 public void display(){ //打印顺序表 ...
顺序表和链表的总结
有没有兴趣和我一起去拯救地球啊
08-07 276
尾插和尾删 顺序表：O（1） 不带头节点的单链表：遍历链表，删除O(N) 如果将最后一个节点保存：O(1) 任意位置的插入与删除 顺序表O（N），因为涉及到数据的迁移 链表O（1） 顺序表支持随机访问，访问任意位置节点O(1) 链表需要遍历O(N) 底层的空间不同 顺序表底层是一段连续的空间 链表底层是不连续的 ...
数据结构小结——顺序表（指针版）
qq_34652485的博客
08-04 3474
上一篇介绍的是基于柔性数组存储数据的顺序表，我个人感觉它和我这篇要介绍的基于给指针开辟空间存数据的顺序表差不多，都是使用堆内存，并且能够对数据存储空间调整大小。
实验三 总结线性表（顺序表、单链表、双链表、静态链表、间接寻址）五种数据结构
x1432553805的博客
05-06 921
顺序表：顺序表是一段地址连续的存储单元依次存储线性表的数据元素，一般用一维数组实现；是一种适用于已知数据元素个数或数据元素个数变化不大的数据结构。该数据结构的存储结构为顺序存储，存取时为随机存取。因此按位查找的时间复杂度为O（1）。在未知的数据元素个数或数据元素变化过大时，使用顺序表则会造成大量的空间浪费。单链表：单链表是用一组任意的存储单元存放线性表的元素元素，这组存储单元可以连续也可以不连续，...
【无标题】顺序表的一些最基本操作
weixin_62528784的博客
09-18 245
数据结构入门1：顺序表的一些最基本的操作
顺序表和链表的优缺点
HanSion.Z
06-25 7251
顺序表 优点： 1.方法简单，基于数组，容易实现 2.不用为表示结点间的逻辑关系而增加额外的开销 3.顺序表可以按照元素下标随机访问 缺点： 1.在插入和删除时大约移动平均一半的元素，对比较大的顺序表操作时效率很低 2.需要预先分配足够大的空间，估计过大，导致空间浪费；估计过小，会造成溢出 链表 优点： 1.不用事先分配空间，用一个空间开辟...
头歌csdn顺序表链表作业
最新发布
10-31
在csdn的顺序表作业中，可能会涉及到实现顺序表的基本功能，如创建一个空表、插入元素到指定位置、删除指定位置上的元素以及获取指定位置上的元素等等。完成这些作业可以帮助学生更好地理解和掌握顺序表的实现原理和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值