精华内容
下载资源
问答
  • 线性表基本操作 实验报告.doc
    2021-06-04 10:15:12

    线性表基本操作 实验报告

    院 系: 计算机科学学院

    专 业: 计算机科学与技术

    年 级:

    课程名称: 数据结构

    学 号:

    姓 名:

    指导教师:

    2011年 03 月 26 日

    年级?班号?学号?专业计算机科学与技术?姓名实验名称?线性表基本操作实验

    类型设计型综合型创新型YES实

    求?目的:实现线性表基本操作

    要求:1、实现线性表的插入,删除,求表长,查找e元素的前驱、后继,查找第i个位置的元素等基本操作。

    2、程序以菜单方式工作,其中一个选项控制退出程序,其他选项可循环进行选择。实

    录实验源代码:

    #include

    #include

    #include

    typedef struct

    {

    int num;

    char name[20];

    int age;

    }student;

    typedef struct

    {

    student *elem;

    int len;

    int maxsize;

    }sqlist;

    void InitList_Sq(sqlist &L)

    {

    L.elem=(student*)malloc(100*sizeof(student));

    L.len=0;

    L.maxsize=100;

    }

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    (写不完时,可另加附页。)实

    录?

    ?int ListInsert_Sq(sqlist &L)

    {

    char con='y';

    int i=0;

    while((con=='y')||(con=='Y'))

    {

    if(L.len<100)

    {

    printf("Number:");

    scanf("%d",&L.elem[i].num);

    printf("Name:");

    scanf("%s",L.elem[i].name);

    printf("Age:");

    scanf("%d",&L.elem[i].age);

    i++;

    L.len++;

    printf("Do you want to contiune?(Y/N)");

    getchar();

    scanf("%s",&con);

    while((con!='y')&&(con!='Y')&&(con!='N')&&(con!='n'))

    {

    printf("you can not choice but'y'and'n',please choice again!");

    getchar();

    scanf("%s",&con);

    }

    }

    else

    con='n';

    }

    return 1;

    }

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    (写不完时,可另加附页。)实

    录?

    ?int output_sq(sqlist &L)

    {

    int j;

    for(j=0;j<=(L.len-1);j++)

    {

    printf("Number:%d\n",L.elem[j].num);

    printf("Name:%s\n",L.elem[j].name);

    printf("age:%d\n\n",L.elem[j].age);

    }

    return 1;

    }

    int getelem(sqlist L)

    {

    int i;

    printf("Which one do you want to getelem?");

    scanf("%d",&i);

    i=i-1;

    printf("Number:%d\n",L.elem[i].num);

    printf("Name:%s\n",L.elem[i].name);

    printf("age:%d\n\n",L.elem[i].age);

    return 1;

    }

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    ?

    (写不完时,可另加附页。)实

    录?

    ?void insert(sqlist &L)

    {

    int i,j;

    printf("before which place do you want to insert?");

    更多相关内容
  • 实验一 线性表基本操作的编程实现 实验目的 线性表基本操作的编程实现 要求 线性表基本操作的编程实现2学时验证型掌握线性表的建立遍历插入删除等基本操作的 编程实现也可以进一步编程实现查找逆序排序等操作存储...
  • 线性表基本操作

    2018-03-12 22:58:46
    完成一些简单的删除操作,包括比较,和框定范围对数据处理
  • 线性表包括两部分顺序表和链表,是数据结构的基础,在此主要就算法进行分析和总结,作为记忆了解,未做具体实现。 提示:以下是本篇文章正文内容,下面案例可供参考 一、顺序表 #define LISST_INIT_SIZE 100 #...
  • java实现线性表基本操作

    主类:

    
    
    public class Start {
        public static void main(String[] args) {
            LinearList linearList = new LinearList(5);
            System.out.println("--插入元素测似(1):--");
            linearList.tailInsert(10);
            linearList.tailInsert(20);
            linearList.tailInsert(30);
            linearList.tailInsert(40);
            linearList.tailInsert(50);
            linearList.showInfo();
            linearList.tailInsert(60);
            System.out.println("--删除元素测似:--");
            linearList.remove(4);
            linearList.showInfo();
            linearList.remove(4);
            linearList.showInfo();
            linearList.remove(1);
            linearList.showInfo();
            System.out.println("--插入元素测似(2):--");
            linearList.insert(50,3);
            linearList.showInfo();
            linearList.insert(60,4);
            linearList.showInfo();
            linearList.insert(40,3);
            linearList.showInfo();
            linearList.insert(40,3);
            linearList.showInfo();
        }
    }
    

     线性表类:

    package Class.LinearList;
    
    public class LinearList {
        private int length = 0;
        private int[] arr;
        private static final int MIN_CAPACITY = 3;
    
        // 构造方法一
        public LinearList(int length) {
            if (length >= MIN_CAPACITY) {
                arr = new int[length];
            } else {
                System.out.println("要求线性表最小长度为3!");
            }
        }
    
        // 构造方法二
        public LinearList() {
            this(MIN_CAPACITY);
        }
    
        //判断线性表是否为空
        public boolean isEmpty() {
            return length == 0;
        }
    
        // 判断线性表是否为满
        public boolean isFull() {
            return length == arr.length;
        }
    
        // 返回线性表长度
        public int size() {
            return length;
        }
    
        // 返回首个与key相等的元素的索引,查找不成功,返回null(这里是0)
        public int keySearch(int key) {
            if (isEmpty()) {
                throw new RuntimeException("线性表为空!");
            }
            for (int i = 0; i < length; i++) {
                if (arr[i] == key) {
                    return i;
                }
            }
            System.out.println("线性表中没有该元素");
            return 0;
        }
    
        // 删除首个与key相等的元素的,返回被删除元素
        public void keyRemove(int key) {
            if (isEmpty()) {
                System.out.println("线性表为空!");
                return;
            }
            for (int i = 0; i < length; i++) {
                if (arr[i] == key) {
                    arr[i] = 0;
                    length--;
                    return;
                }
            }
            System.out.println("线性表中没有该元素");
        }
    
        // 插入value,作为第n个元素
        public void insert(int value, int n) {
            if (isFull()) {
                System.out.println("线性表已满");
                return;
            }
            // 插入位置
            if (n >= 1 && n <= length + 1) {
                for (int i = length; i >= n; i--) {
                    arr[i] = arr[i - 1];
                }
                arr[n - 1] = value;
            } else if (n > length + 1) {
                System.out.println("插入位置过大,自动插入到尾部");
                this.insert(value, length + 1);
            } else if (n < 1) {
                System.out.println("插入位置过小,自动插入到头部");
                this.insert(value, 1);
            }
            length++;
        }
    
        // 在尾部插入value元素
        public void tailInsert(int value) {
            this.insert(value, length + 1);
        }
    
        // 删除第n个元素
        public void remove(int n) {
            if (isEmpty()) {
                throw new RuntimeException("线性表为空!");
            }
            if (n >= 1 && n <= length) {
                for (int i = n - 1; i <= length - 2; i++) {
                    arr[i] = arr[i + 1];
                }
                arr[length - 1] = 0;
                length--;
            } else {
                throw new RuntimeException("删除位置有误");
            }
        }
    
        // 设置第n个元素为value
        public void setValue(int value, int n) {
            if (isEmpty()) {
                System.out.println("当前线性表为空");
            }
            if (n > length || n < 1) {
                System.out.println("访问越界");
                return;
            } else {
                arr[n - 1] = value;
            }
        }
    
        //
        public void showInfo() {
            for (int i = 0; i < length; i++) {
                System.out.print(arr[i] + "\t");
            }
            System.out.println("");
        }
    
    }
    

    展开全文
  • 西南交通大学 报告仅供参考,请独立完成作业
  • 实验一 -- 线性表基本操作的编程实现 实验一 线性表基本操作的编程实现 实验目的 线性表基本操作的编程实现 要求 线性表基本操作的编程实现 2学时验证型掌握线性表的建立遍历插入删除等基本操作的编程实现也可以...
  • 线性表基本操作函数定义,创建、清空、初始化等操作函数集锦
  • 数据结构实验线性表基本操作.doc
  • 数据结构实验-线性表基本操作.doc
  • 数据结构之线性表基本操作及实践
  • 线性表基本操作和简单程序 实验目的 一、实验目的与基本要求 1.掌握数据结构中的一些基本概念。数据、数据项、数据元素、数据类型和数据结构,以及它们之间的关系。 2.了解数据的逻辑结构和数据的存储结构之间的...

    线性表基本操作和简单程序

    实验目的

    一、实验目的与基本要求
    1.掌握数据结构中的一些基本概念。数据、数据项、数据元素、数据类型和数据结构,以及它们之间的关系。
    2.了解数据的逻辑结构和数据的存储结构之间的区别与联系;数据的运算与数据的逻辑结构的关系。
    3.掌握顺序表和链表的基本操作:插入、删除、查找以及表的合并等运算。
    4.掌握codeblock上机调试程序的基本方法及C语言编程。

    实验内容

    1.认真阅读和掌握和本实验相关的教材内容及所给的两个程序代码。
    2.建立顺序表,基本操作包括:初始化,建立一个顺序存储的链表,输出顺序表,判断是否为空,取表中第i个元素,定位函数(返回第一个与x相等的元素位置),插入,删除。
    3.建立单链表,基本操作包括:初始化,建立一个链式存储的链表,输出顺序表,判断是否为空,取表中第i个元素,定位函数(返回第一个与x相等的元素位置),插入,删除。
    4.用顺序表和链表分别设计输入一组数据(4,6,9,0,2,-25,14,3,-29),测试程序的如下功能:根据输入的数据,找到相应的存储单元并删除,并显示表中所有的数据,例如输入数据3,如果存在所在的数据中,删除,输出删除后的这组数据,否则,直接输出。

    顺序表代码

    #include <bits/stdc++.h>
    const int maxn=1e3+10;
    using namespace std;
    struct List
    {
    	int num;
    	int id;
    };
    typedef struct 
    {
    	List *place;
    	int len;
    }Node;
    // 初始化
    bool init(Node &a)
    {
    	a.place=new List[maxn];
    	if(!a.len)
    		return false;
    	a.len=0;
    	return true;
    }
    // 取值
    bool get_num(Node a,int b,List &c)
    {
    	if(!b||b>a.len)
    		return false;
    	c=a.place[b-1];
    	return true;
    }
    // 查找
    int find(Node a,int b)
    {
    	for(int i=0;i<a.len;i++)
    		if(a.place[i].num==b)
    			return i+1;
    	return 0;
    }
    // 插入
    bool insert(Node &a,int b,int c)
    {
    	if(b<1 || b>a.len+1 || a.len==maxn)
    		return false;
    	for(int i=a.len-1;i>=b-1;i--)
    		a.place[i+1]=a.place[i];
    	a.place[b-1].num=c;
    	a.len+=1;
    	return true;
    }
    // 删除
    bool Delete(Node &a,int b)
    {
    	if(b<1 || b>a.len)
    		return false;
    	for(int i=1;i<=a.len;i++)
    		a.place[i-1]=a.place[i];
    	a.len--;
    	return true;
    }
    int main(int argc, char const *argv[])
    {
    	Node L;
    	List g;
    	int n,m,ID;
    	cout<<"/*****************请输入要进行的操作的编号*****************/"<<endl;
    	cout<<"1->建立"<<endl;
    	cout<<"2->输入"<<endl;
    	cout<<"3->取值"<<endl;
    	cout<<"4->查找"<<endl;
    	cout<<"5->插入"<<endl;
    	cout<<"6->删除"<<endl;
    	cout<<"7->输出"<<endl;
    	cout<<"0->退出\n"<<endl;
    	while(1)
    	{
    		cout<<"请输入编号:";
    		cin>>n;
    		if(!n)
    			break;
    		if(n==1)
    		{
    			if(init(L))
    				cout<<"建立顺序表成功"<<endl;
    			else
    				cout<<"建立顺序表失败"<<endl;
    			cout<<endl;
    		}
    		if(n==2)
    		{
    			cout<<"请输入链表元素的个数:";
    			cin>>m;
    			cout<<"请输入链表元素:";
    			L.place=new List[maxn];
    			int _;
    			for(int i=0;i<m;i++)
    			{
    				cin>>_;
    				L.place[i].num=_;
    				L.place[i].id=i;
    				L.len++;
    			}
    		}
    		if(n==3)
    		{
    			
    			cout<<"请输入链表中要取值的位置:";
    			cin>>ID;
    			if(get_num(L,ID,g))
    			{
    				cout<<"查找成功!";
    				cout<<"链表中第"<<ID<<"个位置的元素为:"<<g.num<<endl;
    			}
    			else
    				cout<<"查找失败!位置超出范围!"<<endl;
    		}
    		if(n==4)
    		{
    			cout<<"请输入需要查找的元素:";
    			int x;
    			cin>>x;
    			if(find(L,x))
    				cout<<"查找成功!该元素在顺序表中"<<endl;
    			else
    				cout<<"查找失败!该元素不在顺序表中"<<endl;
    		}
    		if(n==5)
    		{
    			cout<<"请输入需要插入的位置和元素(用空格隔开):";
    			int _,__;
    			cin>>_>>__;
    			if(insert(L,_,__))
    				cout<<"插入成功"<<endl;
    			else
    				cout<<"插入失败"<<endl;
    		}
    		if(n==6)
    		{
    			cout<<"请输入要删除的位置:";
    			int _;
    			cin>>_;
    			if(Delete(L,_))
    				cout<<"删除成功"<<endl;
    			else
    				cout<<"删除失败"<<endl;
    		}
    		if(n==7)
    		{
    			cout<<"当前顺序表读出:"<<endl;
    			for(int i=0;i<L.len;i++)
    				cout<<L.place[i].num<<" ";
    			cout<<endl;
    		}
    		cout<<endl;
    	}
    	return 0;
    }
    
    展开全文
  • 编程实现数据结构线性表基本操作

    千次阅读 2018-03-26 17:15:05
    这个代码主要实现了1 线性表的创建,插入,删除函数等2 主函数调用上面的函数#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;stdlib.h&gt; #include&lt;malloc.h&...
    这个代码主要实现了


    1 线性表的创建,插入,删除函数等


    2 主函数调用上面的函数


    #include<stdio.h>
    #include<stdlib.h>
    #include<stdlib.h>
    #include<malloc.h>
    struct LinearList	 	/*定义线性表结构*/
    {
    	int *list;		     /* 存线性表元素 */
    	int size;    		 /* 存线性表长度 */
    	int MaxSize;       /* 存list数组元素个数 */
    };
    typedef struct LinearList LIST;
    
    void InitList(LIST *L, int ms)	/* 初始化线性表 */
    {
    	if ((L->list = (int*)malloc(ms * sizeof(int))) == NULL) {
    		printf("内存申请错误!\n");
    		exit(1);
    	}
    	L->size = 0;//  L->size=0;              
    	L->MaxSize = ms;
    }
    
    int InsertList(LIST *L, int item, int rc)
    /* item:记录值  rc:插入位置  */
    {
    	int i;
    	if (L->size == L->MaxSize)	/* 线性表已满 */
    		return -1;
    	if (rc < 0)         		/* 插入位置为 0 --> L->size */
    		rc = 0;
    	if (rc>L->size)
    		rc = L->size;
    	for (i = L->size - 1; i >= rc; i--)	/* 将线性表元素后移 */
    		L->list[i + 1] = L->list[i];
    	L->list[rc] = item;
    	L->size++;
    	return 0;
    }
    
    void OutputList(LIST *L)		/* 输出线性表元素 */
    {
    	int i;
    	for (i = 0; i<L->size; i++)
    		printf("%d ", L->list[i]);
    	printf("\n");
    }
    
    
    int FindList(LIST *L, int item)/* 返回 >=0 为元素位置 -1 没找到 */
    {
    	int i;
    	for (i = 0; i < L->size; i++)
    	if (item == L->list[i])	/* 找到相同的元素,返回位置 */
    		return i;
    	return -1;				/* 没找到 */
    }
    
    
    int DeleteList1(LIST *L, int item)
    /* 删除指定元素值的线性表记录,返回>=0:删除成功 */
    {
    	int i, n;
    	for (i = 0; i < L->size; i++)
    	if (item == L->list[i])	/* 找到相同的元素 */
    		break;
    	if (i < L->size) {
    		for (n = i; n < L->size - 1; n++)
    			L->list[n] = L->list[n + 1];
    		L->size--;
    		return i;
    	}
    	return -1;
    }
    
    
    
    int DeleteList2(LIST L, int rc)	 /* 删除指定位置的线性表记录 */
    {
    	int i, n;
    	if (rc<0 || rc >= L.size)
    		return -1;
    	for (n = rc; n<L.size - 1; n++)
    		L.list[n] = L.list[n + 1];
    	L.list--;
    	return 0;
    }
    
    int main()
    {
    	LIST L1;
    	int i, r;
    	InitList(&L1, 100);
    	printf("list addr=%p\tsize=%d\tMaxsize=%d\n");
    	while (1)
    	{
    		printf("请输入元素值,输入0结束插入操作:");
    		fflush(stdin);
    		scanf_s("%d", &i);
    		if (i == 0)
    			break;
    		printf("请输入插入位置:");
    		scanf_s("%d", &r);
    		InsertList(&L1, i, r - 1);
    		printf("线性表为:");
    		OutputList(&L1);
    	}
    	while (1)
    	{
    		printf("请输入查找元素值,输入0结束查找操作:");
    		fflush(stdin);	/* 清空标准输入缓冲区 */
    		scanf("%d", &i);
    		if (i == 0)
    			break;
    		r = FindList(&L1, i);
    		if (r < 0)
    			printf("没找到\n");
    		else
    			printf("有符合条件的元素,位置为:%d\n", r + 1);
    	}
    	while (1)
    	{
    		printf("请输入删除元素值,输入0结束查找操作:");
    		fflush(stdin);	/* 清空标准输入缓冲区 */
    		scanf("%d", &i);
    		if (i == 0)
    			break;
    		r = DeleteList1(&L1, i);
    		if (r < 0)
    			printf("没找到\n");
    		else {
    			printf("有符合条件的元素,位置为:%d\n线性表为:", r + 1);
    			OutputList(&L1);
    		}
    	}
    	while (1)
    	{
    		printf("请输入删除元素位置,输入0结束查找操作:");
    		fflush(stdin);	/* 清空标准输入缓冲区 */
    		scanf("%d", &r);
    		if (r == 0)
    			break;
    		i = r = DeleteList2(L1, r - 1);
    		if (i < 0)
    			printf("位置越界\n");
    		else {
    			printf("线性表为:");
    			OutputList(&L1);
    		}
    	}
    
    	return 0;
    }
    
    //书上代码
    //#include<stdio.h>
    //#include<stdlib.h>
    //#include<malloc.h>
    //struct LinearList	 	/*定义线性表结构*/
    //{
    //	int *list;		     /* 存线性表元素 */
    //	int size;    		 /* 存线性表长度 */
    //	int MaxSize;       /* 存list数组元素个数 */
    //};
    //typedef struct LinearList LIST;
    //void InitList(LIST *L, int ms)	/* 初始化线性表 */
    //{
    //	if ((L->list = (int*)malloc(ms * sizeof(int))) == NULL) {
    //		printf("内存申请错误!\n");
    //		exit(1);
    //	}
    //	L->size = 0;
    //	L->MaxSize = ms;
    //}
    //
    //int InsertList(LIST *L, int item, int rc)
    ///* item:记录值  rc:插入位置  */
    //{
    //	int i;
    //	if (L->size = L->MaxSize)	/* 线性表已满 */
    //		return -1;
    //	if (rc < 0)         		/* 插入位置为 0 --> L->size */
    //		rc = 0;
    //	if (rc>L->size)
    //		rc = L->size;
    //	for (i = L->size - 1; i >= rc; i--)	/* 将线性表元素后移 */
    //		L->list[i + 1] = L->list[i];
    //	L->list[rc] = item;
    //	L->size++;
    //	return 0;
    //}
    //
    //void OutputList(LIST *L)		/* 输出线性表元素 */
    //{
    //	int i;
    //	for (i = 0; i<L->size; i++)
    //		printf("%d ", L->list[i]);
    //	printf("\n");
    //}
    //
    //int FindList(LIST *L, int item)		/* 返回 >=0 为元素位置 -1 没找到 */
    //{
    //	int i;
    //	for (i = 0; i < L->size; i++)
    //	if (item == L->list[i])	/* 找到相同的元素,返回位置 */
    //		return i;
    //	return -1;				/* 没找到 */
    //}
    //
    //int DeleteList1(LIST *L, int item)
    ///* 删除指定元素值的线性表记录,返回>=0:删除成功 */
    //{
    //	int i, n;
    //	for (i = 0; i < L->size; i++)
    //	if (item == L->list[i])	/* 找到相同的元素 */
    //		break;
    //	if (i < L->size) {
    //		for (n = i; n < L->size - 1; n++)
    //			L->list[n] = L->list[n + 1];
    //		L->size--;
    //		return i;
    //	}
    //	return -1;
    //}
    //
    //int DeleteList2(LIST L, int rc)	 /* 删除指定位置的线性表记录 */
    //{
    //	/*编写删除指定位置的线性表记录子程序*/
    //
    //	int DeleteList2(LIST * L, int rc)
    //	{
    //		int i, n;
    //		if (rc<0 || rc >= L->size)
    //			return -1;
    //		for (n = rc; n<L->size - 1; n++)
    //			L->list[n] = L->list[n + 1];
    //		L->list--;
    //		return 0;
    //	}
    //}
    

    展开全文
  • 线性表基本操作——删除,插入等

    千次阅读 2018-09-08 12:21:50
    线性表基本操作 (类C语言描述) 若一个元素占p个字节,则线性表第i个元素ai的存储位置,LOC(ai) = LOC(a1) + (i-1)*p; 线性表动态分配内存 #define LIST_INIT_SIZE 100 //线性表初始内存分配量 #define ...
  • 数据结构中的 顺序线性表基本操作,适合刚学数据结构的同学用
  • 线性表基本操作代码片段(C和C++)

    千次阅读 2022-03-13 17:03:02
    线性表基本操作代码片段(C和C++)
  • 线性表基本操作 数据结构C语言实现
  • //构造空的线性表 void DestroyList_Sq(SqList *L); //销毁一个线性表 void ClearList_Sq (SqList *L); //将L置为空表 Status ListEmpty_Sq (SqList L); //空表返回TRUE Status ListLength_Sq (SqList L); // 返回...
  • C语言线性表基本操作

    2010-05-03 12:14:14
    纯C语言写的线性表基本操作 程序段:/*线性表的操作*/ #include #include typedef int ElemType; struct List { ElemType *list; int size; int MaxSize; }; /*初始化列表,即动态存储空间分配并置L为一个空列表*...
  • C、C++介绍线性表基本操作

    千次阅读 2020-10-30 09:59:32
    线性表基本操作 文章目录线性表基本操作前言一、顺序表1、定义2、初始化构建3、插入操作1、算法2、代码实现4、删除操作1、算法2、代码实现5、合并操作二、链表1.单链表2.循环链表3.双向链表总结1 前言 线性表...
  • 帮助复习C语言程序设计中的知识。 熟悉线性表的逻辑结构。 熟悉线性表基本运算在顺序表(链表)结构上的实现。 掌握顺序表(链表)的存储结构形式及其描述和基本运算的实现。
  • 线性表基本操作

    2022-01-25 00:14:35
    线性表的一些基本操作(同时补充下部分功能实现的逻辑和原理): 构造线性表结构-----相当于C语言中的结构体,把实例的结构抽取、打框、定义类型、限制范围,最后取上别名 初始化线性表-----对定...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 48,015
精华内容 19,206
关键字:

线性表的基本操作