精华内容
下载资源
问答
  • 2021-05-20 17:53:06

    1.第一步定义线性表结构

    typedef struct {

    ElementType data[MaxSize];

    int length;

    }Lineartable;

    2.第二步线性表初始化

    //初始化线性表

    Lineartable* INITAL(){

    Lineartable *lineartable;

    lineartable = (Lineartable *)malloc(sizeof(Lineartable));

    lineartable->length=0;

    return lineartable;

    };

    3 按照顺序插入生成线性表

    void INSERT(ElementType x,int i,Lineartable *lineartable){

    if(i<0||i>lineartable->length){

    //

    printf("插入位置不合理");

    return ;

    }else{

    for(int j=lineartable->length;j>=i-1;j--){

    lineartable->data[j+1]=lineartable->data[j];

    }

    lineartable->data[i-1]=x;

    lineartable->length++;

    return ;

    }

    }

    4查找元素所在顺序表中位置

    int LOCATE(Lineartable *lineartable,int item){

    int n= lineartable->length;

    for(int i=0;idata[i]==item){

    return i+1;//查找成功,返回所在表中位置

    }

    }

    return -1;//查找失败,返回-1

    };

    5插入元素,第i个位置上插入item

    int INSERTITEM(Lineartable *lineartable,int i,int item){

    if(lineartable->length ==MaxSize|| i<1||i> (lineartable->length+1)){

    //测试空间是否满了

    return -1;//插入失败

    }else{

    for(int j= (lineartable->length -1);j>=i-1;j--){

    lineartable->data[j+1]=lineartable->data[j];//元素依次后移一个位置

    }

    lineartable->data[i-1]=item;//将item插入表的第i个位置

    lineartable->length ++;//线性表长度加1

    return 1;//插入成功

    }

    };

    6删除元素,删除第i个位置的元素

    int DELETE(Lineartable *lineartable,int i){

    if(i<1||i>(lineartable->length)){//测试表空和位置合适与否

    return -1;//删除失败

    }

    for(int j=i;jlength);j++){

    lineartable->data[j-1]=lineartable->data[j];//元素依次前移一个位置

    }

    (lineartable->length)--;//线性表长度减1

    return 1;//删除成功

    }

    7插入元素到有序线性表中

    void INSERTSORT(Lineartable *lineartable,ElementType item){

    int i,j;

    int n=lineartable->length;

    if(item >= lineartable->data[n-1]){

    //特殊情况,插入表尾部

    lineartable->data[n]=item;

    }else{

    i=0;

    while(item >= lineartable->data[i]){

    //寻找插入位置

    i++;

    }

    for(j=n-1;j>=i;j--){//将item插入表中

    lineartable->data[j+1]=lineartable->data[j];

    }

    lineartable->data[i]=item;

    lineartable->length ++;

    }

    }

    8显示线性表中的元素

    void print(Lineartable *lineartable){

    for(int i=0;i< (lineartable->length);i++){

    printf("%d\t",lineartable->data[i]);

    }

    }

    9主函数

    Lineartable* INITAL();

    void INSERT(ElementType x,int i,Lineartable *lineartable);

    int LOCATE(Lineartable *lineartable,int item);

    int INSERTITEM(Lineartable *lineartable,int i,int item);

    void print(Lineartable *lineartable);

    int DELETE(Lineartable *lineartable,int i);

    void INSERTSORT(Lineartable *lineartable,ElementType item);

    int main()

    {

    ElementType A[]={1,2,3};

    //定义一个线性表

    Lineartable *lineartable;

    //初始化一个线性表

    lineartable = INITAL();

    //插入法插入元素到线性表中

    for(int i=0;i<10;i++){

    INSERT(i,i,lineartable);

    }

    //查找元素所在线性表位置

    int result = LOCATE(lineartable,2);

    printf("元素2所在位置为:%d\n",result);

    //线性表中指定位置插入元素

    printf("在第3个位置上插入元素12后元素显示如下\n:");

    INSERTITEM(lineartable,3,12);

    print(lineartable);

    //删除指定位置线性表元素

    printf("删除第3个位置元素后显示如下\n");

    DELETE(lineartable,3);

    print(lineartable);

    //将新数据插入到有序的线性表中

    printf("将新数据7插入到有序的顺序表中,并输出元素\n");

    INSERTSORT(lineartable,7);

    print(lineartable);

    };

    更多相关内容
  • 线性表的创建,实现插入,删除,查询和初始化创建功能 ——以c语线性表的创建,实现插入,删除,查询和初始化创建功能 ——以c语言为例#include #include //morall free函数#include #define elemType int#define ...

    线性表的创建,实现插入,删除,查询和初始化创建功能 ——以c语

    线性表的创建,实现插入,删除,查询和初始化创建功能 ——以c语言为例

    #include

    #include //morall free函数

    #include

    #define elemType int

    #define LIST_INIT_SIZE 10

    using namespace std;

    struct sqlist {

    elemType* elem;//数组

    int size= LIST_INIT_SIZE;//容量

    int length;//长度

    };

    //初始化

    void initsqlist(sqlist& list) {

    list.elem = new elemType[LIST_INIT_SIZE];

    //上下两句语句等价

    //list.elem=(int*) malloc(5*sizeof(int));

    list.size = LIST_INIT_SIZE;

    list.length = 0;

    //初始化一个数组{1,2,3,4,5}

    for (int i = 0; i < 5; i++) {

    list.elem[i] = i + 1;

    list.length++;

    }

    }

    //查询

    void rlist(sqlist list) {

    for (int i = 0; i < list.length; i++) {

    cout << "list数组中第" << i + 1 << "个元素的值为" << list.elem[i] << endl;

    }

    }

    //插入

    void insertlist(sqlist& list, int pos, elemType val) {

    for (int i = list.length-1; i >=pos-1; i--){

    list.elem[i+1 ] = list.elem[i];

    //从最后一个元素开始,依次向后移动一个位置

    }

    list.elem[pos - 1] = val;

    list.length++;

    }

    //删除

    void deletelist(sqlist& list, int pos, elemType &deleteval) {

    deleteval = list.elem[pos - 1];

    for (int i = pos-1; i < list.length;i++){

    list.elem[i] = list.elem[i + 1];

    //从删除的元素开始,依次向前移动一个位置

    }

    list.length--;

    }

    int main() {

    sqlist list;

    initsqlist(list);

    insertlist(list, 3, 99);

    insertlist(list, 1, 99);

    rlist(list);

    elemType deleteval;

    deletelist(list, 4, deleteval);

    rlist(list);

    return 0;

    }在这里插入代码片

    效果图

    912c8d102c33957260a922a8703595e6.png

    线性表的创建,实现插入,删除,查询和初始化创建功能 ——以c语相关教程

    展开全文
  • 数据结构之线性表初始化及其操作

    万次阅读 多人点赞 2019-04-03 23:47:22
    1.线性表初始化,建立了一个空表 void InitList ( SqList * LP ) { LP - > length = 0 ; } 2.创建一个顺序表 void CreateList ( SqList * LP , ElemType a [ ] , int n ) { int ...


    TOC]

    一.准备工作

    1.定义存储空间的分配量

    #define MAXSIZE 10
    

    2.定义结果状态函数Status 返回成功失败的状态。

    误区:刚开始我把Status理解成了C语言的一个关键字,后来才知道Status是一个用户自定义函数,是定义的一种类型。

    用来表示成功或失败的状态。

        typedef int Status;//Status是函数的类型
    

    3.定义ElemType 函数类型,需要根据实际情况而定。

    typedef为类型定义标识符,作用是为一个数据类型或者结构(比如struct)重新定义一个名称。

    所以定义:

        typedef int ElemType;
    

    作用是:将关键字int重命名为ElemType

    intElemType代表的类型是一样的,声明和定义的变量是等价的

    4.通过结构类型来定义顺序表存储类型与定义。

    typedef struct
         {
             ElemType data[MAXSIZE];
             int length;
         
         }SqList;
    

    以上顺序表类型的定义【初始化】的含义:

    为顺序表分配一个容量为MAXSIZE大小的数组空间,数组名为data ,并将线性表的当前长度length设为0.

    [注意点]:

       为什么用数组来对线性表进行存储?
    

    顺序表的定义:用一组地址连续的存储单元依次存储线性表的各个数据元素,即用顺序存储的线性表

       它采用的数据元素存储方式是静态存储,这种方式还是有很多缺点的,因为你不知道自己实现到底需要计算机分配多少空间,在编程活动中,特别是我们的小学期中,很多同学出现了溢出或空间不够的现象,也就是传说中的“烫烫”,而数组的存储方式就是静态存储,计算机分配的空间都是你自己去定义的,后边进入链表我们会知道动态存储你需要多少空间计算机会自动按需分配,告别数组的这种静态存储带来的弊端。


    二.功能函数的声明

        void InitList(SqList *LP);//顺序表的初始化
        void CreateList(SqList *LP,ElemType a[],int n);//顺序表的创建
        void PrintList(SqList *LP);//顺序表的输出
        int ListLength(SqList *LP);//顺序表的长度,即当前元素的个数
        Status ListInsert(SqList *LP,int i,ElemType e);//顺序表的插入操作,在位置i插入元素
        Status GetElem(SqList *LP,int i,ElemType *e);//顺序表的查找操作,返回第i个位置的元素到e中
        Status ListDelete(SqList *LP,int i,ElemType *e);//顺序表的删除操作
    

    1.顺序表的初始化
    2.顺序表的创建
    3.顺序表的输出
    4.顺序表的长度,即当前元素的个数
    5.顺序表的插入操作,在位置i插入元素
    6.顺序表的查找操作,返回第i个位置的元素到e中
    7.顺序表的删除操作

    以上表示7个函数声明分别所代表的意义。

    接下来我们需要分别编写这7个功能函数,将对应的接口进行连接,最后写出主函数,通过主函数实现调用,完成整个操作。


    三.函数功能的编写

    1.线性表的初始化,建立了一个空表

        void InitList(SqList *LP)
        {
            LP->length=0;
        }
    

    2.创建一个顺序表

        void CreateList(SqList *LP,ElemType a[],int n)
        {
            int i;
        for(i=0;i<n;i++)
            {//通过循环将数组元素全部遍历放入顺序表中
            LP->data[i]=a[i];
            LP->length++;
            }
        }
    

    3.输出线性表

    void PrintList(SqList *LP)
    {
    	int i;
    	printf("\n顺序表中的元素为:\n");
    	for(i=0;i<LP->length;i++)
    	printf("%4d",LP->data[i]);
    	printf("\n\n");
    }
    

    4.线性表的当前长度

    void ListLength(SqList *LP)
    {
    	return LP->length;
    }
    

    5./*==========================================================
    函数功能的实现:顺序表的运算----元素的插入
    函数输入:顺序表的地址,插入值,插入位置
    函数输出:完成标志--------0:异常 1:正常

    ============================================================*/

    Status ListInsert(SqList *LP,int i,ElemType e)
    {
    	int k;
    	if(LP->length==MAXSIZE)//顺序表已满
    	return 0;
    	if(i<1||i>LP->length+1)//插入位置非法
    	return 0;
    
    	for(k=LP->length-1;k>=i-1;k--)//从顺序表最后一个元素开始后移
    	LP->data[k+1]=LP->data[k];
    LP->data[i-1]=e;//将插入的元素放入i-1中
    
    LP->length++;
    return 1;
    }
    

    6./*==========================================================
    函数功能的实现:顺序表的运算----元素的删除
    函数输入:顺序表的地址,删除位置,返回删除元素值
    函数输出:完成标志--------0:异常 1:正常

    ============================================================*/

    Status ListDelete(SqList *LP,int i,ElemType *e)
    {
    	int k;
    	if(LP->length==0)
    	return 0;
    	if(i<1||i>LP->length)
    	return 0;
    	*e=LP->data[i-1];
    for(k=i;k<LP->length;k++)
    LP->data[k-1]=LP->data[k];
    
    LP->length--;
    return 1;
    }
    

    7./*==========================================================
    函数功能的实现:顺序表的运算----元素的查找
    函数输入:顺序表的地址,查找位置,接收查找值的变量(地址)
    函数输出:完成标志--------0:异常 1:正常

    ============================================================*

    Status GetElem(SqList *LP)
    {
    	if(p->length==0||i<1||i>LP->length)
    	return 0;
    	*e=LP->data[i-1];
    	return 1;
    }
    

    四.主函数的编写

    	int main()
    	{
    		SqList L,*SP;
    		int flag;//用于接收函数状态返回或用于接收查找元素
    		ElemType result;
    		int search;
    
    		ElemType arr[]={12,14,16,24,28,30,42,77};
    		SP=&L;
    		InitList(SP);//初始化线性表
    		CreateList(SP,arr,8);//创建线性表
    		PrintList(SP);//输出线性表
    		printf("顺序表的当前长度为:%d\n",ListLength(SP));
    
    		//顺序表中插入元素
    		printf("在第几个位置插入?\n");
    		flag=ListInsert(SP,9,90);
    		if(flag==1)
    		{
    			PrintList(SP);
    			printf("顺序表当前长度为:%d\n\n",ListLength(SP));
    		}
    		else
    		{
    			printf("顺序表插入失败\n");
    			printf("顺序表的当前长度为:%d\n\n",ListLength(SP));
    		}
    
    		/*顺序表中查找元素*/
    		printf("要查找第几个元素?\n\n");
    		scanf("%d",&search);
    		flag=GetElem(SP,search,&result);
    		if(flag==1)
    		printf("第%d个元素是%d\n\n",search,result);
    		else
    		printf("顺序表查找失败!\n");
    
    		/*顺序表的删除操作*/
    		printf("要删除第几个元素?\n");
    		scanf("%d",&search);
    		flag=ListDelete(SP,search,&result);
    		if(flag==1)
    		printf("删除的第%d个元素是%d\n\n",search,result);
    		else
    		printf("顺序表删除失败!\n");
    
    		return 0;
    	}
    

    五.函数接口说明

    1. 线性表的初始化
    void InitList(SqList *LP);
    

    接口1:SqList *LP
    含义:线性表的地址。

    1. 线性表的创建
     	void InitList(SqList *LP);//顺序表的初始化
    

    接口1:SqList *LP
    含义:线性表的地址。

    1. 线性表的输出
     void PrintList(SqList *LP);//顺序表的输出
    

    接口1:SqList *LP
    含义:线性表的地址。

    1. 线性表的当前长度
     int ListLength(SqList *LP);//顺序表的长度,即当前元素的个数
    

    接口1:SqList *LP
    含义:线性表的地址。

    1. 线性表的插入操作
     Status ListInsert(SqList *LP,int i,ElemType e);//顺序表的插入操作,在位置i插入元素
    

    接口1:SqList *LP线性表的地址
    接口2:int i插入的位置
    接口3:ElemType e插入的新元素值

    1. 线性表的查找操作
    Status GetElem(SqList *LP,int i,ElemType *e);//顺序表的查找操作,返回第i个位置的元素到e中
    

    接口1:SqList *LP线性表的地址
    接口2:int i查找到的位置
    接口3:ElemType *e返回元素值

    1. 线性表的删除操作
     Status ListDelete(SqList *LP,int i,ElemType *e);//顺序表的删除操作
    

    接口1:SqList *LP线性表的地址
    接口2:int i要删除的位置
    接口3:ElemType *e获得的删除值


    六.实现思路

    代码流程图


    展开全文
  • Java数据结构——线性表的顺序存储实现一、描述线性结构特点:(1)存在唯一的一个被称作“第一个”的数据...常用的两种存储结构为:线性表的顺序存储结构和线性表的链式存储结构。线性表的顺序表示:指的是用一组地址...

    Java数据结构——线性表的顺序存储实现

    一、描述

    线性结构特点:

    (1)存在唯一的一个被称作“第一个”的数据元素

    (2)存在唯一的一个被称作“最后一个”的数据元素

    (3)除第一个之外,集合中的每个数据元素均只有一个前驱

    (4)除最后一个之外,集合中的每个数据元素均只有一个后继

    线性表:是n个数据元素的有限序列。常用的两种存储结构为:线性表的顺序存储结构和线性表的链式存储结构。

    线性表的顺序表示:指的是用一组地址连续的存储单元依次存储线性表的数据元素。

    538d545f0ec7cd66af591757910c7afa.png

    本篇主要讲线性表的顺序存储。

    二、源码

    2.1 SequenceList.java

    package com.yds.list;

    import java.util.Arrays;

    public class SequenceList{

    //默认长度

    private int DEFAULT_SIZE = 2;

    //定义一个数组用于保存线性表的长度

    private Object[] elementData;

    //用于保存数组长度

    private int capacity;

    //保存顺序表中当前元素的个数

    private int size = 0;

    /**

    * 构造一个默认长度的空线性表

    */

    public SequenceList(){

    capacity = DEFAULT_SIZE;

    elementData = new Object[capacity];

    }

    /**

    * 用一个初始化元素来创建线性表

    * @param element 初始化元素

    */

    public SequenceList(T element){

    this();

    elementData[0] = element;

    size++;

    }

    /**

    * 用一个元素和指定长度来创建线性表

    * @param element 元素

    * @param initSize 指定长度

    */

    public SequenceList(T element,int initSize){

    capacity = 1;

    if(capacity

    capacity = initSize +2;

    }

    elementData = new Object[capacity];

    elementData[0] = element;

    size++;

    }

    /**

    * 向顺序表中插入元素

    * @param element   待插入的元素

    * @param index 待插入的位置

    */

    public void insert(T element,int index){

    if(index<0||index>size){

    throw new IndexOutOfBoundsException("数组越界异常");

    }

    ensureCapacity(size+1);

    //把index以后的元素都后移一位

    System.arraycopy(elementData, index, elementData, index+1, size-index);

    elementData[index] = element;

    size++;

    }

    /**

    * 表长

    * @return

    */

    public int length(){

    return size;

    }

    /**

    * 向表中添加元素

    * @param element

    */

    public void add(T element){

    insert(element, size);

    }

    /**

    * 得到线性表存储的对象

    * @param index 获得的位置

    * @return  得到的结果

    */

    public T get(int index){

    if(index<0||index>size)

    throw new IndexOutOfBoundsException("数组越界异常");

    return (T)elementData[index];

    }

    /**

    * 判断线性表是否为空

    * @return

    */

    public boolean isEmpty(){

    return size==0;

    }

    /**

    * 清空线性表

    */

    public void clear(){

    Arrays.fill(elementData, null);

    size = 0;

    }

    /**

    * 获取指定位置的前一个元素

    * @param index 线性表位置,若是取线性表最后一个元素,必须index = size,

    * size为线性表元素个数

    * @return

    */

    public T priorElem(int index){

    if(index>0&&index

    return (T)elementData[index-1];

    else {

    throw new IndexOutOfBoundsException("数组越界异常");

    }

    }

    /**

    * 删除指定位置的元素

    * @param index

    */

    public void delete(int index){

    if(index<0||index>size-1){

    throw new IndexOutOfBoundsException("数组越界异常");

    }else{

    //把数组前移一位

    System.arraycopy(elementData, index+1, elementData, index, size-index-1);

    size--;

    //清空最后一个元素

    elementData[size]=null;

    }

    }

    /**

    * 获取指定线性表位置的后一个元素

    * @param index 线性表位置,若是取线性表第0个元素,必须index=-1

    * @return

    */

    public T nextElem(int index){

    if (index==-1) {

    return (T)elementData[0];

    }

    else if (index-1) {

    return (T)elementData[index+1];

    }else{

    throw new IndexOutOfBoundsException("数组越界异常");

    }

    }

    /**

    * 确保数组所需长度大于数组原有长度

    * @param mCapacity 数组所需长度

    */

    private void ensureCapacity(int mCapacity){

    if(mCapacity>capacity){

    capacity=mCapacity+2;

    //          System.out.println("capacity:"+capacity);

    elementData = Arrays.copyOf(elementData, capacity);

    }

    }

    }

    2.2 JavaMain.java

    package com.yds.list;

    public class JavaMain {

    public static void main(String[] args) {

    // TODO Auto-generated method stub

    SequenceList list = new SequenceList();

    System.out.println("isEmpty:"+list.isEmpty());

    String La[] = {

    "3"

    };

    for (int i = 0; i < La.length; i++) {

    list.add(La[i]);

    }

    System.out.println("isEmpty:"+list.isEmpty());

    for (int i = 0; i < La.length; i++) {

    System.out.println(list.get(i));

    }

    System.out.println("length:"+list.length());

    System.out.println("priorElem:"+list.priorElem(1));

    list.insert("7", 0);

    System.out.println("--------------------");

    for (int i = 0; i < list.length(); i++) {

    System.out.println(list.get(i));

    }

    System.out.println("length:"+list.length());

    System.out.println("--------------------");

    System.out.println("priorElem:"+list.priorElem(1));

    System.out.println("nextElem:"+list.nextElem(0));

    System.out.println("--------------------");

    list.delete(1);

    for (int i = 0; i < list.length(); i++) {

    System.out.println(list.get(i));

    }

    list.clear();

    System.out.println("isEmpty:"+list.isEmpty());

    System.out.println("----------SequenceList(T element)----------");

    SequenceList list1 = new SequenceList("5");

    for (int i = 0; i < La.length; i++) {

    list1.add(La[i]);

    }

    for (int i = 0; i < list1.length(); i++) {

    System.out.println(list1.get(i));

    }

    System.out.println("-------SequenceList(T element,int initSize)--------");

    SequenceList list2 = new SequenceList("5",3);

    for (int i = 0; i < La.length; i++) {

    list2.add(La[i]);

    }

    for (int i = 0; i < list2.length(); i++) {

    System.out.println(list2.get(i));

    }

    }

    3 结果截图

    展开全文
  • 线性表 按存储方式不同 连续存储空间分组称为顺序存储 非连续存储空间称为链表 线性表基本概念 线性结构是一种最简单且常用的数据结构,基本的特点是节点之间满足线性关系。 线性表是零个或者多个数据元素的有限序列...
  • 内容节点结构InitList(*L):初始化一个线性表ListEmpty(L):判断是否为空表ClearList(*L):清空线性表GetElem(L,i,*e):将表中的第i个元素,返回给eLocateElem(L,e):查找表中是否有与e相等元素ListInsert(L,i,e):在...
  • void InitList(SqList *&L) //初始化线性表 { L=(SqList *)malloc(sizeof(SqList)); //分配存放线性表的空间 L->length=0; //置空线性表长度为0 } void DestroyList(SqList *L) //销毁线性表 { free(L); } ...
  • 数据结构线性表顺序表的初始化输出输入查找测量删除等操作C语言
  • 初始化空的线性表,&L 引用参数表示会修改值 // 构造空表 L.elem =(ElemType *) malloc (LIST_INIT_SIZE* sizeof (ElemType)); // 分配内存,返回void*指针,类型强转一下 if (!L.elem) exit(OVERFLOW); // ...
  • cout 初始化线性表长度: " ; cout 在list1中插入元素2后list1为:" ; insertList(list1, 1, 2); listTraverse(list1); cout 在list1中的1改为3" ;; modifyList(list1, 1, 3); cout 在list1中第二个位置...
  • 创建一个顺序表 List[]={1,2,6,9,7,4,22,11,25,17,8,3,55,101,39,44,71,39,21} 然后移动顺序表中的元素变为: List[]={8,3,55,101,39,44,71,39,21,1,2,6,9,7,4,22,11,25,17} 也就是把原来的顺序表元素8之前的元素,...
  • /本程序中半酣对线性表创建初始化、插入、删除、查找、遍历等基本常用操作/ #include<stdio.h> #include<stdlib.h> #define maxsize 100 typedef int ElemType; typedef struct sqlist { ElemType ...
  • 线性表创建(C)

    2021-05-24 02:43:28
    main.c#define _CRT_SECURE_NO_WARNINGS#include "header.h"#include "SqList.h"void main(void) {...//初始化线性表。。。。。。。。。。。。。。。。。//添加自己的程序代码while (1);}header.h#include #inc...
  • 函数完成对线性表(单链表)的初始化创建附加头结点,将线性表初始长度置为0。 打开“线性表”项目,创建线性表(单链表)类型的两个文件“LList.h”“LList.c”。 在“LList.h”头文件中声明线性表(单链表)类型...
  • 链表、线性表初始化和操作。(主要参考自数据结构c语言版) /*2018.7.24,程序主要参考自数据结构c语言版,主要为了自己练手*/ #include&lt;iostream&gt; #include&lt;cstdlib&gt; #include&...
  • 线性表创建和操作

    2021-03-05 13:54:15
    //对顺序表的操作#include#include #include#define MAXSIZE 1000typedef char ElemType;typedef struct{ElemType data[MAXSIZE];...//初始化线性表void InitList(SqList*&L){L=(SqList*)malloc(sizeof(SqL...
  • 本文给出了单链表的初始化(带头结点、不带头结点)、结点的定义(两种方式)、头指针 L 的两种命名方式及区别,它们的代码及相应图示助于理解,代码实现使用的是C语言在线工具。无概念解释,初学者建议配合书本食用...
  • //初始化 void initsqlist(sqlist& list) { list.elem = new elemType[LIST_INIT_SIZE]; //上下两句语句等价 //list.elem=(int*) malloc(5*sizeof(int)); list.size = LIST_INIT_SIZE; list.length = 0; //...
  • 线性表之顺序表的创建 初始化 查找 删除 插入合并
  • 线性表初始化及插入元素操作

    千次阅读 2018-06-06 13:35:04
    C语言实现 #include&amp;lt;stdio.h&amp;gt;...#define LIST_INIT_SIZE 100 // 初始分配空间 typedef struct { int *elemList; // 定义int类型指针指向数组,elem为数组首元素地址 i...
  • 线性表的建立使用

    千次阅读 多人点赞 2018-09-05 22:02:08
    void CreatList(List * & L, int a[], int n) //初始化线性表,构造一个空的线性表L {  int i = 0;  L = ( List *) malloc( sizeof( List ) );  while( i )  {  L->data[i] = a[i];  i++;  }  L->...
  • 线性表的基本创建和输入输出

    千次阅读 2021-09-02 14:52:01
    #include<iostream> #include<malloc.h> using namespace std; typedef struct SqList{ ...L) //线性表创建初始化) { L.elem=(int *)malloc(20*sizeof(int)); //动态分配内存空间 L.length=0; .
  • 本文只要讲述了顺序存储线性表的一些基本操作,对于老鸟老说可能偏简单,但是对于新手或者很久没碰线性表的读者来说,还是比较有价值的,代码我都一一调试过。且必要的地方,我也做了详细的注释,这样也为自己后期...
  • printf("请向线性表中输入值:"); for(i=0;i;i++) { //int temp; scanf("%d",&L.data[i]); L.length++; } return true; } bool InsertList(SqList &L,int i,ElemType e) { if(i|| i>L.length+1) ...
  • * 实现线性表 */ public class sequenceList<T> { private int length; // 线性表的长度 final int maxSize = 10; // 线性表的最大长度 private T[] listArray; // 存储元素的数组对象 .
  • 3.其他数据,有且仅有一个前件一个后件; 4.在任意删除或增加一个数据后,剩余数据仍然满足以上三个条件。 线性表的表示: *1.可以用线性存储结构表示: 数组 2.可以用非线性存储结构表示:链表 * 在这里我们使用...
  • 线性表整表创建方法:头插法尾插法
  • 线性表创建(最基础)

    千次阅读 2021-03-26 21:27:34
    线性表:是最基本、最简单、也是最常用的一种数据结构。 前提:在学习数据结构的时候命名不要使用拼音!这是初学者的经常犯得错误。 顺序表的创建: #include<stdio.h> #define N 10 typedef int SLDataType; ...
  • C语言创建线性表

    千次阅读 2019-09-20 22:30:55
    动态分配而非数组的线性表 在VS2019中创建的,结构体里定义了默认的构造函数...ListInit 初始化时输入一批数据 ListDelete 删除某个位置的数据 ListSearch 查找某数据在什么位置 ListOutput 输出全部数据 这是头文件...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,805
精华内容 9,122
关键字:

线性表的初始化和创建