数据结构——线性表

最新推荐文章于 2021-06-06 18:30:11 发布
最新推荐文章于 2021-06-06 18:30:11 发布
阅读量178 收藏
点赞数
文章标签： 数据结构与算法 java
原文链接：http://www.cnblogs.com/noneplus/p/11330317.html
版权

什么是线性表？

线性表是具有相同类型的n个元素（n>=0）的有限序列。

1.顺序表

  • 线性表采用顺序存储方式
  • 其逻辑顺序和物理顺序相同

问题：需要连续存储空间，插入等操作需要移动大量元素，时间复杂度高。

2.单链表

线性表采用链式存储方式称为单链表。

链式存储是采用节点来进行存储的。

每个节点包括data域和next域。（不一定连续存储）
20190808125703566

  • 单链表反转
  • 单链表的增删改查
  • 约瑟夫环

单链表反转

20190808115959474

20190808115940644

单链表的增删改查

import java.util.Stack;

//定义单个节点
class Node
{

    public String data;  //定义数据节点

    public Node next;   //定义指向下一个节点的指针

    public Node() {
    }

    public Node(String data) {
        this.data = data;
    }

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }

    @Override
    public String toString() {
        return "Note{" +
                "data='" + data + '\'' +
                '}';
    }
}


public class Operation
{
    //初始化头结点
    private static Node head = new Node();


    private static Node reverseHead = new Node();


    //插入节点（头插）
    public void insertToHead(Node node)
    {
        Node temp = head;

        //头插法需要设置head.next和node.next的值。其中nodeNext指向headNext，而headNext指向node。
        //由于是赋值的关系，二者顺序不可颠倒
        node.next=temp.next;
        temp.next=node;
    }

    //插入节点（尾插）
    public void insertToLast(Node node)
    {
        Node temp = head;

        while (true)
        {
            if(temp.next==null)
            {break;}
            temp=temp.next;
        }
        temp.next=node;
    }

    //插入节点（指定位置k之后）

    public void insertToK(Node node,int k)
    {
        Node temp = head;
        for(int i=0;i<k;i++)
        {
            temp=temp.next;
        }
        node.next=temp.next;
        temp.next=node;
    }


    //删除第m个节点
    public void deleteM(int m)
    {
        Node temp = head;
        for(int i=0;i<m-1;i++)
        {
            temp=temp.next;
        }
        temp.next=temp.next.next;
    }


    //修改第n个节点（n）
    public void updateN(int n)
    {
        Node temp = head;
        for(int i=0;i<n;i++)
        {
            temp=temp.next;
        }
        temp.data="up";
    }


    //递归反转

    public Node reverseLinkedList(Node node) {
        if (node == null || node.next == null) {
            return node;
        } else {
            Node headNode = reverseLinkedList(node.next);
            node.next.next = node;
            node.next = null;
            return headNode;
        }
    }

    //遍历反转
    public Node reserveByFor(Node head)
    {
        Node cur = head.next;
        Node next = null;
        Node Rhead = new Node();


        while(true)
        {
            if(cur==null)
            {
                break;
            }
            else
            {
                next=cur.next;
                cur.next=Rhead.next;
                Rhead.next=cur;

                cur=next;
            }
        }

        head.next=Rhead.next;

        return head;
    }

    //print(last to first)
    public void printLtoF(Node head)
    {
        Stack<Node>stack = new Stack<>();
        Node cur = head.next;
        while (cur!=null)
        {
            stack.push(cur);
            cur=cur.next;
        }
        while (stack.size()>0)
        {
            System.out.println(stack.pop());
        }
    }




    public static void main(String[] args)
    {
        Operation operation = new Operation();

        operation.insertToHead(new Node("A"));
        operation.insertToHead(new Node("B"));
        operation.insertToHead(new Node("C"));

        operation.insertToLast(new Node("1"));
        operation.insertToLast(new Node("2"));
        operation.insertToLast(new Node("3"));

//        operation.insertToK(new Node("k"),2);

//        operation.deleteM(3);

//        operation.updateN(1);


        Node temp =head;
        //遍历链表
        while(true)
        {
            if(temp.next==null)
            {break;}
            else
            {
                temp=temp.next;
                System.out.println(temp.toString());

            }
        }



        System.out.println("//1.求单链表中有效节点个数.");

        temp=head;
        int count=0;
        while(true)
        {
            if(temp.next==null)
            {break;}
            else
            {
                temp=temp.next;
                count++;
            }
        }
        System.out.println(count);


        System.out.println("//2.查找单链表中倒数第K=3个节点");

        temp=head;

        //获取链表总长
        int length=0;

        while (true)
        {
            if(temp.next==null)
            {break;}
            else
            {
                temp=temp.next;
                length++;
            }
        }


        temp=head;
        for(int i=0;i<length-2;i++)
        {
            temp=temp.next;
        }
        System.out.println(temp.data);


        System.out.println("3.实现单链表的反转");

//      temp=operation.reverseLinkedList(head);


        temp = operation.reserveByFor(head);

        //遍历链表
        while(true)
        {
            if(temp.next==null)
            {break;}
            else
            {
                temp=temp.next;
                System.out.println(temp.toString());
            }
        }


        System.out.println("4.从尾到头打印单链表");

        temp = head;
        operation.printLtoF(temp);






    }
}

2019080812432676

单向环形链表输出约瑟夫环

2019080816052262

//定义单个节点
class Node
{

    public String data;  //定义数据节点

    public Node next;   //定义指向下一个节点的指针


    public Node() {
    }

    public Node(String data) {
        this.data = data;
    }


    @Override
    public String toString() {
        return "Note{" +
                "data='" + data + '\'' +
                '}';
    }


}


public class Operation
{
    //初始化头结点
    private static Node head = new Node();

    //尾插法
    public void add(Node node)
    {
        Node temp = head;

        while (true)
        {
            if(temp.next==null)
            {break;}
            temp=temp.next;
        }
        temp.next=node;
    }

    //创建单向环形链表
    public Node createCircle(int n)
    {
        //创建单链表
        for(int i=0;i<n;i++)
        {
            add(new Node("No:"+(i+1)));
        }

        //遍历链表
        Node temp = head;
        while(temp.next!=null)
        {
            temp=temp.next;
            System.out.println(temp);
        }

        Node last = temp;
        temp=head;
        last.next=head.next;   //连接首尾

        System.out.println("last为最后一个数5：");
        System.out.println(last);


        System.out.println("循环两遍单向环形链表：");
        int count=2*n;
        while(last!=null)
        {
            if(count==0)
            {
                break;
            }
            System.out.println(last.next);
            last=last.next;
            count--;
        }
        System.out.println("last="+last.data);
        return last;
    }

    public static void JosephusProblem(int n, int k, int m, Node last)
    {
        //定位到第k个节点,输出k+1个节点并删除，并让last定位到第k个节点

        Node temp = last;
        for(int i=0;i<k;i++)  //定位到第k个节点
        {
            temp=temp.next;
        }
        System.out.println("第一次输出"+temp.next.data);//输出

        temp.next=temp.next.next; //删除第K+1个节点
        last=temp.next;



        for(int i=0;i<n-1;i++)
        {
            temp=last;

            System.out.println("第二次输出"+temp.next.data);

            temp.next=temp.next.next;
            last=temp.next;
        }


    }
    public static void main(String[] args)
    {
        Operation operation = new Operation();

        //定义人数
        int n=5;
        Node last = operation.createCircle(n);


        //定义从第几个节点开始数
        int k=1;
        //定义数的次数
        int m=2;


        System.out.println("输出约瑟夫环：");
        JosephusProblem(n,k,m,last);


    }
}

20190808160504403

3.双向链表

双向链表与单向链表的区别

单向列表只能从前往后查找，而双向链表可以向前向后查找。
单向链表删除节点需要依靠辅助节点，而双向链表可以实现自我删除。

双向链表与单项列表的实际区别在于多了一个pre域。

20190808125632756

双向链表增删改查

import java.util.Stack;

//定义单个节点
class Node
{

    public String data;  //定义数据节点

    public Node next;   //定义指向下一个节点的指针

    public Node pre;    //定义指向上一个节点的指针

    public Node() {
    }

    public Node(String data) {
        this.data = data;
    }


    @Override
    public String toString() {
        return "Note{" +
                "data='" + data + '\'' +
                '}';
    }
}


public class Operation
{
    //初始化头结点
    private static Node head = new Node();


    //插入节点（尾插法）
    public void addNode(Node node)
    {
        Node temp = head;
        while(true)
        {
            if(temp.next==null)
            {
                break;
            }
            temp=temp.next;
        }
        temp.next=node;
        node.pre=temp;
    }

    //插入节点(头插法)
    public void addNodeToHead(Node node)
    {
        Node temp = head;


        node.pre=temp;
        node.next=temp.next;
        temp.next.pre=node;
        temp.next=node;
    }

    //插入到第k个节点后
    public void addToK(Node node,int k)
    {
        Node temp = head;
        for(int i=0;i<k;i++)
        {
            temp=temp.next;
        }
        //先建立单链表联系
        node.next=temp.next;
        temp.next=node;
        //建立pre指向
        node.pre=temp;
        node.next.pre=node;
    }

    //删除第n个结点
    public void deleteNode(int n)
    {
        Node temp = head;
        for(int i=0;i<n;i++)
        {
            temp=temp.next;
        }
        temp.next.pre=temp.pre;
        temp.pre.next=temp.next;
    }

    public void list()
    {
        //遍历链表
        Node temp = head;
        while(temp.next!=null)
        {
            temp=temp.next;
            System.out.println(temp.toString());
        }
        System.out.println("=============");
    }


    //修改第m个结点
    public void update(int m)
    {
        Node temp = head;
        for(int i=0;i<m;i++)
        {
            temp=temp.next;
        }
        temp.data="up";
    }

    public static void main(String[] args)
    {
        Operation operation = new Operation();

        operation.addNode(new Node("A"));
        operation.addNode(new Node("B"));
        operation.addNode(new Node("C"));
        operation.addNode(new Node("D"));
        operation.addNodeToHead(new Node("head1"));
        operation.addNodeToHead(new Node("head2"));
        operation.addNodeToHead(new Node("head3"));

        //遍历链表
        operation.list();

        System.out.println("删除第n个节点");
        operation.deleteNode(3);

        //遍历链表
        operation.list();

        System.out.println("修改第m个节点");

        operation.update(3);

        operation.list();

        System.out.println("插入到第k个节点后");
        operation.addToK(new Node("k" ),3);

        operation.list();
    }
}

转载于:https://www.cnblogs.com/noneplus/p/11330317.html

WY2718
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
线性表的定义和基本操作
crazy的博客
07-23 1万+
------线性表的定义       线性表是具有相同数据类型的 n  （n&gt;= 0）个数据元素的有限序列。其中 n 为 表长，当 n = 0  时，该线性表是一个空表。若用 L 命名线性表，则其一般表示如下：       L = ( a1 , a2 , a3 , ... , a(i) , a( i + 1) , ... , a(n)  )     其中，a1 是唯一的 “ 第一个 ...
数据结构第2章线性表习题（一）——选择题
＃两个西柚
07-21 1万+
第2章 线性表 一 选择题 1．下述哪一条是顺序存储结构的优点？（ A ） A．存储密度大 B．插入运算方便 C．删除运算方便 D．可方便地用于各种逻辑结构的存储表示 2．下面关于线性表的叙述中，错误的是哪一个？（B ） A．线性表采用顺序存储，必须占用一片连续的存储单元。 B．线性表采用顺序存储，便于进行插入和删除操作。 C．线性表采用链接存储，不必占用一片连续的存储单元。 D．线性表采用链接存储，便于插入和删除操作。 3．线性表是具有n个（ C ）的有限序列...
02、线性表基础考点
weixin_30362083的博客
08-23 997
线性表 一、线性表的顺序存储 　　1、线性表采用顺序存储，必须占用一片连续的存储单元； 　　2、线性表顺序存储结构是一种随机存取的存储结构； 　　3、顺序表在查找指定序号的元素、读取元素和在末尾插入元素最节省时间； 　　4、顺序表中，在任何一个位置插入元素的概率相同，则插入一个元素所需移动的元素平均数——（n+1）/2； 　　5、顺序表中，在任何一个位置删除元素的概率相同，则插入一个元...
线性表 详讲及使用
Java我们右转见
09-21 393
在这里我要进行一下说明，在我们学习数据结构与算法之后，我们编程思维就不能仅仅局限于能够达成目标，而是在达成目标的基础上，代码的逻辑要相对直观清晰，时间复杂度和空间复杂度要相对低一些，这样，我们编写的代码才能算作是“合格”的代码 所谓的线性表，是一种 逻辑线性结构，即，一对一结构。 至于线性表的实现，可以用物理线性结构（即数组）来实现，也可以用物理非线性结构（即链表）实现。 至于数组的方法，我们就不...
数据结构习题——第二章 线性表
热门推荐
Colin丶
09-08 2万+
第二章 线性表 一、选择题 1．下述哪一条是顺序存储结构的优点？（ ） A．存储密度大 B．插入运算方便 C．删除运算方便 D．可方便地用于各种逻辑结构的存储表示 2．下面关于线性表的叙述中，错误的是哪一个？（ ） A．线性表采用顺序存储，必须占用一片连续的存储单元。 B．线性表采用顺序存储，便于进行插入和删除操作。 C．线性表采用链接存储，不必占用一片连续的存储单元。 D．线性表
数据结构——线性表的实现.zip
09-18
本资料包“数据结构——线性表的实现.zip”着重介绍了线性表的两种常见实现方式：链表和数组。 1. 链表实现： 链表是一种物理存储单元非连续、非顺序的存储结构，它通过节点间的指针链接来表示元素之间的逻辑关系...
数据结构——线性表分享.pdf
01-01
数据结构——线性表分享 一、顺序存储结构 在数据结构中，顺序存储结构是一种常用的存储方式，它将线性表的每个元素存储在一块连续的存储空间中。这种存储方式的优点是可以快速访问任意一个元素，但缺点是插入或...
数据结构——线性表(选择题).docx
07-11
线性表是数据结构中的一种基础类型，它是由n（n>=0）个相同类型元素构成的有限序列。在这个序列中，每个元素都有一个直接前驱（除了第一个元素）和一个直接后继（除了最后一个元素），并且这个序列可以为空。线性表...
数据结构——线性表类模板
12-19
线性表是计算机科学中一种基础且重要的数据结构，它是由n（n≥0）个相同类型元素构成的有限序列。在C++编程语言中，类模板被广泛用于实现抽象数据类型，它允许我们创建通用的数据结构，适用于多种数据类型。本主题将...
算法与数据结构二(数据结构——线性表).doc
10-10
算法与数据结构二(数据结构——线性表).doc
数据结构实验——线性表子系统
最新发布
07-31
线性表是数据结构中最基础且重要的概念之一，它是由n(n≥0)个相同类型元素组成的有限序列。在这个实验中，我们主要关注线性表的链式存储结构，特别是字符型的单链表。实验的目标是理解线性表的特点，掌握顺序存储和...
数据结构练习题——线性表（二）
煮酒blog
06-06 7320
一、判断正误 （ F ）1. 链表的每个结点中都恰好包含一个指针。 （ F ）2. 链表的物理存储结构具有同链表一样的顺序。 （ F ）3. 链表的删除算法很简单，因为当删除链中某个结点后，计算机会自动将后续各个单元向前移动。 （ F ）4. 线性表的每个结点只能是一个简单类型，而链表的每个结点可以是一个复杂类型。 （ F ）5. 顺序表结构适宜于进行顺序存取，而链表适宜于进行随机存取。 二、单项选择题 （ A ）1. 链式存储的存储结构所占存储空间： 分两...
数据结构线性表题库
闲狗的博客
08-01 1万+
网络课课后题 1、下面关于线性表的叙述中，正确的是 A、线性表采用顺序存储，必须占用一片连续的存储单元。 B、线性表采用顺序存储，便于进行插入和删除操作。 C、线性表采用链接存储，不必占用一片连续的存储单元。 D、线性表采用链接存储，便于插入和删除操作。 解析 顺序存储是按索引值从小到大存放在一片相邻的连续区域 采用链接存储，便于插入和删除操作，如果采用顺序存储，插入和删除时需要...
利用线性表进行UPDATE操作
eastlift的专栏
05-12 2313
public void updateChannel(Channel channel) throws Exception ...{        //构造一线性表,然后将数据库字段的名称逐一加入该线性表        List colums = new ArrayList() ;        colums.add("channel_name") ;        colums.add("cha
线性表进行UPDATE操作
eastlift的专栏
10-17 1082
上次写过一个，当时感觉还可以，现在看看也蛮不爽的。刚刚用到JDBC写DAO时想到这样写，感觉还可以，不知大伙认为如何呢。。。传一个对象过来进行更新操作，对旬具体内容不管，只要用标识列就OK了。。。，动态构造Update语句 public void updateArard(Award award) throws SQLException ...{        String te
数据结构实验报告——线性表、二叉树、图的实现
这篇文档是吕鹏泽同学的一份数据结构实验报告，主要探讨了基于不同存储结构的线性表、二叉树以及图的实现。以下是各部分的详细知识点： 1. 基于顺序存储结构的线性表实现 - 问题描述：使用动态分配的顺序表来实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值