链表题目

7-8 单向链表3 (10 分)

编程实现：输入一个正整数 repeat (0<repeat<10)，做 repeat 次下列运算：

输入一个正整数 n(0<n<=9)和一组(n个)升序的整数，建立单向链表，再输入一个整数 x，把 x 插入到这组数据中，使该组数据仍然有序。

输入输出示例：括号内为说明

输入样例:

4               (repeat=4) 
5               (数据的个数n=5)
1 2 4 5 7       (5个有序整数)
3               (待插入整数x=3)
4               (数据的个数n=4)
1 2 5 7	        (4个有序整数)
-10             (待插入整数x=-10)
3               (数据的个数n=3)
1 2 4	        (3个有序整数)
100             (待插入整数x=100)
5               (数据的个数n=5)
1 2 4 5 7       (5个有序整数)
4               (待插入整数x=4)

输出样例:

size=6:1 2 3 4 5 7 
size=5:-10 1 2 5 7 
size=4:1 2 4 100 
size=6:1 2 4 4 5 7

#include<iostream>
using namespace std;
struct Node{
	int data;
	struct Node *next;
};
struct Node *Create(int n)
{
	Node *p=NULL,*q=NULL,*head=NULL;
	for(int i=0;i<n;i++)
	{
		q=new Node;//新建一个Node给q
		q->next=NULL;//先让它的next为NULL，比较安全
		cin>>q->data;
		if(head==NULL)
		{
			head=p=q;//让三个指针都先指向第一个Node 
		}
		else
		{
			p->next=q;//q起到的作用就是把链表串起来
			p=q;//将p移到链表的下一个位置上，以便下一次的串联 
		}
	}
	return head;//返回头节点 
}
struct Node *Insert(Node *head,int x)//插入数x 
{
	Node *p,*q;
	int flag=0;
	p=head;
	if(head==NULL) return head;
	q=new Node;
	q->data=x;
	q->next=NULL;
	if(p->data>x)//如果x的值小于链表中的第一个数 
	{
		q->next=p;
		head=q;//如果替换了第一个数，记得要修改头节点
		return head; 
	} 
	while(p->next!=NULL)
	{
		if(p->data<=x&&p->next->data>x)
		{
			q->next=p->next;
			p->next=q;
			flag=1;
			break;
		}
		p=p->next;//指向下一个，往下一项移动 
	}
	if(flag==0)
		p->next=q;
	return head;
}
int main()
{
	int repeat;
	cin>>repeat;
	Node *head,*p;
	for(int i=0;i<repeat;i++)
	{
		int n;
		cin>>n;
		int b;
		head=Create(n);	
		cin>>b;
		head=Insert(head,b);
		p=head;
		cout<<"size="<<n+1<<":";
		cout<<p->data;
		p=p->next;
		while(p!=NULL)
		{
			cout<<" "<<p->data;
			p=p->next;
		}
        cout<<endl;
}
	return 0;
}

7-12 单链表基本操作 (5 分)

请编写程序实现单链表插入、删除结点等基本算法。给定一个单链表和一系列插入、删除结点的操作序列，输出实施上述操作后的链表。单链表数据域值为整数。

输入格式:

输入第1行为1个正整数n，表示当前单链表长度；第2行为n个空格间隔的整数，为该链表n个元素的数据域值。第3行为1个正整数m，表示对该链表施加的操作数量；接下来m行，每行表示一个操作，为2个或3个整数，格式为0 k d或1 k。0 k d表示在链表第k个结点后插入一个数据域值为d的结点，若k=0则表示表头插入。1 k表示删除链表中第k个结点，此时k不能为0。注：操作序列中若含有不合法的操作（如在长度为5的链表中删除第8个结点、删除第0个结点等），则忽略该操作。n和m不超过100000。

输出格式:

输出为一行整数，表示实施上述m个操作后的链表，每个整数后一个空格。输入数据保证结果链表不空。

输入样例:

5
1 2 3 4 5
5
0 2 8
0 9 6
0 0 7
1 0 
1 6

输出样例:

7 1 2 8 3 5 

#include<iostream>
using namespace std;
struct Node{
	int data;
	struct Node *next;
};
struct Node *Create(int n)//创建链表
{
	Node *p=NULL,*q=NULL,*head=NULL;
	for(int i=0;i<n;i++)
	{
		q=new Node;//新建一个Node给q
		q->next=NULL;//先让它的next为NULL，比较安全
		cin>>q->data;
		if(head==NULL)
		{
			head=p=q;//让三个指针都先指向第一个Node 
		}
		else
		{
			p->next=q;//q起到的作用就是把链表串起来
			p=q;//将p移到链表的下一个位置上，以便下一次的串联 
		}
	}
	return head;//返回头节点 
}

struct Node *Insert(Node *head,int k,int b)//在链表第k个节点后插入一个数值为d的节点 
{
	Node *p,*q;
	p=head;
	if(head==NULL) return head;
	q=new Node;
	q->data=b;
	q->next=NULL;
	if(k==0)
	{
		q->next=p;
		head=q;
		return head;
	}
	if(k!=0)
	{
		for(int i=1;i<k;i++)
			p=p->next;
		q->next=p->next;
		p->next=q;
		return head;
	}
}

struct Node *Delete(Node *head,int k)//删除某个节点 
{
	Node *p;
	p=head;
	if(head==NULL) return head;
	if(k==1)
	{
		p=p->next;
		head=p;
		return head;
	}
	else
	{
		while(k-2)
		{
			p=p->next;
			k--;
		}
		p->next=p->next->next;
		return head;
	}
}
int main()
{
	int n;
	Node *p,*head;
	cin>>n;//为单链表的长度
	head=Create(n);
	int m;//为对链表的操作数量
	cin>>m;
	int count=n; 
	for(int i=0;i<m;i++)
	{
		int a;
		cin>>a;
		if(a==0)
		{
			int k,b;
			cin>>k>>b;
			if(k>count)
				continue;
			count++;
			head=Insert(head,k,b);
			p=head;
		}
		else if(a==1)
		{
			int k;
			cin>>k;
			if(k>count||k==0)
				continue;
			count--;
			head=Delete(head,k);
			p=head;
		}
	}
	p=head;
	while(p!=NULL)
		{
			cout<<p->data<<" ";
			p=p->next;
		} 
} 

7-13 链表操作-插入、查找和删除 (100 分)

请编写创建链表和输出链表的函数。对于以下数据结点的结构定义，
针对带头结点的链表，请编程完成以下功能。
struct LNode{
int data;                  //数据域
struct LNode *next;        //指针域
};
struct LNode *head;            //头指针
输入数据包含若干组命令和数据，一组数据中的第1个字符代表命令，
接下来的是该命令需要的数据。
(1)如果命令是I，功能为创建空链表，对应函数：void List_Init(head)；
(2)如果命令是A，后跟一个整数data，功能为向链表尾部追加一个数据data,
对应函数：void List_Append(head,data)；
(3)如果命令是C，后跟一个整数N，再跟N个整数，功能为向链表尾部追加N个
数据,可通过调用List_Append()函数实现；
(4)如果命令是P，功能遍历输出链表中所有数据，数据间用一个空格分隔,对应
函数：void List_print(head)，如果链表未建立，输出“List not defined!”，
如果链表为空输出：“List is empty!”。

以上为上一题目的内容，在此基础上，增加设计如下功能：

(5)如果命令是N，后跟一个整数n和d，功能为向链表的第n个位置插入数据d,
可通过调用List_Insert(head,n,d)函数实现；
(6)如果命令是F，后跟一个整数d，功能为在链表查找数据d,返回其位序，若
找不到返回-1。可通过调用List_Find(head,d)函数实现；
(7)如果命令是D，后跟一个整数n，功能为删除链表第n个位置的数据,可通过
调用List_Delete(head,n)函数实现。

输入格式:

若干组命令和数据，很多命令和数据写在一起请注意识别。

输出格式:

根据输入命令输出相应内容，详见输出样例。

输入样例:

I C 5 100 200 300 400 500 P
F 500 N 3 23 N 5 31 P
D 4 P F 99
A 6 P

输出样例:

100 200 300 400 500
index:5
100 200 23 300 31 400 500
100 200 23 31 400 500
Not Found!
100 200 23 31 400 500 6

输入样例:

I A 100 A 200 A 300 C 4 400 500 600 700 P
F 800 F 500
N 4 4 N 5 5 P
D 2 D 2 D 2 P
D 2 D 2 D 2 P
D 1 D 1 P
D 1 D 1 P

输出样例:

100 200 300 400 500 600 700
Not Found!
index:5
100 200 300 4 5 400 500 600 700
100 5 400 500 600 700
100 600 700
700
List is empty!

#include<iostream>
using namespace std;
struct Node{
	int data;
	struct Node *next;
};
struct Node *head;//在外部声明，则后面函数中可以直接用void不用struct 
void List_Init(Node *&head)//新建一个空链表 
{
	head=new Node;
	head->next=NULL;
}
void List_Append(Node *head,int data)//向链表的尾部追加一个数据data 
{
	Node *p,*q;
	p=head;
	q=new Node;
	q->data=data;
	q->next=NULL;
	while(p->next!=NULL){
		p=p->next;
	}
	p->next=q;
}
void List_print(Node *head)//遍历输出链表中的所有数据，如果链表未建立，输出"List not defined!"如果链表为空输出:"List is empty!" 
{
	Node *p;
	if(head==NULL){
		cout<<"List not defined!"<<endl;
		return;
	}
	if(head->next==NULL){
		cout<<"List is empty!"<<endl;
		return;
	}
	p=head->next;//因为这是一个带头结点的链表，所以head实际上是没有数的，它指向的才存了第一个数 
	cout<<p->data;
	p=p->next;
	while(p!=NULL){
		cout<<' '<<p->data;
		p=p->next;
	}
	cout<<endl;
}
void List_Insert(Node *head,int n,int d)//向链表的第n个位置插入数据d 
{
	int i;
	Node *p,*q;
	q=new Node;
	q->data=d;
	q->next=NULL;
	p=head;
	for(i=1;i<n;i++)p=p->next;
	q->next=p->next;
	p->next=q;
}
int List_Find(Node *head,int d)//在链表中查找数据d，并返回其位序，如果找不到则返回-1 
{
	int cnt=1;
	Node *p;
	p=head->next;
	while(p!=NULL){
		if(p->data==d)return cnt;
		p=p->next;
		cnt++;
	}
	return -1;
}
void List_Delete(Node *head,int n)//删除链表第n个位置的数据 
{
	Node *p,*q;
	int i;
	p=head;
	q=p->next;
	for(i=1;i<n;i++){
		if(p!=NULL)p=p->next;
	}
	if(p==NULL || p->next==NULL)return;
	q=p->next;
	p->next=p->next->next;
	delete q;
}

int main()
{
	head=NULL;
	char c;
	int i,n,N,data;
	while(cin>>c){
		if(c=='I')List_Init(head);
		if(c=='A'){
			cin>>data;
			List_Append(head,data);
		}
		if(c=='C'){
			cin>>N;
			for(i=0;i<N;i++){
				cin>>data;
				List_Append(head,data);
			}
		}
		if(c=='P')List_print(head);
		if(c=='N'){
			cin>>n>>data;
			List_Insert(head,n,data);
		}
		if(c=='F'){
			cin>>data;
			if(List_Find(head,data)==-1)cout<<"Not Found!"<<endl;
			else cout<<"index:"<<List_Find(head,data)<<endl;
		}
		if(c=='D'){
			cin>>n;
			List_Delete(head,n);
		}
	}
	return 0;
}

• 若已建立下面的链表结构，指针 p、q 分别指向图中所示结点，则不能将 q 所指结点插入到链表末尾的语句是（C ）。

A.

q->next = NULL;
p = p->next; 
p->next = q;

B.

p = p->next; 
q->next = p->next;
p->next = q;

C.

p = p->next; 
q->next = p;
p->next = q;

D.

p = (*p).next; 
(*q).next = (*p).next;
(*p).next = q;

需要分配较大空间，插入和删除不需要移动元素的线性表，其存储结构是（B）。

A.单链表

B.静态链表

C.线性链表

D.顺序存储结构

• 顺序存储和链式存储没有优劣之分,根据算法要求灵活使用,但链式存储结构比顺序存储结构能更方便地表示各种逻辑结构

• 对于一个线性表既要求能够进行较快速地插入和删除，又要求存储结构能反映数据之间的逻辑关系，则应该用(链式存储方式 )。

• ‘静态链表需要分配较大的连续空间，插入和删除不需要移动元素

• 若用单链表来表示队列，则应该选用带尾指针的循环链表

• 删除最后一个链表元素时,就算设置尾指针,也无法删除最后一个节点,也只能从头结点往后遍历,删除最后一个节点,时间复杂度为O(n)

• 设对n(n>1)个元素的线性表的运算只有4种:删除第一个元素;删除最后一个元素;在第一个元素之前插入新元素;

• 在最后一个元素之后插入新元素，则最好使用(只有头结点指针没有尾结点指针的循环双链表)。

• 需要分配较大空间，插入和删除不需要移动元素的线性表，其存储结构为( 静态链表)。

单链表中，增加一个头结点的目的是（C ）

A.使单链表至少有一个结点。

B.标识表结点中首结点的位置。

C.方便运算的实现。

D.说明单链表是线性表的链式存储

解析：(1) 对带头结点的链表，在表的任何结点之前插入结点或删除表中任何结点，所要做的都是修改前一结点的指针域，因为任何元素结点都有前驱结点。若链表没有头结点，则首元素结点没有前驱结点，在其前插入结点或删除该结点时操作会复杂些。 (2) 对带头结点的链表，表头指针是指向头结点的非空指针，因此空表与非空表的处理是一样的。

2-1

线性表若采用链式存储结构时，要求内存中可用存储单元的地址 B

A 必须是连续的
B 连续或不连续都可以
C 部分地址必须是连续的
D 一定是不连续的

2-2

线性表L在什么情况下适用于使用链式结构实现？ A

A 需不断对L进行删除插入
B 需经常修改L中的结点值
C L中含有大量的结点
D L中结点结构复杂

2-3

链表不具有的特点是： B

A 插入、删除不需要移动元素
B 方便随机访问任一元素
C 不必事先估计存储空间
D 所需空间与线性长度成正比

2-7

可以用带表头附加结点的链表表示线性表，也可以用不带头结点的链表表示线性表，前者最主要的好处是（B）。 (1分)

A 可以加快对表的遍历
B 使空表和非空表的处理统一
C 节省存储空间
D 可以提高存取表元素的速度

2-8

在单链表中，要删除某一指定结点，必须先找到该结点的（A）。 (1分)

A 直接前驱
B 自身位置
C 直接后继
D 直接后继的后继

2-9

以下关于链式存储结构的叙述中，（C）是不正确的。 (1分)

A 结点除自身信息外还包括指针域，因此存储密度小于顺序存储结构
B 逻辑上相邻的结点物理上不必邻接
C 可以通过计算直接确定第i个结点的存储地址
D 插入、删除运算操作方便，不必移动结点

以下结构类型可用来构造链表的是（B）。

A.struct aa{ int a；int * b；}；

B.struct bb{ int a；bb * b；}；

C.struct cc{ int * a；cc b；}；

D.struct dd{ int * a；aa b；}；

链表要有一个next，next的类型要与结构体的类型一致

2-13

关于delete运算符的下列描述中，（C）是错误的。

A.它必须用于new返回的指针；

B.使用它删除对象时要调用析构函数；

C.对一个指针可以使用多次该运算符；

D.指针名前只有一对方括号符号，不管所删除数组的维数。

2-14

以下程序中，new语句干了什么。（C）

int** num;

num = new int* [20];

A.分配了长度为20的整数数组空间，并将首元素的指针返回。

B.分配了一个整数变量的空间，并将其初始化为20。

C.分配了长度为20的整数指针数组空间，并将num[0]的指针返回。

D.存在错误，编译不能通过。

关于new运算符的下列描述中，（D）是错误的。

A.它可以用来动态创建对象和对象数组；

B.使用它创建的对象或对象数组可以使用运算符delete删除；

C.使用它创建对象时要调用构造函数；

D.使用它创建对象数组时必须指定初始值

2-11

表达式 “new int”的返回值类型是?

A.int

B.int *

C.int &

D.无法确定

设void f1(int * m，long & n)；int a；long b；则以下调用合法的是（B）。

A.f1(a，b)；

B.f1(&a，b)；

C.f1(a，&b)；

D.f1(&a，&b)；