精华内容
下载资源
问答
  • 初识Java语言——线性表(基础知识1——创建一个线性表) 在数据结构中,按逻辑将数据的结构分为线性表和非线性表,而线性表按照存储单元是否连续分为顺序表和链表。 一、顺序表 顺序表你可以看成一个数组,因为它的...

    初识Java语言——线性表(基础知识1——创建一个线性表)

    在数据结构中,按逻辑将数据的结构分为线性表和非线性表,而线性表按照存储单元是否连续分为顺序表和链表。
    一、顺序表
    顺序表你可以看成一个数组,因为它的存储单元是连续的,要访问它的元素,就需要知道首地址和偏移量,进而可以随机访问顺序表当中的值。下面来看一下如何创建一个顺序表吧。(后序补充顺表当中的算法)

    class ArraysList{
    private int usedSize;
    private int[]num;
    public ArraysList(){
    this.num=new int[5];
    }
    }
    public class Main{
    ArraysList arr=new ArraysList();//此时就算创建了一个存储长度为5的一个顺序表了
    }
    

    但是顺序表有个缺点就是当我执行删除或者插入操作时会带动大量的元素进行移动,还有就是如果顺序表扩容时,如果我们仅仅只需再放入一个元素时,那么多出来的存储空间就会 被浪费掉,所以就引申出了链表这个东西。
    二、链表
    链表和顺序表的性质完全相反(存储结构不连续,永远不会放满,不浪费空间,但是必能做到随机访问数据元素,一切都是在遍历整条链表的前提下进行操作的。下面来看一下如何创建一个单项链表吧。
    在这里插入图片描述
    在这里插入图片描述

    class Node{
    public int data;
    public Node next;
    public Node(){
    }
    public Node(int data){
    this.data=data;
    }
    }
    //暂时以头插法创建一个单链表,后序会补充尾插和其他功能
    public class LinkList{
    Node head;
    public creatLink(int data){
    Node node=new Node(data);
    node.next=this.head;
    this.head=node;
    }
    }
    
    public class Main{
    public static void main(String[]args){
    LinkList link=new LinkList();
    link.creatLink(8);
    link.creatLink(7);
    link.creatLink(6);
    }//这样就创建了一个单向链表,6 7 8
    }
    

    以上就是顺序表和单向链表的创建,后序会补充顺序表和链表的一些算法,一起加油!!!!!

    展开全文
  • 来一个最简单的单链表来举例吧 创建链表就得有链表节点。节点里面包含节点数据即值域,另外还有...为了方便后续的程序操作,我们将这个语句用函数封装起来,即创建一个新函数,让头节点指向空。既然是指向,那么头...

    来一个最简单的单链表来举例吧

    创建链表就得有链表节点。节点里面包含节点数据即值域,另外还有指针域,这里就得定义一个结构体。

    定义结构体

    为了方便下面代码方便写,将struct node定义成Node,struct node *定义为Link。
    重新定义

    我们操作的是无头节点的空链表,所以要创建一个空链表。为了方便后续的程序操作,我们将这个语句用函数封装起来,即创建一个新函数,让头节点指向空。既然是指向,那么头节点一定是一个指针,这个函数需要被主函数调用,而且需要返回主函数的类型不是一个数值,而是一个一级指针,所以这里必须得定义一个二级指针。
    创建空链表

    函数里定义的head是一个二级指针,Link相当于struct node *。在函数里,head是一个二级指针,对一个二级指针取 * 号,即取二级指针的内容,二级指针里的内容就是一级指针的地址。

    我们这里采用的是比较简单的头插法来实现。这里的函数定义的head也是一个二级指针,也是需要返回一个地址,而新节点new_node就仅仅返回一个数值就可以了,所以定义的是一级指针。
    头插法
    头节点为空,让新节点的指针域new_node->next指向头指针 * head,再让 * head指向new_node,这样新节点就插在了头指针的前面。

    插入链表后,要打印这个链表,为了后续操作,我们也用一个函数对其封装。
    打印函数
    这里的head是一个一级指针,因为这时不需要带回一个地址。值得注意的是,头指针是不可以动的,只能重新定义一个指针变量来指向头指针。

    前期准备工作到这里就算是做好了,后续只要写出主函数就可以了。

    主函数

    值得注意的是,主函数定义的head是一级指针,后面调用函数时需要用到二级指针,这是就需要对一级指针取地址,才能和二级指针的数据类型对应,否则会出现段错误。在定义一个指针时,最好初始化指向空,防止野指针的危害。至此,一个链表就建立好了。

    刚刚接触链表的内容,难以理解,感觉和之前的C语言知识出现了断层,随着后续的深入学习,这些内容就变得简单了。所以万事开头难,只要不断学习,坚持不懈,之前遇到的问题都不再是问题了。

    展开全文
  • 将这两个线性表/数组相加得到一个的新的线性表 题目 输入数据创建两个非空线性表/数组来代表两个正整数,线性表/数组中的每个结点只存储一位数字。实现一种算法,将这两个线性表/数组相加得到一个的新的线性表,并将...

    将这两个线性表/数组相加得到一个的新的线性表

    题目

    输入数据创建两个非空线性表/数组来代表两个正整数,线性表/数组中的每个结点只存储一位数字。实现一种算法,将这两个线性表/数组相加得到一个的新的线性表,并将该线性表/数组输出。

    思路

    1. 创建两个数组;
    2. 对应位数相加,循环次数为max(x,y);
    3. 设置四个数组,a数组,b数组,t数组(表示进位),sum数组;
    4. 最后将相加得到的数组倒序输出。

    在这里插入图片描述

    代码

    #include <stdio.h>
    #define LIST_INIT_SIZE 100
    
    int main() {
        int a[LIST_INIT_SIZE] = { 0 }, b[LIST_INIT_SIZE] = { 0 }, sum[LIST_INIT_SIZE] = { 0 }, t[LIST_INIT_SIZE] = { 0 };
        int i,k;
    
        printf("输入线性表1的长度:");
        int x;
        scanf_s("%d", &x);
        for (i = x - 1; i >= 0; i--)
            scanf_s("%d", &a[i]);
    
        printf("输入线性表2的长度:");
        int y;
        scanf_s("%d", &y);
        for (i = y- 1; i >= 0; i--)
            scanf_s("%d", &b[i]);
      
        if (x <y)
        {
            k = x;
            x = y;
            y = k;
        }
    
        for (i = 0; i <x; i++)
        {
            sum[i] = a[i] + b[i] + t[i];
            t[i + 1] = sum[i] / 10;
            sum[i] = sum[i] % 10;
        }
        if (t[x] > 0)
        {
            sum[x] = 1;
            for (i = x; i >= 0; i--)
                printf("%d ", sum[i]);
        }
        else
            for (i =x - 1; i >= 0; i--)
                printf("%d ", sum[i]);
        return 0;
    }
    
    
    
    
    
    
    展开全文
  • 一、SeqList.h  #ifndef _SEQLIST_H_ #define _SEQLIST_H_ typedef void SeqList; typedef void SeqListNode; SeqList* SeqList_Create(int capacity); //创建一个线性表 void S
    一、SeqList.h


     #ifndef  _SEQLIST_H_
    #define  _SEQLIST_H_


    typedef    void  SeqList;
    typedef   void  SeqListNode;


    SeqList*  SeqList_Create(int  capacity);           //创建一个线性表


    void  SeqList_Destory(SeqList*   list);                //销毁一个线性表 
    void  SeqList_Clear(SeqList*   list);                     //清空一个线性表
    int  SeqList_Length(SeqList*   list);                     //获取一个线性表的长度
    int  SeqList_Capacity(SeqList*   list);                 //获取线性表的容量


    int   SeqList_Insert(SeqList*  list,SeqListNode*   node,int  pos);        //在线性表插入一个元素
    SeqListNode*   SeqList_Get(SeqList*  list,int   pos);                             //获取线性表某个位置的元素
    SeqListNode*   SeqList_Delete(SeqList*  list,int  pos);                       //删除线性表的某个元素
    #endif




    二、SeqList.c


    #include<stdio.h>
    #include<malloc.h>
    #include<SeqList.h>


    typedef  unsigned int   TSeqListNode;
    typedef    struct   _tag_SeqList
    {
        int  capacity;    //线性表的最大容量
        int   length;      //当前线性表的长度
        TSeqListNode*   node;            //存储空间的起始位置
    }TSeqList;




    SeqList*      SeqList_Create(int   capacity )
    {
          TSeqList*   ret=NULL;          //地址初始化为NULL
          if(capacity>=0)                       //最大容量大于0时,进入
           {
                   ret=(TSeqList*)malloc(sizeof(TSeqList)+sizeof(TSeqListNode)*capacity)          //分配内存空间地址
           }
            if(ret! !=NULL)                 //分配到地址时进入
            {
                   ret->capacity=capacity;             //初始化线性表的最大容量
                   ret->length=0;                            //初始化线性当前的长度
                   ret->node=(TSeqListNode*)(ret+1);    //初始化线性表的地址
              }
               return    ret;
    }


    void  SeqList_Destroy(SeqList*  list)
    {
       free(list);   //释放链表存储的空间
    }


    void  SeqList_Clear(SeqList*  list)
    {
      TSeqList*    sList=(SeqList*)list;     //将线性表强制转化为SeqList类型的
       if(sList!=NULL)                                  //判断线性表是否为空
        {
               sList->length=0;                        //将当前的长度置0,清空链表中的所有元素
         }
    }


    int  SeqList_Length(SeqList*  list)          //获取线性表当前的长度
    {
         TSeqList*  sList=(TSeqList*)list;       //将线性表强制转化为SeqList类型的
        if(sList!=NULL)                                          //判断线性表是否为空
         { 
                ret=sList->length;                             //将链表当前的长度的值赋给ret
          }
            return    ret;                                            //返回ret的值
    }


    int  SeqList_Capacity(SeqList*  list)         //获取线性表当前容量的最大值
    {
          TSeqList*  sList=(TSeqList*)list;       //将线性表强制转化为SeqList类型的
           ret=-1;                                                    //ret置为-1,当线性表为null时,返回错误提示
           if(sList!=NULL)                                    //判断链表是否为null
            { 
                     ret=sList->capacity;                 //将线性表的最大容量值赋给ret
             }
                 return  ret;
    }


    int   SeqList_Insert(SeqList*  list,SeqListNode*  node,int  pos)    //在某个位置插入某个元素
    {
                  TSeqList*  sList=(TSeqList*)list;                 //将线性表强制转化为SeqList类型的            
                   int  ret =(sList!=NULL);                                //判断线性表是否合法(线性表不能为null)
                    int  i=0;
                   ret=ret&&(sList->length+1<=sList->capacity);   //判断插入位置是否合法(插入的位置应该从0开始,但不能大于最大的容量值)
                   ret=ret&&(0<=pos);
     
                    if(ret)
                     {
                               if(pos>=sList->length)
                                {
                                        pos=sList->length;         //如果插入的位置大于线性表当前的长度,则将视插入的位置为最后一位
                                }
                      for(i=sList->length;i>pos;i--)          //从最后一位开始,到pos的后一位进行循环依次向后移一位
                         {
                              sList->node[i]=sList->node[i-1];    //依次向后移一位
                         }
                       sList->node[i]=(TSeqListNode)node;   //将新元素插入表中
                        sList->length++;                                      //长度加一
                      }
                return   ret;


    }


    SeqListNode* SeqList_Get(SeqList* list, int pos) //   获取线性表某个位置的元素
    {
        TSeqList* sList = (TSeqList*)list;      
        SeqListNode* ret = NULL;
        
        if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )   //判断线性表的是否合法,以及获取的位置是否合法
        {
            ret = (SeqListNode*)(sList->node[pos]);                                 //将获取的元素赋值给ret
        }
        
        return ret;
    }




    SeqListNode* SeqList_Delete(SeqList* list, int pos) //删除线性表某个位置的元素
    {
        TSeqList* sList = (TSeqList*)list;
        SeqListNode* ret = SeqList_Get(list, pos);    //将要删除的元素获取出来
        int i = 0;
        
        if( ret != NULL )
        {
            for(i=pos+1; i<sList->length; i++)      
            {
                sList->node[i-1] = sList->node[i];   //将pos后面一位到最后一位依次向前移一个位置
            }
            
            sList->length--;   //长度减一
        }
        
        return ret;

    }



    第一二部分创建了可复用的顺序线性表,一个完整的顺序线性表表达成功;

    接着我们进行第三步,通过main函数进行编写,也可称为线性表的操作;


    三、main.c

    #include <stdio.h>
    #include <stdlib.h>
    #include "SeqList.h"


    /* run this program using the console pauser or add your own getch, system("pause") or input loop */


    int main(int argc, char *argv[]) 
    {
        SeqList* list = SeqList_Create(5);
        
        int i = 0;
        int j = 1;
        int k = 2;
        int x = 3;
        int y = 4;
        int z = 5;
        int index = 0;
        
        SeqList_Insert(list, &i, 0);
        SeqList_Insert(list, &j, 0);
        SeqList_Insert(list, &k, 0);
        SeqList_Insert(list, &x, 0);
        SeqList_Insert(list, &y, 0);
        SeqList_Insert(list, &z, 0);
        
        for(index=0; index<SeqList_Length(list); index++)
        {
            int* p = (int*)SeqList_Get(list, index);
            
            printf("%d\n", *p);
        }
        
        printf("\n");
        
        while( SeqList_Length(list) > 0 )
        {
            int* p = (int*)SeqList_Delete(list, 0);
            
            printf("%d\n", *p);
        }
        
        SeqList_Destroy(list);
        
        return 0;
    }

    执行结果:







    展开全文
  • 北京邮电大学软件学院 2019-2020 学年第 1 学期实验报告 课程名称 算法与数据结构课程设计 实验名称 线性表 实验完成人 实验目的 一 实验内容 1城市列表 [ 问题描述 ] 将若干城市的信息存入一个带头结点的单链表 ...
  • 上课啦THE POWERPOINT TEMPALTE模块2线性表54123顺序存储结构逻辑结构实例引入应用举例链式存储结构学习目的与要求重点:掌握顺序表和链表的逻辑描述和存储实现难点:顺序表...且具有如下特点:(1)存在唯一的一个被...
  • 超过数组的容量时,创建一个新的更大的数组,并且将当前数组中的元素复制到新建的数组中。另一种方法是用链表结构实现。链表由节点组成,每个结点都是动态生成的,用来存储一个元素。所有的结点连接成一个线性表。...
  • . 范文 实验一 线性表应用 一. 实验目的 掌握用Turbo C或... 实验学时 课内实验学时2学时 课外实验学时4学时 三备选实验题目 单链表基本操作练习实验类型验证型 1问题描述在主程序中设计一个简单的菜单分别调用相应的函
  • 创建链式线性表

    2016-10-05 15:01:27
    public class LinkList { ... //定义一个内部类Node,Node实例代表链表的节点  private class Node{  //保存节点的数据  private T data;  //指向下个节点的引用  private Node next;
  • 线性表

    2019-10-08 21:18:24
    第二章线性表 抽象数据类型的定义 InitList 线性表的初始化 ...CreateList 创建一个线性表 Length 求出线性表的长度(所含的元素的个数) Get 输入下标求下标所指的元素 Insert 插入操作 Dela...
  • 线性表(List):由零个或多个数据元素组成的有限序列。...创建一个接口,IList,接口中存储常用的方法。 创建一个类,用来实现顺序表,继承当前接口。 实现接口中的方法 创建一个数组,用来存储数据 ...
  • 上一节我们实现并优化了动态数组的创建和基础功能的实现,这节进行链表的学习。1.以缺陷提出新的解决思路1.动态数组有个明细的缺点,可能会造成内存空间的大量浪费而链表可以做到用多少就申请多少。... 一个节点...
  • “一切尽意,百世从欢,在爱与失落中坚持。”本小节知识点一览one.Python中变量标识的本质...首先我们要清楚一个小概念。a=10,a是内存的别名?a保存的是数值?no.都不是。a的这一块空间指向10,a中保存的是10的内存...
  • 在数据结构>中的顺序线性表结构是用数组存储数据的,如果完全是自己编写代码不使用数组该如何创建线性表呢?
  • /*声明一个带头指针的单链表 * * */ package DataStructureTestSinglyLinkedList; import DataStructureTest.LList; public class SinglyLinkedList implements LList { public Node head; //无参构造...
  • 学习目标与重点 理解线性表的...线性表由一组具有相同属性的数据元素构成 数据元素的含义广泛在不同的具体情况下可以有不同的含义 例如英文字母表ABCZ是一个长度为26的线性表其中的每一个字母就是一个数据元素 再如某公
  • 第 第 PAGE 1 页 共 NUMPAGES 11 页 学院计算机与控制工程学院 专业...2实验内容 建立某班学生的通讯录要求用链表存储 具体功能包括 1可以实现插入一个同学的通讯录记录 2能够删除某位同学的通讯录 3对通讯录打印输出
  • //定义一个链表指针 //生成菜单 char sel=' '; while(sel!='0') { printf("------线性表(链式存储结构)演示系统-------\n"); printf(" 版本:1.0 作者:xxx 日期:xxxx-xx-xx\n"); printf("-----------...
  • 注意物理序号和逻辑序号的不同define MaxSize 50typedef struct ...构造一个空的线性表L 分配空间,并将length成员设置为0 算法 void InitList(SqList *&L) //指针的引用 { L=(SqList *)mall

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,530
精华内容 612
关键字:

创建一个线性表