P1 功能：静态线性表操作 实习作业

最新推荐文章于 2023-02-20 21:44:25 发布
最新推荐文章于 2023-02-20 21:44:25 发布
阅读量2.2k 收藏 32
点赞数 7
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41424132/article/details/81165789
版权

自己写的 欢迎copy/学习 

这个有一个功能不好使， 就是删除x-y的范围---数字数字太大了就会崩，

因为是交上去的时候才发现的问题 就没有继续优化了，有意的可以再自己改一改哦。

功能截图：

 

 

这是整个程序的代码部分 ： 

/*
	源文件名：P1.cpp
	功能：静态线性表操作
*/
#include <iostream>
#include <iomanip>
#include <conio.h>
#include <stdio.h>
#include <process.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>

#define max 10000
int quicksort_swaps=0,quicksort_times=0;
struct SqList
{
	int data[max];         //存放元素的数组
	int length;            //当前长度
};

void init(SqList &list);
void display(SqList &list);
void insert(SqList &list);
void search(SqList &list);
void del(SqList &list);
void simpleSort(SqList &list);
void quickSort(SqList &list);
void quickSort_o(SqList &list,int left,int right);
void binarySearch(SqList &list);
void turn_around(SqList &list);
void 	del_x_to_y(SqList &list);
void insert_by_size(SqList &list);
void statistics(SqList &list);//统计函数
//魔改函数下面是(用于统计)
void init_statistics(SqList &list,int seed);
int simpleSort_swaps(SqList &list);
int simpleSort_times(SqList &list);
using namespace std;
SqList list;
int main()
{
	char choice;

	while (1)
	{
		system("cls");
		cout << "\n\n\n\n";
		cout << "\t\t            静态线性表操作  \n";
		cout << "\t\t======================================";
		cout << "\n\n";
		cout << "\t\t             1：初始化      \n";
		cout << "\t\t             2：显示        \n";
		cout << "\t\t             3：单个插入    \n";
		cout << "\t\t             4：查找        \n";
		cout << "\t\t             5：删除        \n";
		cout << "\t\t             6：简单排序    \n";
		cout << "\t\t             7：快速排序    \n";
		cout << "\t\t             8：折半查找(请先排序)    \n";
		cout << "\t\t             9: 顺序表的就地逆置(一闪而过)\n\n";
		cout << "\t\t             q: *删除表中元素值在x到y的元素 (请先排序) \n";
		cout << "\t\t             w: *有序插入(请先排序) \n";
		cout << "\t\t             e: *自动统计\n";
		cout << "\n";
		cout << "\t\t             0：退出        \n";
		cout << "\n";
		cout << "\t\t请选择：" << flush;

		choice = getch();
		system("cls");

		switch(choice)
		{
			case '1':
				init(list);
				break;
			case '2':
				display(list);
				break;
			case '3':
				insert(list);
				break;
			case '4':
				search(list);
				break;
			case '5':
				del(list);
				break;
			case '6':
				simpleSort(list);
				break;
			case '7':
				quickSort(list);
				break;
			case '8':
				binarySearch(list);
				break;
				case '9':
				turn_around(list);
					break;
					case 'q':
					del_x_to_y(list);
						break;
				case 'w':
			 	insert_by_size(list);
							break;
				case 'e':
						 	statistics(list);
										break;

			case '0':
				exit(0);
		}
	}
}



//屏幕提示后，从键盘输入线性表长度和随机数种子，生成指定长度的线性表list
void init(SqList &list)
{
	int i;
	while (1)
	{
	    cout << "输入元素个数（0－" << max << "）：" << flush;
		cin >> list.length;
		if (list.length >= 0 && list.length <= max)
			break;
		cout << endl;
	}
	while (1)
	{
	    cout << "输入随机数种子（0－32767）：" << flush;
		cin >> i;
		if (i >= 0 && i <= 32767)
			break;
		cout << endl;
	}
	srand(i);  //指定随机数种子，相同的种子将产生相同的数据序列
	rand();

	for (i = 0; i < list.length; i++)
	{
		list.data[i] = rand() % 10000;
	}
	for (i = list.length; i < max; i++)
		list.data[i] = 0;
}

//在屏幕上依次显示线性表list中的元素个数和全部元素
//格式应便于观察
//如果需要指定输出的宽度，可以使用 cout << setw(W) << X ，其中 X 是输出的数值，W 是占据的列数
void display(SqList &list)
{int i;
for(i=0;i<list.length;i++)
	{printf("[%5d]= %6d\n",(i+1),list.data[i]);}
	 puts("press 1 to continue");
   while(scanf("%d",&i )!=1);
}
//屏幕提示后，从键盘输入一个元素值，然后把这个新元素插到线性表list的末尾
//应有溢出判断和报告
void insert(SqList &list)
{	if((list.length+1)<=max){
	printf("键入新元素的值:(一个数字)" );
	scanf("%d",&list.data[list.length] );
	list.length++;
}
		else printf("空间不足无法加入新值\n" );
		int i;
		puts("press 1 to continue");
    while(scanf("%d",&i )!=1);
}
//屏幕提示后，从键盘输入一个元素值，在线性表list中搜索这个元素
//屏幕显示搜索结果和搜索过程中的比较次数
void search(SqList &list)
{ int i;
	int key;
	int flag=0;
	printf("输入你要查找到值(数字)\n" );
	scanf("%d",&key);
	for(i=0;i<list.length;i++){
		if(list.data[i]==key)break;
		flag++;
	}
	if( (i==list.length)&&(list.data[i]!=key)) printf("没找到\n" );
	else printf("[%5d]= %6d\n",(i+1),list.data[i]);
printf("查找次数:%d\n",flag );
puts("press 1 to continue");
	while(scanf("%d",&i )!=1);
}
//屏幕提示后，从键盘输入一个元素值，在线性表list中删除这个元素
//屏幕显示删除成功与否的信息，并显示比较次数和移动次数
void del(SqList &list)
{ int i;
	int key;
	int flag=0;
	printf("输入你要del的值(数字)\n" );
	scanf("%d",&key);
	for(i=0;i<list.length;i++){
		if(list.data[i]==key)break;
		flag++;
	}
	if( (i==list.length)&&(list.data[i]!=key)) printf("没找到\n" );

	//从这里开始是删除部分(上面是查找部分)
	else {
		printf("[%5d]= %6d\n",(i+1),list.data[i]);
		for(;(i+1)<list.length;i++){
		list.data[i]=list.data[i+1];//每一个元素都向前平移
			}
		list.length--;//总长度减一
printf("删除成功!\n" );
	}
	puts("press 1 to continue");
		while(scanf("%d",&i )!=1);
}

//对线性表list进行简单排序
//屏幕显示比较次数和移动次数
void simpleSort(SqList &list)
{
  int i,j,times=0,swaps=0,t;
printf("排序如下:\n" );
for(i=0;i<list.length;i++)
  {for(j=i;j<list.length;j++){
    times++;
    if(list.data[i]>list.data[j]){
      swaps++;
  t=list.data[i];
      list.data[i]=list.data[j];
      list.data[j]=t;
    }
  }}

  printf("比较次数:%d\n移动次数:%d",times,swaps );
  puts("press 1 to continue");
  while(scanf("%d",&i )!=1);
}
//对线性表list进行快速排序
//屏幕显示比较次数和移动次数
void quicksort_o(SqList &list,int left,int right)
{ int*a;
a=list.data;
	 int i,j,t,temp;
	 if(left>right)
			return;

	 temp=a[left]; //temp中存的就是基准数
	 i=left;
	 j=right;
	 while(i!=j)
	 {
									//顺序很重要，要先从右边开始找
									while(a[j]>=temp && i<j)
													 {j--;quicksort_times++;}
									//再找右边的
									while(a[i]<=temp && i<j)
													 {i++;quicksort_times++;}
									//交换两个数在数组中的位置
									if(i<j)
									{
													 t=a[i];
													 a[i]=a[j];
													 a[j]=t;
									}
	 }
	 //最终将基准数归位
	 quicksort_swaps++;
	 a[left]=a[i];
	 a[i]=temp;

	 quicksort_o(list,left,i-1);//继续处理左边的，这里是一个递归的过程
	 quicksort_o(list,i+1,right);//继续处理右边的 ，这里是一个递归的过程
}
void quickSort(SqList &list){
	quicksort_o(list,0,(list.length-1));
	cout<<"quicksort_times--比较次数"<<quicksort_times<<endl;
	cout<<"quicksort_swaps--交换次数"<<quicksort_swaps<<endl;
	int i;
	puts("press 1 to continue");
while(scanf("%d",&i )!=1);
}
//屏幕提示后，从键盘输入一个元素值，对经过排序的线性表list进行折半查找
//屏幕显示查找结果，并显示比较次数
void binarySearch(SqList &list)
{
  int key;
  int times=0;
  printf("输入你要二分查找的值(数字)\n" );
	scanf("%d",&key);
  int mid,low=0,high=list.length-1;

    while(low<=high){
    times++;
      if(list.data[low]==key){
        printf("[%d]%d,查找次数为:%d",low,list.data[low],times );
        break;}
      if(list.data[high]==key){
        printf("[%d]%d,查找次数为:%d",high,list.data[high],times );
        break;
      }
    mid=(low+high)/2;
    if(list.data[mid]==key){
      printf("[%d]%d,查找次数为:%d",mid,list.data[mid],times );
      break;
    }
    if(list.data[mid]>key)high=mid-1;
    if(list.data[mid]<key)low=mid+1;
    }
    if(low>high)printf("没有找到,查找次数为:%d\n",times );
int i;
    puts("press 1 to continue");
while(scanf("%d",&i )!=1);
}
//编程实现一个顺序表的就地逆置，即利用原表的存储空间将顺序表逆置
void turn_around(SqList &list)
{

	int i;
	for(i=0;i<list.length/2;i++){
		list.data[i] += list.data[list.length-i-1];//i是总和
		list.data[list.length-i-1] = list.data[i]-list.data[list.length-i-1];//尾部变成原来的i
		list.data[i] -= list.data[list.length-i-1];//头部变成原来的list.data[list.length-i-1]
	}
	for(i=0;i<20;i++)
cout<<"就地逆置完成\n"<<endl;

}
//要求以较高的效率实现删除顺序表中元素值在x到y(x和y自定)之间的所有元素。
void 	del_x_to_y(SqList &list){
	int x,y;
	printf("(x<y 空格分开x,y (x,y)区间里面的元素将会被删除)\n输入 x y :\n");
	scanf("%d %d",&x ,&y);
	printf("x=%d y=%d\n",x,y );
	int xplace,yplace;
	int i,j;
	for(i=0;list.data[i]<=x;i++);//i的位置就是第一个比x大的数字
	for(j=i;list.data[j]<y;){//会从第一个比x大的数字一直循环到刚好比y小的数字
		for(i=j;i<list.length;i++){//i前向后,做一次
			list.data[i]=list.data[i+1];
		}list.length--;
	}
}
//有序插入（显示比较次数、移动次数），
//   屏幕提示后，从键盘输入一个元素值，在经过排序的线性表list中插入这个元素
//   屏幕显示比较次数和移动次数，应有溢出判断和报告。
void insert_by_size(SqList &list){
	int compare_times=0,trans_times=0;//他们分别是比较次数、移动次数
	int x,i,xplace;
	if(list.length==10000)puts("Err:内存上限不能加入");
	puts("请输入你要插入的值");
	scanf("%d",&x);
	printf("你要插入的值=%d\n",x );
	for(i=0;i<list.length;i++){
	  compare_times++;
	  if(list.data[i]>=x)break;
	}  xplace=i;            //找到了的位置
	      for(i=list.length;i>=xplace;i--){
	        trans_times++;
	      list.data[i+1]=list.data[i];//每一个元素都向后平移
	    }
	    list.data[xplace]=x;
	      list.length++;//总长度减一
	  puts("有序插入已经完成了");
	  puts("press 1 to continue");
	    while(scanf("%d",&i )!=1);
}
//通过大量的自动操作，统计平均比较次数、平均移动次数。
//下面是超级魔改内容 将会占用上百行7
void init_statistics(SqList &list,int seed)//行数10000,使用15个不同的seed
{
	int i;
	while (1)
	{

	list.length=5000;
		if (list.length >= 0 && list.length <= max)
			break;
		cout << endl;
	}
	while (1)
	{
	     i=seed;
		if (i >= 0 && i <= 32767)
			break;
		cout << endl;
	}
	srand(i);  //指定随机数种子，相同的种子将产生相同的数据序列
	rand();

	for (i = 0; i < list.length; i++)
	{
		list.data[i] = rand() % 10000;
	}
	for (i = list.length; i < max; i++)
		list.data[i] = 0;
}
int simpleSort_times(SqList &list)
{
  int i,j,times=0,swaps=0,t;
printf("统计比较次数中..\n" );
for(i=0;i<list.length;i++)
  {for(j=i;j<list.length;j++){
    times++;
    if(list.data[i]>list.data[j]){
      swaps++;
  t=list.data[i];
      list.data[i]=list.data[j];
      list.data[j]=t;
    }
  }}
return times;
}
int simpleSort_swaps(SqList &list)
{
  int i,j,times=0,swaps=0,t;
printf("统计交换次数中...\n" );
for(i=0;i<list.length;i++)
  {for(j=i;j<list.length;j++){
    times++;
    if(list.data[i]>list.data[j]){
      swaps++;
  t=list.data[i];
      list.data[i]=list.data[j];
      list.data[j]=t;
    }
  }}
return swaps;
}

void statistics(SqList &list){
	int seed;
	int simpleSort_timesx[15];
	int simpleSort_swapsx[15];
	double timesx=0,swapsx=0,qs=0,qt=0;
	int quicksort_timesx[15];
	int quicksort_swapsx[15];
	for(seed=0;seed<15;seed++){//使用15个不同的seed
		init_statistics(list,seed);
		simpleSort_swapsx[seed]=simpleSort_swaps(list);
		simpleSort_timesx[seed]=simpleSort_times(list);
		quicksort_o(list,0,(list.length-1));
		quicksort_timesx[seed]=quicksort_times;
		quicksort_swapsx[seed]=quicksort_swaps;
	}
	for(seed=0;seed<15;seed++){
		timesx+=simpleSort_timesx[seed];
		swapsx+=simpleSort_swapsx[seed];
		qs+=quicksort_swapsx[seed];
		qt+=quicksort_timesx[seed];
	}
	timesx=timesx/15;
	swapsx=swapsx/15;
	qt=qt/15;
	qs=qs/15;
	puts("\n\n\n经过15次的随机种子length=5000的随机线性\n的简单排序结果如下:");
cout<<setw(6)<<"\n简单排序\n"<<"比较次数:"<<timesx <<"交换次数:"<<swapsx <<endl;
cout<<setw(6)<<"\n快速排序\n"<<"比较次数:"<<qt <<"交换次数:"<< qs<<endl;
	int i;
	puts("press 1 to continue");
		while(scanf("%d",&i )!=1);
}

如果vc6不能用 请自己加减合适的东西 那古董玩意如果还在用我推荐换一个。

这是迷你驱动

用来写新函数的时候 测试使用 测试没有问题 就直接复制函数到主程序里就肯定可以使用了 一般，，，

#include <iostream>
#include <iomanip>
#include <conio.h>
#include <stdio.h>
#include <process.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
using namespace std;
#define max 10000
struct SqList
{
	int data[max];         //存放元素的数组
	int length;            //当前长度
};
SqList list;
void init(SqList &list);
void display(SqList &list);

int quicksort_swaps=0,quicksort_times=0;

 void quicksort(SqList &list,int left,int right)
{ int*a;
 a=list.data;
    int i,j,t,temp;
    if(left>right)
       return;

    temp=a[left]; //temp中存的就是基准数
    i=left;
    j=right;
    while(i!=j)
    {
                   //顺序很重要，要先从右边开始找
                   while(a[j]>=temp && i<j)
                            {j--;quicksort_times++;}
                   //再找右边的
                   while(a[i]<=temp && i<j)
                            {i++;quicksort_times++;}
                   //交换两个数在数组中的位置
                   if(i<j)
                   {
                            t=a[i];
                            a[i]=a[j];
                            a[j]=t;
                   }
    }
    //最终将基准数归位
		quicksort_swaps++;
    a[left]=a[i];
    a[i]=temp;

    quicksort(list,left,i-1);//继续处理左边的，这里是一个递归的过程
    quicksort(list,i+1,right);//继续处理右边的 ，这里是一个递归的过程

}

int main()
{
  int bzre;
  list.length=20;
  for(bzre=0;bzre<20;bzre++){
    list.data[bzre]=10+bzre+2;
  }       //迷你驱动
	//init(list);
display(list);//快速显示检查错误

quicksort(list,0,(list.length-1));
cout<<"quicksort_times--比较次数"<<quicksort_times<<endl;
cout<<"quicksort_swaps--交换次数"<<quicksort_swaps<<endl;

puts("rrrrrrrrr-----rrrrrrrrrr");
display(list);//快速显示检查错误
}












//**********************************************************************************

void init(SqList &list)
{
	int i;
	while (1)
	{
	    cout << "输入元素个数（0－" << max << "）：" << flush;
		cin >> list.length;
		if (list.length >= 0 && list.length <= max)
			break;
		cout << endl;
	}
	while (1)
	{
	    cout << "输入随机数种子（0－32767）：" << flush;
		cin >> i;
		if (i >= 0 && i <= 32767)
			break;
		cout << endl;
	}
	srand(i);  //指定随机数种子，相同的种子将产生相同的数据序列
	rand();

	for (i = 0; i < list.length; i++)
	{
		list.data[i] = rand() % 10000;
	}
	for (i = list.length; i < max; i++)
		list.data[i] = 0;
}

void display(SqList &list)
{int i;
for(i=0;i<list.length;i++)
  {printf("[%5d]= %6d\n",(i+1),list.data[i]);}
}

Thank you for reading my essay.

"Kim"
关注
  • 7
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
数据结构暑期实训作业——顺序表操作
qq_43452776的博客
12-27 1489
一、顺序表操作 1、显示 2、插入 3、查找（显示比较次数） 4、删除（显示移动次数） 5、排序（普通、快速，显示比较次数、移动次数） 6、折半查找（显示比较次数） 7、编程实现一个顺序表的就地逆置，即利用原表的存储空间将顺序表逆置。 提高题： 8*、要求以较高的效率实现删除顺序表中元素值在x到y(x和y自定)之间的所有元素。 [解题思路] 在顺序表中设置两个初值为0的下标变量i和j，其中，i为...
数据结构——静态线性表操作（顺序表）
programmer1997的博客
03-21 1276
静态线性表 #define ListSize 100 //最大允许长度 typedef struct { ListData data[ListSize] ; //存储空间 int length; //当前元素个数 } SeqList; // 1. InitList(&amp;...
静态顺序表基本操作
summer初夏的博客
04-21 271
测试环境VS2013 seqlist.h #pragma once #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;assert.h&gt; #include &lt;malloc.h&gt; typedef int DataType; typedef struct ListNode { struct...
静态顺序表的基本操作
芮萌萌的博客
06-30 598
相关概念： 线性表：n（n&amp;amp;amp;amp;amp;amp;gt;=0）个数据元素组成的一个有限序列，可以在其任意位置上进行插入和删除操作的线性数据结构 从数据在物理内存存储形式上线性表分为：顺序表和链表 从上图可知： 线性表中的数据与数据之间存在一对一的关系，即除了第一个元素和最后一个元素之外，每个元素都有唯一的直接前驱和唯一的直接后继，第一个元素没有前驱，最后一个元素没有后继。 顺序表 用一段地址连续的存...
【数据结构】排序--快速排序
soybeen的博客
01-25 123
public static void quiteSort(int[] a, int low, int high) { if (low &gt; high) { return; } int privot = parttion(a, low, high); quiteSort(a, low, priv...
数据与算法课程：3 线性表.pdf
06-15
线性表的抽象数据类型（ADT）定义了它的一系列操作。数据对象D包含数据元素ai，它们属于同一个集合ElemSet，并按顺序排列。数据关系R表示相邻元素的关系，即ai和ai+1之间的关系。ADT LinearList包括以下基本操作： ...
数据结构作业：第2章-线性表作业题目.docx
12-16
"数据结构作业：第2章-线性表作业题目.docx" 在这份作业中，我们可以总结出以下几个...这份作业涵盖了线性表的基本概念、存储方式、操作、时间复杂度和应用等方面的知识点，为我们提供了一个系统的了解线性表的机会。
数据结构作业：第2章-线性表作业答案.docx
12-16
数据结构作业：第2章-线性表作业答案 本文将详细解释数据结构中的线性表概念，並通過多个选择题和问题，帮助读者深入理解线性表的存储方式、操作和特点。 一、线性表的定义 线性表是一种具有n个有限序列（n>0）的...
严蔚敏《数据结构》实验一：基于线性表的图书信息管理系统
最新发布
06-28
本资源为“严蔚敏《数据结构》实验一：基于线性表的图书信息管理系统”相关资源，其中包含有完整可运行的源代码，以及完整的实验报告。 适合正在学习《数据结构》课程的同学作为实验参考。
数据结构实验报告-实验：1线性表的顺序存储和操作实现.doc
10-12
实验中，我们通过main方法对这些操作进行了测试，包括向线性表中添加元素、删除元素、修改元素、获取元素值以及对线性表进行排序等操作，验证了Sequencelist类的正确性和功能完整性。 通过这次实验，我们不仅熟悉了...
数据结构实现下列函数：void InsertSort(SqList &L);
06-14
试以L.r[k+1]作为监视哨改写教材10.2.1节 中给出的直接插入排序算法。其中，L.r[1..k]为待排 序记录且k<MAXSIZE。 实现下列函数： void InsertSort(SqList &L);
顺序表操作（C语言）含注释
m0_62925086的博客
02-20 469
顺序表操作 1、显示 2、插入 3、查找（显示比较次数） 4、删除（显示移动次数） 5、排序（普通、快速，显示比较次数、移动次数） 6、折半查找（显示比较次数） 7、编程实现一个顺序表的就地逆置，即利用原表的存储空间将顺序表逆置。 8*、要求以较高的效率实现删除顺序表中元素值在x到y(x和y自定)之间的所有元素。 9*、编程实现将两个有序的顺序表进行合并，要求同样的数据元素只出现一次。 10*、有序插入（显示比较次数、移动次数）
【数据结构】——顺序表的基本操作
m0_64311080的博客
07-11 799
01 //(较简易)线性表：由n(n>=0)个数据特性相同的元素构成的有限序列。 顺序表：用顺序存储的方式实现线性表。 顺序存储：把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现。 顺序表特点： （1）随机访问； （2）存储密度高，每个节点只存储数据元素； （3）拓展容量不方便； （4）插入、删除操作不方便，需移动大量元素。 构造顺序表 按值查找 时间复杂度为O(n) ##按位查找 时间复杂度为O(1) 插入 时间复杂度为O(n) 删除 时间复杂度为O(n)
线性表（List） 一
蜗牛先生的博客
07-07 1576
线性表的基本概念，描述了线性表的抽象数据类型，八种基本操作组合成复杂的操作，线性表的顺序存储结构，数组实现，随机存取结构，可以直接根据数组的下标确定该元素的物理位置，查询操作很简单，但是插入和删除操作较为复杂，要移动数据元素来完成对应操作，例如插入是需要将该位置后面的元素向后移动一位，删除时需要将该位置后面的元素向前移动一位，最后指出顺序存储的优缺点。
P2==单链表操作== 实习作业
qq_41424132的博客
07-23 1809
由我自己写的单链表内容 下面是格式以及全部代码，随意使用吧！ #include &lt;iostream&gt; #include &lt;iomanip&gt; #include &lt;conio.h&gt; #include &lt;stdio.h&gt; #include &lt;process.h&gt; #include &lt;string.h&gt; #include &l...
P21例2-1 编程实现如下任务：建立一个线性表，首先依次输入数据元素1，2，3，...，10，然后删除数据元素5，最后依次显示当前线性表中的数据元素。假设该线性表的数据元素个数在最坏情况下不会超过1
AKK188888881的博客
10-08 5587
P21例2-1 编程实现如下任务：建立一个线性表，首先依次输入数据元素1，2，3，…，10，然后删除数据元素5，最后依次显示当前线性表中的数据元素。假设该线性表的数据元素个数在最坏情况下不会超过100个。要求使用顺序表。 头文件为：SeqList.h #include<stdio.h> #define MaxSize 100 typedef int DataType; typedef struct { DataType list[MaxSize]; int size; }SeqList
C语言数据结构--线性表(List)
SurpriseKuang的博客
11-06 2116
1.0 线性表 线性表头文件: #pragma once #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define INVALID_INDEX -1 // 存储空间初始分配量 #define LIST_INIT_SIZE 20 // 元素类型，假定是 int 类型。 typedef int elemType; typedef struct ListNode { // 容量 int capacity; /.
数据结构：线性表(List)【详解】
热门推荐
UniqueUnit的博客
02-18 11万+
线性表 一、线性表的定义 线性表（List）：零个或多个数据元素的有限序列。 线性表的数据集合为{a1,a2,…,an}，假设每个元素的类型均为DataType。其中，除第一个元素a1外，每一个元素有且只有一个直接前驱元素，除了最后一个元素an外，每一个元素有且只有一个直接后继元素。数据元素之间的关系是一对一的关系。 在较复杂的线性表中，一个数据元素可以由若干个数据项组成。在这种情况下，常把数据元素称为记录，含有大量记录的线性表又称为文件 二、线性表的顺序标识和实现 概念：用一组地址连续的存储单元依次存储
数据结构实验-线性表基本操作.pdf
11-12
"数据结构实验-线性表基本操作" 在计算机科学中，数据结构是一种组织和存储数据的方式，以便于高效地访问和操作数据。线性表是数据结构中的一种基本类型，指的是一个元素按线性顺序排列的集合。线性表可以通过顺序...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值