数据结构（严蔚敏）第二章部分算法设计题的实现

最新推荐文章于 2023-01-06 18:26:38 发布
最新推荐文章于 2023-01-06 18:26:38 发布
阅读量692 收藏 4
点赞数 1
分类专栏： Linear List
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Feynman1999/article/details/65632633
版权 
//2.17 2.18 单链表有无头结点的插入、删除比较  
#include<iostream>
#include<cstdio>
#include<stdlib.h>
#include<time.h> 
#define LIST_INIT_SIZE 20
using namespace std;

typedef int Elemtype;//用int示例

typedef struct Node
{
	Elemtype data;
	struct Node *next;
}Node;
typedef struct Node *LinkList;


//创建有头节点链表，尾插法 
Node *createlisthead(int n)//n个节点 
{
	LinkList L;
	LinkList p,q;//指向节点的指针p,q 
	int i;
	srand(time(0));//初始化随机数种子
	L=(LinkList )malloc(sizeof(Node));//头结点 
	q=L; //q要指向尾部 
	for(i=0;i<n;++i){
		p=(LinkList)malloc(sizeof(Node));
		p->data=rand()%1000+1;
		q->next=p;
		q=p;
	}
	q->next=NULL;
	return L;
}

void print1(LinkList L)//有头结点 
{
	LinkList p;
	printf("\nNow ,These records are:\n");
	p=L->next;
	if(p!=NULL)
	  do
	  {
	  	printf("%d ",p->data);
	  	p=p->next;
	  }while(p!=NULL);
	  cout<<endl;
} 

bool listheadinsert(LinkList &L,int i,Elemtype e)//含头结点  
{  
    int j;//计数器   
    LinkList p,q;  
    p=L;  
    j=1;  
    while(p&&j<i)  
    {  
        p=p->next;  
        ++j;  
    }  
    if(!p||j>i) return false;  
      
    //现在p指向第i-1个结点   
    q=(LinkList)malloc(sizeof(Node));//生成新的结点   
    q->data=e;  
    q->next=p->next;//先接上   
    p->next=q;//后断开，接到新的结点上
	return true;   
}  
  
bool listheaddelete(LinkList &L,int i,Elemtype &e)//含头结点 
{
	int j;
	LinkList p,q;
	p=L;
	j=1;//j为计数器
	while(p->next &&j<i)
	{
		p=p->next;
		++j;
	} 
	if(!(p->next)||j>i) return false;
	q=p->next;
	p->next=q->next;
	e=q->data;
	free(q);
	return true; 
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


//创建无头节点链表，尾插法 
Node *creat(int n)//无头结点 
{
	LinkList L;
	LinkList p,q;//指向节点的指针p,q 
	int i;
	srand(time(0));//初始化随机数种子
	//L=(LinkList )malloc(sizeof(Node)); //头结点 
	//q=L; //q要指向尾部 
	L=(LinkList)malloc(sizeof(Node));
	L->data=rand()%1000+1;
	q=L;
	for(i=0;i<n-1;++i){
		p=(LinkList)malloc(sizeof(Node));
		p->data=rand()%1000+1;
		q->next=p;
		q=p;
	}
	q->next=NULL;
	return L;
}

void print2(LinkList head)//无头结点输出 
{
	LinkList p;
	printf("\nNow ,These records are:\n");
	p=head;
	if(head!=NULL)
	  do
	  {
	  	printf("%d ",p->data);
	  	p=p->next;
	  }while(p!=NULL);
	cout<<endl;
}

bool insert(LinkList &L,int i,Elemtype e)//无头结点  
{  
    int j;//计数器   
    LinkList p,q;  
    p=L;  
    j=1;
	if(i==1){
		q=(LinkList)malloc(sizeof(Node));//生成新的结点  
		q->data=e;
		q->next=p;
		L=q;
		return true;
	}  
	else{
		i=i-1;
    while(p&&j<i)  
    {  
        p=p->next;  
        ++j;  
    }  
    if(!p||j>i) return false;  
      
    //现在p指向第i-1个结点   
    q=(LinkList)malloc(sizeof(Node));//生成新的结点   
    q->data=e;  
    q->next=p->next;//先接上   
    p->next=q;//后断开，接到新的结点上
	return true;   
	}
}  
  
bool del(LinkList &L,int i,Elemtype &e)//无头结点 
{
	int j;
	LinkList p,q;
	p=L;
	j=1;//j为计数器
	if(i==1){
		q=p;
		p=q->next;
		L=p;
		e=q->data;
		free(q);
		return true;
	} 
	else{
		i=i-1;
	while(p->next &&j<i)
	{
		p=p->next;
		++j;
	} 
	if(!(p->next)||j>i) return false;
	q=p->next;
	p->next=q->next;
	e=q->data;
	free(q);
	return true; 
	}
}

int main()
{
	int i,e;
	LinkList head1,head2;
	cout<<"有头结点"<<endl; 
	head1=createlisthead(LIST_INIT_SIZE);//有头结点
	cout<<"创建成功，下面打印"<<endl; 
	print1(head1);
	
	cout<<"下面进行插入,请输入要插入的位置和元素"<<endl;
	cin>>i>>e;
	if(listheadinsert(head1,i,e)){
		cout<<"成功插入在"<<i<<"位置上"<<endl;
		cout<<"现在的链表为";
		print1(head1);
	}
	else{
		cout<<"删除失败"<<endl;
	}
	
	cout<<"下面进行删除,请输入要删除的序号(<20)"<<endl;
	cin>>i;
	if(listheaddelete(head1,i,e)){ 
	cout<<"成功删除了"<<i<<"位置上的元素"<<e<<endl;
	cout<<"现在的链表为";
	print1(head1);
	}
	else{
		cout<<"删除失败"<<endl; 
	}
	
	cout<<endl<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;
	
	cout<<"无头结点"<<endl; 
	head2=creat(LIST_INIT_SIZE);//有头结点
	cout<<"创建成功，下面打印"<<endl; 
	print2(head2);
	
	cout<<"下面进行插入,请输入要插入的位置和元素"<<endl;
	cin>>i>>e;
	if(insert(head2,i,e)){
		cout<<"成功插入在"<<i<<"位置上"<<endl;
		cout<<"现在的链表为";
		print2(head2);
	}
	else{
		cout<<"删除失败"<<endl;
	}
	
	cout<<"下面进行删除,请输入要删除的序号(<20)"<<endl;
	cin>>i;
	if(del(head2,i,e)){ 
	cout<<"成功删除了"<<i<<"位置上的元素"<<e<<endl;
	cout<<"现在的链表为";
	print2(head2);
	}
	else{
		cout<<"删除失败"<<endl; 
	}
	
	return 0;	
}


//2.19 删除链表中指定区间的元素 
#include<iostream>
#include<cstdio>
#include<stdlib.h>
#include<time.h>
#include<algorithm> 
#define LIST_INIT_SIZE 20
using namespace std;

typedef int Elemtype;//用int示例

typedef struct Node
{
	Elemtype data;
	struct Node *next;
}Node;
typedef struct Node *LinkList;

int arr[LIST_INIT_SIZE];

Node *createlist(int n)//创建链表 
{
	LinkList L;
	LinkList p,q;//指向节点的指针p,q 
	int i;
	//srand(time(0));//初始化随机数种子
	L=(LinkList )malloc(sizeof(Node));//头结点 
	q=L; //q要指向尾部 
	for(i=0;i<n;++i){
		p=(LinkList)malloc(sizeof(Node));
		p->data=arr[i];
		q->next=p;
		q=p;
	}
	q->next=NULL;
	return L;
}

void print(LinkList L)//有头结点 
{
	LinkList p;
	printf("\nNow ,These records are:\n");
	p=L->next;
	if(p!=NULL)
	  do
	  {
	  	printf("%d ",p->data);
	  	p=p->next;
	  }while(p!=NULL);
	  cout<<endl;
} 

bool listdelete_L(LinkList &L,Elemtype mink,Elemtype maxk)
{
	LinkList p,q,prev=NULL;
	if(mink>maxk) return false;
	p=L;
	prev=p;
	p=p->next;
	while(p&&p->data<maxk){
		if(p->data<=mink){
			prev=p;
			p=p->next;
		}
		else{
			prev->next=p->next;
			q=p;
			p=p->next;
			free(q);
		}
	}
	return true;
}

//算法的时间复杂度为O(n) 
int main()
{
	LinkList head;
	Elemtype min,max;
	srand(time(0));
	for(int i=0;i<LIST_INIT_SIZE;++i){
		arr[i]=rand()%1000+1;
	}
	sort(arr,arr+LIST_INIT_SIZE);//构建递增元素
	head=createlist(LIST_INIT_SIZE);
	cout<<"现在的链表为 ";
	print(head);
	cout<<"现在我们删除链表中在min:"<<min<<"和max"<<max<<"之间的元素"<<endl;
	cout<<"请输入min和max(均为1000以内的整数)"<<endl;
	cin>>min>>max;
	if(listdelete_L(head,min,max)){
		cout<<"操作成功"<<endl; 
	}
	else{
		cout<<"操作失败，请检查min和max"<<endl;
	}
	cout<<"现在的链表为 ";
	print(head);
	return 0;
}

//2.20 删除链表中相同的元素 
#include<iostream>
#include<cstdio>
#include<stdlib.h>
#include<time.h>
#include<algorithm> 
#define LIST_INIT_SIZE 20
using namespace std;

typedef int Elemtype;//用int示例

typedef struct Node
{
	Elemtype data;
	struct Node *next;
}Node;
typedef struct Node *LinkList;

int arr[LIST_INIT_SIZE];

Node *createlist(int n)//创建链表 
{
	LinkList L;
	LinkList p,q;//指向节点的指针p,q 
	int i;
	//srand(time(0));//初始化随机数种子
	L=(LinkList )malloc(sizeof(Node));//头结点 
	q=L; //q要指向尾部 
	for(i=0;i<n;++i){
		p=(LinkList)malloc(sizeof(Node));
		p->data=arr[i];
		q->next=p;
		q=p;
	}
	q->next=NULL;
	return L;
}

void print(LinkList L)//有头结点 
{
	LinkList p;
	printf("\nNow ,These records are:\n");
	p=L->next;
	if(p!=NULL)
	  do
	  {
	  	printf("%d ",p->data);
	  	p=p->next;
	  }while(p!=NULL);
	  cout<<endl;
} 

void ListDelete_LSameNode(LinkList &L)
{
	LinkList p,q,prev;
	p=L;
	prev=p;
	p=p->next;
	while(p)
	{
		prev=p;
		p=p->next;
		if(p&&p->data==prev->data){
			prev->next=p->next;
			q=p;
			p=p->next;
			free(q);
		}
	}
}

//该算法的时间复杂度为O(n) 
int main()
{
	char c;
	LinkList head;
	srand(time(0));
	for(int i=0;i<LIST_INIT_SIZE;++i){
		arr[i]=rand()%30+1;
	}
	sort(arr,arr+LIST_INIT_SIZE);//构建递增元素
	head=createlist(LIST_INIT_SIZE);
	cout<<"现在的链表为 ";
	print(head);
	cout<<"现在我们删除链表中所有重复的元素"<<endl;
	cout<<"请点击字符s开始操作"<<endl; 
	cin>>c;
	ListDelete_LSameNode(head);
	cout<<"现在的链表为 ";
	print(head);
	return 0;
}

//2.21 顺序表的就地逆置 
#include<iostream>
#include<cstdio>
#include<stdlib.h>
#include<time.h>
#include<algorithm> 
#define LIST_INIT_SIZE 20
using namespace std;

typedef int Elemtype;//用int示例

typedef struct
{
	Elemtype data[LIST_INIT_SIZE];
	int length;
}SqList;

void listoppose_sq(SqList &L)
{
	int i;
	Elemtype x;
	for(int i=0;i<L.length/2;++i){
		x=L.data[i];
		L.data[i]=L.data[L.length-1-i];
		L.data[L.length-1-i]=x;
	}
}

void creat(SqList &L)
{
	srand(time(0));
	for(int i=0;i<L.length;++i){
		L.data[i]=rand()%1000+1;
	}
}

void print(SqList L)
{
	for(int i=0;i<L.length;++i){
		cout<<L.data[i]<<' ';
	}
	cout<<endl;
}

int main()
{
	char c;
	SqList stu;
	stu.length=LIST_INIT_SIZE;
	creat(stu);
	cout<<"初始的线性表为"<<endl;
	print(stu);
	cout<<endl<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;
	cout<<"下面我们对线性表就地逆置"<<endl;
	cout<<"请点击字符s开始操作"<<endl;
	cin>>c;
	listoppose_sq(stu);
	cout<<"现在的线性表为";
	print(stu);
	return 0;
}


//2.22 单链表就地逆置 
#include<iostream>
#include<cstdio>
#include<stdlib.h>
#include<time.h> 
#define LIST_INIT_SIZE 20
using namespace std;

typedef int Elemtype;//用int示例

typedef struct Node
{
	Elemtype data;
	struct Node *next;
}Node;
typedef struct Node *LinkList;

Node *createlist(int n)//n个节点 
{
	LinkList L;
	LinkList p,q;//指向节点的指针p,q 
	int i;
	srand(time(0));//初始化随机数种子
	L=(LinkList )malloc(sizeof(Node));//头结点 
	q=L; //q要指向尾部 
	for(i=0;i<n;++i){
		p=(LinkList)malloc(sizeof(Node));
		p->data=rand()%1000+1;
		q->next=p;
		q=p;
	}
	q->next=NULL;
	return L;
}

void print(LinkList L)//有头结点 
{
	LinkList p;
	printf("\nNow ,These records are:\n");
	p=L->next;
	if(p!=NULL)
	  do
	  {
	  	printf("%d ",p->data);
	  	p=p->next;
	  }while(p!=NULL);
	  cout<<endl;
}

void ListOppose_L(LinkList &L)
{
	LinkList p,q;
	p=L;
	p=p->next;
	L->next=NULL;
	while(p)
	{
		q=p;
		p=p->next;
		q->next=L->next;
		L->next=q;
	}
} 

int main()
{
	char c;
	LinkList head;
	srand(time(0));
	head=createlist(LIST_INIT_SIZE);
	cout<<"现在的链表为 ";
	print(head);
	cout<<endl<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;
	cout<<"下面我们对链表就地逆置"<<endl;
	cout<<"请点击字符s开始操作"<<endl; 
	cin>>c;
	ListOppose_L(head);
	cout<<"现在的链表为 ";
	print(head);
	return 0;
}

//2.23 合并两个单链表 
#include<iostream>
#include<cstdio>
#include<stdlib.h>
#include<time.h> 
//#define LIST_INIT_SIZE 20
using namespace std;

typedef int Elemtype;//用int示例

typedef struct Node
{
	Elemtype data;
	struct Node *next;
}Node;
typedef struct Node *LinkList;

Node *createlist(int n)//n个节点 
{
	LinkList L;
	LinkList p,q;//指向节点的指针p,q 
	int i;
	srand(time(0));//初始化随机数种子
	L=(LinkList )malloc(sizeof(Node));//头结点 
	q=L; //q要指向尾部 
	for(i=0;i<n;++i){
		p=(LinkList)malloc(sizeof(Node));
		p->data=rand()%1000+1;
		q->next=p;
		q=p;
	}
	q->next=NULL;
	return L;
}

void print(LinkList L)//有头结点 
{
	LinkList p;
	printf("\nNow ,These records are:\n");
	p=L->next;
	if(p!=NULL)
	  do
	  {
	  	printf("%d ",p->data);
	  	p=p->next;
	  }while(p!=NULL);
	  cout<<endl;
}

//将合并后的结果放到C表中，并删除B表 
void ListMerge_L(LinkList &A,LinkList &B,LinkList &C)
{
	LinkList pa,pb,qa,qb;
	pa=A->next;
	pb=B->next;
	C=A;
	while(pa&&pb)
	{
		qa=pa;  qb=pb;
		pa=pa->next; pb=pb->next;
		qb->next=qa->next;
		qa->next=qb;
	}
	if(!pa){
		qb->next=pb;
	}
	pb=B;
	free(pb); 
}

int main()
{
	char c;
	int n,m;
	LinkList head1,head2,head3;
	srand(time(0));
	cout<<"下面建立两个单链表，前输入他们的长度："<<endl;
	cin>>m>>n;
	head1=createlist(m);
	head2=createlist(n);
	cout<<"现在的链表为 "<<endl;
	print(head1);
	print(head2);
	cout<<endl<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;
	cout<<"下面我们对链表进行合并"<<endl;
	cout<<"请点击字符s开始操作"<<endl; 
	cin>>c;
	ListMerge_L(head1,head2,head3);
	cout<<"合并后的链表为 ";
	print(head3);
	return 0;
}


//2.24 归并升序的A表和B表并转为非递增放在C表中 
#include<iostream>
#include<cstdio>
#include<stdlib.h>
#include<time.h>
#include<algorithm> 
#define LIST_INIT_SIZE 20
using namespace std;

typedef int Elemtype;//用int示例

int arr[LIST_INIT_SIZE];

typedef struct Node
{
	Elemtype data;
	struct Node *next;
}Node;
typedef struct Node *LinkList;

Node *createlist(int n)//创建链表 
{
	LinkList L;
	LinkList p,q;//指向节点的指针p,q 
	int i;
	//srand(time(0));//初始化随机数种子
	L=(LinkList )malloc(sizeof(Node));//头结点 
	q=L; //q要指向尾部 
	for(i=0;i<n;++i){
		p=(LinkList)malloc(sizeof(Node));
		p->data=arr[i];
		q->next=p;
		q=p;
	}
	q->next=NULL;
	return L;
}

void print(LinkList L)//有头结点 
{
	LinkList p;
	printf("\nNow ,These records are:\n");
	p=L->next;
	if(p!=NULL)
	  do
	  {
	  	printf("%d ",p->data);
	  	p=p->next;
	  }while(p!=NULL);
	  cout<<endl;
} 

void ListMerge_L(LinkList &A,LinkList &B,LinkList &C)
{
	LinkList pa,pb,qa,qb;
	pa=A;
	pb=B;
	qa=pa; //保留pa的前驱指针 
	qb=pb; //保留pb的前驱指针 
	pa=pa->next;
	pb=pb->next;
	A->next=NULL;
	C=A;
	while(pa&&pb)
	{
		if(pa->data<pb->data){
			qa=pa;
			pa=pa->next;
			qa->next=A->next;//将当前最小节点插入A表表头 
			A->next=qa;
		}
		else{
			qb=pb;
			pb=pb->next;
			qb->next=A->next;//将当前最小节点插入A表表头 
			A->next=qb;
		}
	}
	while(pa)
	{
		qa=pa;
		pa=pa->next;
		qa->next=A->next;
		A->next=qa;
	}
	while(pb)
	{
		qb=pb;
		pb=pb->next;
		qb->next=A->next;
		A->next=qb;
	}
	pb=B;
	free(pb);
}

int main()
{
	char c;
	LinkList head1,head2,head3;
	srand(time(0));
	for(int i=0;i<LIST_INIT_SIZE;++i){
		arr[i]=rand()%1000+1;
	}
	sort(arr,arr+LIST_INIT_SIZE);//构建递增元素
	head1=createlist(LIST_INIT_SIZE);
	for(int i=0;i<LIST_INIT_SIZE;++i){
		arr[i]=rand()%1000+1;
	}
	sort(arr,arr+LIST_INIT_SIZE);
	head2=createlist(LIST_INIT_SIZE);
	
	cout<<"现在的两个链表为 "<<endl;
	print(head1);
	print(head2);
	
	cout<<endl<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;
	cout<<"下面我们对链表进行合并"<<endl;
	cout<<"请点击字符s开始操作"<<endl; 
	cin>>c;	
	ListMerge_L(head1,head2,head3);
	cout<<"合并后的链表为 ";
	print(head3);
	return 0;
}


Feynman1999
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
严蔚敏版《数据结构》第二章线性表的算法C语言实现
Mirror
09-30 8386
首先，今天是中秋，明天是国庆，在这说声节日快乐啊。 说点题外话，今天出去走了走，看到药店就进去称体重了。尼玛，竟然轻了4斤，本来就是100刚出头，现在倒好，直接掉下100了。我想这可能是因为最近天天熬夜，而且最近学校还规定天天要去早读（直接导致睡眠不足），直到过了英语4级。唉，大一时不能考，不知今年12月能否考过啊。所以说各位还要注意休息啊，记得要早点休息。昨天晚上就11点后就因为写这个代码直到
数据结构以及应用算法教程参考答案（2）第二章答案上
VAN
04-01 5852
第2章 线性表 2.1 描述以下三个概念的区别：头指针，头结点，首元结点（第一个元素结点）。 　　解：头指针是指向链表中第一个结点的指针。首元结点是指链表中存储第一个数据元素的结点。头结点是在首元结点之前附设的一个结点，该结点不存储数据元素，其指针域指向首元结点，其作用主要是为了方便对链表的操作。它可以对空表、非空表以及首元结点的操作进行统一处理。 2.2 填空题。 　　解：(1) 在顺序表中插入或删除一个元素，需要平均移动表中一半元素，具体移动的元素个数与元素在表中的位置有关。 (2) 顺序表中逻辑上相
《数据结构》（严蔚敏）算法代码实现第二章
suda_lv的博客
03-22 590
个人学习笔记 说明：代码由C++代码实现，但是和C语言基本一样。力求和课本一样，部分地方已处理，不足之处请指教。 #define LIST_INIT_SIZE 100//线性表存储空间的初始分配量 #define LISTINCREMENT 10//线性表存储空间的分配增量 typedef char ElemType; #define OK 1; #define NO 0; #de
单链表头插法函数LinkList List_HeadInsert(LinkList &L)中&L详解
weixin_43624310的博客
08-16 1527
因为地址的变化会导致free的时机难以把握，本文有助于读者掌握free时机
单链表的一些基本操作
m0_64000794的博客
11-25 302
单链表的一些基本操作
王道数据结构代码题--第一章线性表链表
李昂的博客
10-14 1716
1、核心代码 2、框架（定义参数） 第一章 线性表 将两个有序顺序表合并为一个新的有序表，由函数返回结果顺序表 1、从A的0开始不断和B的第一个元素比较，将较小的元素放入C中 2、如果某个数据已经遍历完成，则说明另外一个的数组剩余的都是最大的，将剩余的整体放入C中即可 bool Merge(SqList A,SqList B,SqList C) { if(A.length + B.length > C.length) { return false; } int i = 0,j = 0,k
C语言线性表实现：单链表
m0_53881899的博客
01-06 662
C语言线性表实现：单链表
《数据结构 C语言版|第2版 严蔚敏》算法设计题答案与书中算法源码版
08-06
本人对书中部分算法进行了优化，对参考答案中的所有错误均进行了纠正，对可能产生的bug及其触发条件、算法的不同实现方法或优化思路以及执行过程均进行了详细的说明。赠品为五本经典算法或数据结构书，链接在ReadMe....
数据结构第二版（清华严蔚敏版）数据结构习题答案
01-24
1、初次学习数据结构 2、考研学生的参考资料
数据结构严蔚敏C语言第二版习题答案（全）
01-05
数据结构严蔚敏C语言第二版习题答案（全）
数据结构（C语言版 第2版）课后习题答案 严蔚敏 编著
01-21
数据结构（C语言版 第2版）课后习题答案 严蔚敏 编著
数据结构算法实现（严蔚敏版配套实现程序）
02-03
1.1 数组和字符串 2 1.1.1 一维数组的倒置 2 范例1-1 一维数组的倒置 2 ∷相关函数：fun函数 1.1.2 一维数组应用 3 范例1-2 一维数组应用 3 1.1.3 一维数组的高级应用 5 范例1-3 一维数组的高级应用 5 ...
严蔚敏数据结构算法设计习题程序和答案
12-08
严蔚敏数据结构算法设计习题答案，蛮好的，答案也很详细
线性表算法设计
01-27
数据结构中线性表部分的习题以及答案，其中算法的主要实现是通过C++程序来的
数据结构第二章（单链表部分）学习笔记
qq_62175345的博客
04-05 3931
线性表---单链表部分 1、知识承接 顺序表可以随时存取表中的任意一个元素，它的存储位置可以用一个简单直观的公式来表示。但效率低插入和删除操作需要移动大量的元素。临时扩大存储空间有困难，存储分配只能预先进行必须占用地址连续的内存空间 . 链式存储线性表时，不需要使用地址连续的存储单元，即不要求逻辑上相邻的元素在物理位置上也相邻，它通过“链”建立起数据元素之间的逻辑关系，因此插入和删除操作不需要移动大量的元素，只需要修改指针，但也会失去顺序表可以随机存取的优点。 单链表 链表： 通过一组任意的
java练习题13.txt
最新发布
04-18
java练习题
云南省移动应用大赛模板.zip
04-18
云南省移动应用大赛模板.zip
HTML5基于SSM校园微公益网站设计可升级SpringBoot源码.7z
04-18
前台技术框架采用Bootstrap，一个高度灵活的HTML5响应式框架，为用户提供了流畅的前端交互体验。程序开发环境支持多样化，无论是myEclipse、Eclipse还是Idea都能轻松应对，结合mysql数据库，确保了数据的高效处理与存储。后台架构则选用SSM组合——SpringMVC、Spring和Mybatis，这一组合以其稳定性和高效性而备受青睐。 校园公益信息关联系统采用b/s架构，实现用户信息、活动类型、公益活动、活动报名、捐款、捐款统计、留言和新闻信息的全面管理。系统分为前台学生端和后台管理员端，满足不同用户群体的需求。 管理员端功能丰富，包括学院管理、活动类型管理、公益活动管理、活动报名管理、捐款信息管理、管理员账号管理、密码修改、捐款统计管理、留言管理和新闻信息管理等。管理员能够灵活添加、修改、删除和查询各类信息，确保信息的准确性和时效性。同时，捐款统计功能以直观的统计图形式展现，为管理员提供决策支持。 学生端则专注于学生的日常需求，包括添加捐款信息、留言、报名活动以及密码修改等。学生可以轻松完成捐款操作，发表留言，查看并报名公益活动，随时修改个人密码，确保账
JavaWeb程序设计SSM框架选课系统开发大作业有数据库文
04-18
JavaWeb程序设计SSM框架选课系统开发大作业有数据库文
数据结构第二章习题严蔚敏
10-22
数据结构第二章习题主要涉及线性表的基本概念、顺序表、链表、栈和队列等内容。以下是习题的一些例子： 1. 什么是线性表？线性表有哪些基本操作？ 2. 什么是顺序表？如何实现顺序表的插入和删除操作？ 3. 什么是...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值