线性表练习题

最新推荐文章于 2023-08-01 17:15:31 发布
原创 最新推荐文章于 2023-08-01 17:15:31 发布 · 970 阅读 · 9 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构

线性表练习题

顺序表与单链表对比

题目

请说明顺序表和单链表有何优缺点，并分析下列情况采用何种存储结构更好些。
①若线性表的总长度基本稳定，且很少进行插入和删除，但要求以最快的速度存取线性表中的元素。
②如果n个线性表同时并存，并且在处理过程中各表的长度会动态发生变化。

答案

顺序表：

  • 优点：
    1.无需为表示表中元素之间的逻辑关系而增加额外的存储空间
    2.随机存取：可以快速存取表中任一位置的元素
  • 缺点：
    1.表的容量难以确定，表的容量难以扩容
    2.插入和删除操作需要移动大量元素

单链表：

  • 优点：
  • 缺点：

①顺序表
②单链表

顺序表有序插入

题目

已知顺序表L中的元素递增有序排列，设计算法将元素x插入到表L中并保持表L仍递增有序。

代码

#include <iostream>

using namespace std;
const int MaxSize=100;
using namespace std;
template<class T>
class SeqList{
private:
    int length;
    T data[MaxSize];
public:
    SeqList(){}
    SeqList(T data[],int length);
    ~SeqList(){}
    int getLength();
    T get(int i);
    int getIndex(T x);
    void Insert(T x,int i);
    T Delete(int i);
    int isEmpty();
    void printList();
};
template<class T>
SeqList<T>::SeqList(T d[],int length){
    this->length=length;
    for(int i=0;i<length;i++)
        data[i]=d[i];
}
template<class T>
int SeqList<T>::getLength(){
    return length;
}
template<class T>
T SeqList<T>::get(int i){
    if(i<1||i>length)
        throw"查找位置非法";
    return data[i-1];
}
template<class T>
int SeqList<T>::getIndex(T x){
    for(int i=0;i<length;i++){
        if(data[i]==x)
            return i+1;
    }
    return -1;
}
template<class T>
void SeqList<T>::Insert(T x,int i){
    //注意检查操作合法性
    if(length==MaxSize) throw"上溢";
    if(i<1||i>length+1) throw"插入位置错误";
    for(int j=length;j>=i;j--){
        data[j]=data[j-1];
    }
    data[i-1]=x;
    length++;
}
template<class T>
T SeqList<T>::Delete(int i){
    T x;
    //注意检查操作合法性
    if(length==0) throw"下溢";
    if(i<1||i>length) throw"删除位置错误";
    x=data[i-1];
    for(int j=i;j<length;j++){
        data[j-1]=data[j];
    }
    length--;
    return x;
}
template<class T>
int SeqList<T>::isEmpty(){
    return length==0?1:0;
}
template<class T>
void SeqList<T>::printList(){
    for(int i=0;i<length;i++){
        cout<<i+1<<":"<<data[i]<<endl;
    }
}
int main()
{
    int a[9]={0,1,2,4,5,6,7,8,9};
    SeqList<int> sl(a,9);
    int x=3,i=1;
    while(sl.get(i)<=x){
        i++;
    }
    sl.Insert(x,i);
    sl.printList();
    return 0;
}

就地逆置

题目

试分别以顺序表和单链表作存储结构，各编写一个实现线性表就地逆置的算法。

代码

顺序表

const int MaxSize=10;    //10只是示例性的数据，可以根据实际问题具体定义
class SeqList
{
public:
   SeqList( ){length=0;}       //无参构造函数，创建一个空表
   SeqList(int a[ ], int n);       //有参构造函数
   void Insert(int i, int x);   //在线性表中第i个位置插入值为x的元素
   int Delete(int i);        //删除线性表的第i个元素
   int Locate(int x);       //按值查找，求线性表中值为x的元素序号
   void Reverse();
   void PrintList( );      //遍历线性表，按序号依次输出各元素
private:
   int data[MaxSize];      //存放数据元素的数组
   int length;            //线性表的长度
};

SeqList::SeqList(int a[ ], int n)
{
      if (n>MaxSize) throw "参数非法";
      for (int i=0; i<n; i++)
        data[i]=a[i];
      length=n;
}

void SeqList::Insert(int i, int x)
{
      if (length>=MaxSize) throw "上溢";
      if (i<1 || i>length+1) throw "位置非法";
      for (int j=length; j>=i; j--)
        data[j]=data[j-1];   //注意第j个元素存在数组下标为j-1处
      data[i-1]=x;
      length++;
}

int SeqList::Delete(int i)
{
      if (length==0) throw "下溢";
      if (i<1 || i>length) throw "位置非法";
      int x=data[i-1];
      for (int j=i; j<length; j++)
        data[j-1]=data[j];   //注意此处j已经是元素所在的数组下标
      length--;
      return x;
}

int SeqList::Locate(int x)
{
      for (int i=0; i<length; i++)
        if (data[i]==x)  return i+1 ;  //下标为i的元素等于x，返回其序号i+1
      return 0;  //退出循环，说明查找失败
}

void SeqList::Reverse(){
    int temp;
    for(int i=0;i<length>>1;i++){
        temp=data[i];
        data[i]=data[length-i-1];
        data[length-i-1]=temp;
    }
}

void SeqList::PrintList( )
{
  for (int i=0; i<length; i++)
	cout<<data[i]<<"  ";
  cout<<endl;
}

单链表
利用头插法进行单链表的逆置

#include <iostream>
using namespace std;

template<class T>
struct Node
{
	T data;
	Node<T> *next;
};

template<class T>
class LinkList
{
public:
	LinkList();
	LinkList(T a[], int n);
	~LinkList();
	void PrintList();
	T Get(int i);
	void Insert(int i, T x);
	void Delete(int i);
public:
	Node<T> *first;
};

template<class T>
LinkList<T>::LinkList()
{
	first=new Node<T>;
	first->next=NULL;
}

template<class T>
LinkList<T>::LinkList(T a[], int n)
{
	first=new Node<T>;
	Node<T> *r=first;
	for(int i=0;i<n;i++)
	{
		Node<T> *s=new Node<T>;
		s->data=a[i];
		r->next=s;
		r=s;
	}
	r->next=NULL;
}

template<class T>
LinkList<T>::~LinkList()
{
	while(first!=NULL)
	{
		Node<T> *q=first;
		first=first->next;
		delete q;
	}
}

template<class T>
void LinkList<T>::PrintList()
{
	Node<T> *p=new Node<T>;
	p=first->next;
	while(p!=NULL)
	{
		cout<<p->data<<" ";
		p=p->next;
	}
}

template<class T>
T LinkList<T>::Get(int i)
{
	Node<T> *p=first->next;
	int count=1;
	while(p!=NULL&&count<i)
	{
		p=p->next;
		count++;
	}
	if(p==NULL) throw "查找位置异常";
	else return p->data;
}

template<class T>
void LinkList<T>::Insert(int i, T x)
{
	Node<T> *p=first;
	int count=0;
	while(p!=NULL&&count<i-1)
	{
		p=p->next;
		count++;
	}
	if(p==NULL) throw "插入位置异常";
	else
	{
		Node<T> *s=new Node<T>;
		s->data=x;
		s->next=p->next;
		p->next=s;
	}
}

template<class T>
void LinkList<T>::Delete(int i)
{
  Node<T> *p;
  int j;
  p=first ; j=0;  //工作指针p初始化
  while (p!=NULL && j<i-1)  //查找第i-1个结点
  {
    p=p->next;
    j++;
  }
  if (p==NULL || p->next==NULL) throw "删除位置异常";  //结点p不存在或结点p的后继结点不存在
  else {
    Node<T> *q;
	T x;
    q=p->next; x=q->data;  //暂存被删结点
    p->next=q->next;  //摘链
    delete q;
  }
}
template<class T>
void Rerverse(Node<T> *first){
    //从链表的第二个元素开始摘，然后头插入链表中
    Node<T> *p=first->next,*s=NULL;
    if(p==NULL) throw "空表";
    if(p->next==NULL) return;
    while(p->next!=NULL){
        s=p->next;
        p->next=s->next;

        s->next=first->next;
        first->next=s;

    }
}
template<class T>
Node<T>* Copy(Node<T> *oFirst){
    Node<T> *p=oFirst->next;
    Node<T> *nFirst=new Node<T>;
    Node<T> *s=nFirst;
    Node<T> *t=NULL;

    while(p!=NULL){
        t=new Node<T>;
        t->data=p->data;

        s->next=t;
        s=s->next;

        p=p->next;
    }
    t->next=NULL;
    return nFirst;
}
int main()
{
	int a[]={1,2,3,4,5};
    LinkList<int> test(a,5);
	cout<<"线性表a的初始状态："<<endl;
	test.PrintList();

	cout<<endl<<"复制线性表a到线性表p,再逆置线性表a。"<<endl;
	Node<int> *p=new Node<int>;
	p=Copy(test.first)->next;
    Rerverse(test.first);

	cout<<"线性表a的状态："<<endl;
	test.PrintList();

	cout<<endl<<"线性表p的状态："<<endl;
	while(p!=NULL)
	{
		cout<<p->data<<" ";
		p=p->next;
	}

	return 0;
}

删除有序单链表某区间元素

题目

已知单链表中各结点的元素值为整型且递增有序，设计算法删除链表中大于mink且小于maxk的所有元素，并释放被删除结点的存储空间。

代码

#include <iostream>

using namespace std;
template<class T>
struct Node{
    T data;
    Node<T> *next;
};
template<class T>
class LinkList{
public:
	LinkList();
	LinkList(T a[],int n);
	~LinkList();
	int Length();
	T Get(int i);
	void Set(int i,T x);
	int Locate(T x);
	void Insert(int i,T x);
	T Delete(int i);
	int Empty();
	void PrintList();
private:
    Node<T> *first;
};
template<class T>
LinkList<T>::LinkList(){
    first=new Node<T>;
    first->next=nullptr;
}
template<class T>
LinkList<T>::LinkList(T a[],int n){
    //头插法
    /*
    first=new Node<T>;
    first->next=nullptr;
    for(int i=0;i<n;i++){
        Node<T> *p=nullptr;
        p=new Node<T>;
        p->data=a[i];
        p->next=first->next;
        first->next=p;
    }
    */

    //尾插法
    first=new Node<T>;
    Node<T> *p=first,*s=nullptr;
    for(int i=0;i<n;i++){
        s=new Node<T>;
        s->data=a[i];
        p->next=s;
        p=s;
    }
    p->next=nullptr;
}
template<class T>
LinkList<T>::~LinkList(){
    Node<T> *p=nullptr;
    while(first!=nullptr){
        p=first;
        first=first->next;
        delete p;
    }
}
template<class T>
int LinkList<T>::Length(){
    int cnt=1;
    Node<T> *p=first->next;
    while(p->next!=nullptr){
        cnt++;
        p=p->next;
    }
    return cnt;
}
template<class T>
T LinkList<T>::Get(int i){
    int cnt=1;
    Node<T> *p=first->next;
    while(cnt<i&&p!=nullptr){
        p=p->next;
        cnt++;
    }
    //别漏了还有异常这种情况
    if(p==nullptr) throw"查找位置错误";
    else return p->data;
}
template<class T>
int LinkList<T>::Locate(T x){
    Node<T> *p=first->next;
    int pos=1;
    while(p!=nullptr){
        if(p->data==x)  return pos;
        p=p->next;
        pos++;
    }
    return 0;
}
template<class T>
void LinkList<T>::Insert(int i,T x){
    Node<T> *p=first;
    int cnt=0;
    //要将数据插入到第i个位置，就要找到第i-1个位置再做插入操作
    while(cnt<i-1&&p!=nullptr){
        p=p->next;
        cnt++;
    }
    if(p==nullptr)  throw"插入位置有误";
    else{
        Node<T> *s=new Node<T>;
        s->next=p->next;
        s->data=x;
        p->next=s;
    }

}
template<class T>
T LinkList<T>::Delete(int i){
    Node<T> *p=first;
    int cnt=0;
    //要删除第i个元素，就要找到第i-1个位置，再做删除操作
    while(cnt<i-1&&p!=nullptr){
        p=p->next;
        cnt++;
    }
    //p->next==nullptr：p不存在后继结点
    if(p==nullptr||p->next==nullptr)  throw"删除位置有误";
    else{
        Node<T> *s=p->next;
        T data=s->data;
        p->next=s->next;
        delete s;
        return data;
    }

}
template<class T>
int LinkList<T>::Empty(){
    if(first->next==nullptr)
        return 1;
    return 0;
}
template<class T>
void LinkList<T>::PrintList(){
    Node<T> *p=first->next;
    while(p!=nullptr){
        cout<<p->data<<endl;
        p=p->next;
    }
}
template<class T>
void LinkList<T>::Set(int i,T x){
    int cnt=1;
    Node<T> *p=first->next;
    while(cnt<i&&p!=nullptr){
        p=p->next;
        cnt++;
    }
    if(p==nullptr) throw"位置错误";
    else{
        p->data=x;
    }
}
int main()
{
    int a[10]={1,2,3,4,5,6,7,8,9,10};
    LinkList<int> ll(a,10);
    int mink=4,maxk=9;
    int i=1;
    while(ll.Get(i)<=mink){
        i++;
    }
    while(ll.Get(i)<maxk){
        ll.Delete(i);
    }
    ll.PrintList();
    return 0;
}
线性表练习题超详细解答
纸城的博客
03-26 777
天才亦是众生，众生皆怀其才。 链表练习： 1有一个带头结点的单链表L，设计一个算法使其元素递增有序。 算法思想：用直接插入排序的方法，将链表分成两部分，每次取后部分一个元素插入前部分正确的位置上。 void sort(LinkList &L) {//本算法实现将一个链表元素升序排列 if(L==NULL) return; LNode *pre,*p=...
数据结构的线性表习题
10-28
关于数据结构的绪论和线性表的练习题，希望对大家有帮助。15．分析：首先在链表中查找元素值为X的结点，若找到则让freq域的值增1；然后 依次和它的前趋的freq域值比较，若比前freq域值大，和前趋结点位置交换，直到比 前趋结点的freq域值小为止。 Typedef struct dfnode *dfpointer; Struct dfnode {datatype data; int freq; dfpointer prior,next; } typedef dfpointer dflklist; 设该双链表含头结点。 Int LOCATE_dflklist(dflklist L,datatype X) {/*定位值等于X的结点*/ p=L->next; I=1; while ((p!=null)&&(p->data!=X)) {o=p->next; I++;} if ((p->data!=X||(p= = null)) error(“不存在值为X的结点 ”); else { p->freq++; /*令元素值为X的结点中freq域的值增1*/ q=p->prior; while((q!= L)&&(q->freqfreq)) {I=I-1; p->prior->next=p->next; /*摘除p*/ p->next->prior=p->prior; q->prior-prior=q->prior; p->next=q; q->prior=p; q=p->prior; /*q重新指向p的前趋*/ } return(i); }
线性表的习题
03-30
对于线性表的学习，需要习题来巩固基础，这是一套能帮你解决这个问题的习题
线性表练习题4
weixin_33858485的博客
04-02 296
题目描述： 从顺序表中，删除其值在s与t之间（包含s和t，要求s<t)的所有元素，如果s或t不合理或者顺序表为空则显示出错信息并推出运行。 分析： 这个题目的解决方法和线性表练习题2的解题思路基本一样，可以解决方法有两个，都很容易理解，并且时间复杂度和空间复杂度都不大。 “线性表练习题2”是要求删除值等于x的元素，而该题目要求的是删除介于s和t之间的元素，所以只是...
【数据结构】——线性表的相关习题
小宇y的博客
08-01 3270
若将删除结点 * p的操作转换为删除结点 * p的后继结点来实现，将下一个结点的指针域指向上一个结点，在交换数据域后，将* q结点从单链表中断开并释放该结点即可，这样的时间复杂度为O(1)。，也是将新结点的指针域指向下一个结点，该结点与前一个结点连接，然后通过一个中间变量将上一个结点的数据域与该结点交换即可，从而使时间复杂度达到。3、在单链表中删除第i个结点的时间复杂度为（），若将删除结点 * p的操作转换为删除结点 * p的后继结点来实现，其时间复杂度为（）。时，则该双链表为空。
精选资源
数据结构线性表练习题试卷及答案.doc
10-06
数据结构线性表练习题试卷及答案 本资源是数据结构领域的线性表练习题试卷及答案，涵盖了顺序存储、链式存储、静态链表、单链表、双链表、单循环链表、带头结点的双循环链表、带尾指针的单循环链表等概念。 知识点...
数据结构与算法-副本线性表练习题 定义线性表节点的结构.ppt
04-18
数据结构与算法-副本线性表练习题 定义线性表节点的结构.ppt
数据结构 线性表 练习题 试卷及答案.doc
10-06
线性表作为数据结构中的一种基础数据类型，它以一种简单直观的形式存在于我们的日常学习和工作中。无论是顺序存储结构还是链式存储结构，都是实现线性表的两种不同方式，它们各自具有不同的特点和适用场景。在深入...
精选资源
数据结构线性表练习题答案.doc
04-02
数据结构
线性表练习题3
weixin_33929309的博客
03-21 191
题目描述： 从有序顺序表中，删除其值在s与t之间（要求s<t)的所有元素，如果s或t不合理或者顺序表为空则显示出错信息并推出运行。 程序分析： 类似练习题2：http://blog.youkuaiyun.com/qsyzb/article/details/21726769 我们仍然可以使用类似的方法解决，但是要注意这里的是有序的顺序表，所以值在s与t之间的数应该是连续的。 ...
数据结构（第二版）严蔚敏第二章线性表练习题及答案
＃两个西柚
07-16 6976
第2章 线性表 1．选择题 （1）顺序表中第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是（ ）。 A．110 B．108 C．100 D．120 答案：B 解释：顺序表中的数据连续存储，所以第5个元素的地址为：100+2*4=108。 （2）在n个结点的顺序表中，算法的时间复杂度是O(1)的操作是（ ）。 A．访问第i个结点（1≤i≤n）和求第i个结点的直接前驱（2≤i≤n） B．在第i个结点后插入一个新结点（1≤i≤
线性表习题一
dongyanxia1000的专栏
07-26 819
1、已知一个带表头结点的单链表，结点的结构为(data,link)。假设该链表只给出了表头指针list，在不改变链表的前提下请设计一个 尽可能有效的算法，查找链表中倒数第k个位置上的结点（k为正数）。若查找成功，算法输出该结点的data域的值，并返回1，否则 只返回0.要求： （1）描述该算法的基本设计思想； （2）描述该算法的详细实现步骤； （3）根据算法的基本设计思想和详细实现步骤，
【数据结构线性表练习题】
爱喝阔落的猫的博客
07-18 1189
代码】【数据结构线性表练习题】
第2章——线性表习题
wyg1997
09-17 846
（1）依次取两个链表的节点，把小的接过去，依次往后，直到一个链到尾部。把另一个链接上去就行了。 typedef struct Lnode { double num; Lnode *next; }Lnode,*LinkList; void ListMerge(LinkList a,LinkList b) //合并a、b有序链表并存到 a { LinkList p,q; LinkLis
02线性表(习题部分)
will5451的博客
08-20 690
综合应用    
线性表题目
weixin_63233998的博客
02-14 1846
线性表题目
线性表的各种题目，操作。
fatal360的专栏
11-14 546
1.有一个单链表的第一个节点指针为head，编写一个函数将该单链表逆置，即最后一个节点编程第一个节点，原来倒数第二个节点变成第二个节点，如此等等，在逆置中不能建立新的单链表。这里有两种方法，1、第一种是换数，即指针不变，只是用temp做中间变量，用temp=a；a=b；b=temp；形式把数换了。2、第二种时把指针换为逆向指针。 实现： # include # include "s
线性表练习题2
weixin_34401479的博客
03-21 447
题目要求： 长度为n的顺序表L，编写一个时间复杂度为O(n)、空间复杂度为O(1)的算法，该算法删除线性表中所有值为x的数据元素。 算法分析： 设置两个计数器，一个为i，记录扫描过的元素的个数；一个为j，记录扫描过的非x的元素的个数。从1~n对所有的元素进行扫描，如果该元素不是x，则i++,j++并令i对应的元素赋给j；如果该元素是x，i++，j不变，并将i对应的元素赋给...
数据结构线性表练习题
09-10
数据结构线性表练习题涵盖了多个题型，包括线性表的存储结构、链表的判空、单链表的建立、顺序表和单链表的插入删除操作、双链表的插入删除操作以及循环链表。其中，一道题目是关于对具有n个元素的线性表建立单链表...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值