两题单链表逆置,求讲解1.p=head->next;head->next=NULL;while(p){s=p;p=p->

碎雨漂痕2022-10-04 11:39:541条回答

两题单链表逆置,求讲解
1.p=head->next;
head->next=NULL;
while(p)
{s=p;
p=p->next;
s->next=head->next;
head->=s;
}
p=head-next;
2.p=head->next;
q=p->next;
p->next=NULL;
while(q!=NULL)
{
r=q->next;
q->next=p;
p=q;
q=r;
}
head->next=p;
本人初学数据结构,看不懂这两个链表是如何逆置,

已提交,审核后显示!提交回复

共1条回复
Mars_Yu 共回答了22个问题 | 采纳率90.9%
第一个,有头结点的单链表,从头到尾顺次摘下所有结点并插入在表头:
p=head->next; p指向第一个结点
head->next=NULL; 断开头结点和链表
while(p)当链表不为空时
{s=p;中间指针保存当前结点好摘下
p=p->next;当前指针后移
s->next=head->next;将摘下的结点
head->=s;表头插入
}
第二个,有头结点单链表,至少一个数据结点,与前面的相似,只是处理方法为每摘下一个结点,将其后继域指向当前第一个结点
p=head->next; 第一个结点
q=p->next;第二个结点
p->next=NULL;断开链表
while(q!=NULL)待摘结点链表不为空
{
r=q->next;中间指针指向待摘结点表头的后继
q->next=p;当前摘下结点指向第一个结点
p=q;第一个结点移到刚插入的结点
q=r;待摘结点指针后移
}
head->next=p;将表头结点和第一个结点链接起来
1年前

相关推荐

c语言问题设计算法将一个带头结点的单链表A分解为两个具有相同结构的链表B、C,其中B表的结点为A表中值小于零的结点,而C
c语言问题
设计算法将一个带头结点的单链表A分解为两个具有相同结构的链表B、C,其中B表的结点为A表中值小于零的结点,而C表的结点为A表中值大于零的结点(链表A的元素类型为整型,要求B、C表利用A表的结点)。
otmf1年前1
innocent2k 共回答了24个问题 | 采纳率95.8%
完全满足你的要求#include
#include

typedef int NodeType;

typedef struct _node {
NodeType data;
struct _node *next;
} Linklist;

void display(Linklist *head) {
Linklist *p;
for(p = head->next; p; p = p->next)
printf("%d%c", p->data, (p->next ? ',':'n'));
}

void split(Linklist *a, Linklist *b, Linklist *c) {
Linklist *bp = b, *cp = c, *p;
for(p = a->next; p; p = p->next) {
if(p->data < 0) {
bp->next = p;
bp = p;
} else if(p->data > 0) {
cp->next = p;
cp = p;
}
}
bp->next = NULL;
cp->next = NULL;
}

int main(){
Linklist *a = (Linklist*)malloc(sizeof(Linklist)),
*b = (Linklist*)malloc(sizeof(Linklist)),
*c = (Linklist*)malloc(sizeof(Linklist)),
*ap = a;
a->next = NULL;
b->next = NULL;
c->next = NULL;
int i;
for(i = 0; i < 50; i++) {
int data = rand()%100 - 50;
Linklist *q = (Linklist*)malloc(sizeof(Linklist));
q->data = data;
q->next = NULL;
ap->next = q;
ap = q;
}
display(a);
split(a, b, c);
display(b);
display(c);
return 0;
}运行结果:
-9,17,-16,-50,19,-26,28,8,12,14,-45,-5,31,-23,11,41,45,-8,-23,-14,41,-46,-48,3,42,32,-29,-34,-32,45,-3,-24,21,-12,19,-38,17,49,-15,44,-47,-39,-28,-17,23,14,-9,-39,3,18-9,-16,-50,-26,-45,-5,-23,-8,-23,-14,-46,-48,-29,-34,-32,-3,-24,-12,-38,-15,-47,-39,-28,-17,-9,-3917,19,28,8,12,14,31,11,41,45,41,3,42,32,45,21,19,17,49,44,23,14,3,18
数据结构算法求大神1 写一算法,统计出单链表L中结点的值等于给定值x的结点数。2 已知线性表中的元素(整数)以值递增有序
数据结构算法求大神
1 写一算法,统计出单链表L中结点的值等于给定值x的结点数。
2 已知线性表中的元素(整数)以值递增有序排列,并以单链表作存储结构。试写一高效算法,删除表 中所有大于K1且小于K2的元素(若表中存在这样的元素,且K13假设两个按元素值递增有序排列的线性表A和B,均以单链表作为存储结构,请编写算法,将A表和B表 归并成一个按元素值递减有序的排列的线性表C,并要求利用原表(即A表和B表的)结点空间存放表C 。
79392341年前1
碧海银砂 共回答了17个问题 | 采纳率88.2%
#include
#include
#include
#include

#define elem int
#define M 10
typedef struct node
{
elem data;
struct node *next;
}no;

//以下单链表均带头节点
//1.
int f1(no *L,elem x)
{
int i=0;
L=L->next;
while(L)
{
if(L->data==x)
i++;
L=L->next;
}
return i;
}
//2.算法复杂度为O(N)
void f2(no *L,int k1,int k2)
{
if(k1>=k2)
{
coutnext;
}
while(L && L->datanext=L->next;
free(q);
L=p->next;
}
}
//3.算法采用的是头插法
node *f3(no *a,no *b)
{
if(!a || !b)
return 0;
node *c=new node,*p;
if(!c)
exit(1);
c->next=0;
while(a->next || b->next)
{
if(!a->next || b->next && b->next->data < a->next->data)
{//当链表a为空时,或b链表存在且b链表的第一个值小于a链表
p=b->next;
b->next=p->next;
}
else
{
p=a->next;
a->next=p->next;
}
p->next=c->next;
c->next=p;
}
return c;
}
急求C++6.急用!单链表排序与删除
急求C++6.急用!单链表排序与删除
设有一个正整数序列组成的有序单链表(按递增次序有序,且允许有相等的整数存在),试编写能实现下列功能的算法 :
x05(1)确定在序列中比正整数x大的数有几个(相同的数只计算一次,如序列{4,5,7,7,8,10,11,15,15,16,17,20,20}中比10大的数有5个);
x05(2) 在单链表将比正整数x小的数按递减次序排列;
x05(3) 将正整数(比)x大的偶数从单链表中删除.
例如:输入:123455667788;设定X=5;输出比X大的为有3个,输出排序后 的:432155667788;输出删除后的链表:12345577
MaliyaQ1年前1
股家寡人的老粉丝 共回答了18个问题 | 采纳率94.4%
来我空间来看~~456875423加!
几道数据结构题1,将长度为n的单链表接在长度为m的单链表之后算法的空间复杂度为()A,O(1) B,O(n) C,O(m
几道数据结构题
1,将长度为n的单链表接在长度为m的单链表之后算法的空间复杂度为()A,O(1) B,O(n) C,O(m) D,(m+n)
2,下列陈述正确的是()A,串可以是一篇文章 B,串的长度必须大于零 C,串中元素只能是字母 D,空串就是空白串
3,在一棵度为2的树中,度为2的结点个数为3,则度为0的结点个数为()A,4 B,5 C,6 D,7
4,n个顶点的无向图最多可能有_____条边
5,在一个带头结点的单循环链表中,p指向尾结点的直接前驱的前驱,则指向头结点的指针first可用p表示为first=______.
6,已知一棵完全二叉树中共有480结点,则该树中共有____个叶子结点
kaidyfaye1年前1
rwnif 共回答了19个问题 | 采纳率94.7%
1、C 3、A 4、n(n-1)/2 5、P->next->next->next 6、240
第二道题,B、C、D都不对,A不怎么确定
计算机三级偏软问题22.设h指向带表头结点的循环链表,h=(a1,a2,a3),p指向循环链表中的一个结点.若p->ne
计算机三级偏软问题
22.设h指向带表头结点的循环链表,h=(a1,a2,a3),p指向循环链表中的一个结点.若
p->next->next==a1("=="为等于关系运算符),则p是指向___(22)___的指针.其中,p指向结点的指针域用p->next表示.
A.表头结点 B.数据域值为a1的结点
C.数据域值为a2的结点 D.数据域值为a3的结点
梦女郎1年前1
痴癫疯呆傻 共回答了13个问题 | 采纳率100%
C、h->head->a1->a2->a3->a1
所以a2->next为a3,a2->next->next为a1
已知线性表中元素以值递增有序排列,并以单链表作为存储结构....我设计了一个算法,求修改
已知线性表中元素以值递增有序排列,并以单链表作为存储结构....我设计了一个算法,求修改

已知线性表中元素以值递增有序排列,并以单链表作为存储结构。试设计一个算法,删除表中值相同的多余元素,使得操作后表中的所有元素值均不相同,同时释放***的结点空间

这是我设计的算法,这是我写的,但我不知道对不对,求修改来符合题意,希望解答能详细。


超级dd棍1年前1
LEO冷寒 共回答了16个问题 | 采纳率93.8%
你这是什么呀,C++不对,伪代码也不是?
伪代码如下:
p = head;
q = head->next
while (q)
if p->data == q->data
t = q;
q = q->next;
delete t;
else
p->next = q;
p = q;
9,求顺序表和单链表的长度算法的时间复杂度分别是 ( )和 ( ).
anoon1年前1
1982222 共回答了16个问题 | 采纳率100%
O(1)和O(n)
采用链表解决约瑟夫问题:有n个人围坐在一起形成头尾相接的一个环,从第m个人开始报数,每次有人数到r时,
采用链表解决约瑟夫问题:有n个人围坐在一起形成头尾相接的一个环,从第m个人开始报数,每次有人数到r时,
这个人就离开.请输出所有人的离队顺序.
tpfs3711年前1
闹闹很乖 共回答了12个问题 | 采纳率91.7%
/*
有n个人围坐在一起形成头尾相接的一个环,从第m个人开始报数,每次有人数到r时,zhe
*/
#include
using namespace std;
// 表示一个犯人的结构体
struct Prisoner
{
// 编号
int id;
// 密码
int pass;
// 用于链表的指针
struct Prisoner * pre;
struct Prisoner * next;
};
class JosephCircle
{
public:
// 基本的约瑟夫构造函数
JosephCircle(int N,int M,int R);
// 输出约瑟夫环
void print();
// 开始处决犯人
void start();
private:
int N,M,R;
// 约瑟夫环的头指针
struct Prisoner * head;
// 第一个被处决的犯人的节点指针
struct Prisoner * firstPunishedPrision;
};
JosephCircle::JosephCircle(int N,int M,int R)
{
this->N = N;
this->M = M;
this->R = R;

struct Prisoner * p , *pr;
// 约瑟夫环的头指针初始化为空
this->head = NULL;
// 构造一个由 N 个犯人组成的约瑟夫环
for(int i=1;ihead == NULL)
{
// 新增一个犯人
p = new struct Prisoner();
// 犯人编号
p -> id = i;
// 犯人密码
p -> pass = R;
// 紧挨着的下一个犯人(因为是环状的,每个人都会有紧挨着的其他犯人)
p -> pre = p;
p -> next = p;
// 约瑟夫环的头指针
this->head = pr = p;
}
else
{
p = new struct Prisoner();
p -> id = i;
p -> pass = R;
p -> pre = pr;
p -> next = pr->next;

pr -> next -> pre = p;
pr -> next = p;

pr = p;
}
}

// 寻找约瑟夫环里面第一个被处决的犯人的【节点指针】
firstPunishedPrision = head;
for(int i=2;ifirstPunishedPrision = this->firstPunishedPrision -> next;
}
}
// 输出约瑟夫环
void JosephCircle::print()
{
cout pre = q -> pre;
p = p -> next;
// 输出被处决的犯人的信息
cout
帮写一个算法假设有两个按元素值递增有序排列的有序表A和B,均以单链表作存储结构,请编写算法利用A表和B表中原有的结点将A
帮写一个算法
假设有两个按元素值递增有序排列的有序表A和B,均以单链表作存储结构,请编写算法利用A表和B表中原有的结点将A表和B表归并成一个按元素值非递增有序排列的有序表C. A=(1,2,3,4,6) B=(2,3,5,7,9) C=(9,7,6,5,4,3,3,2,1)最好写成可以上机操作的程序
铅笔削1年前1
fukie 共回答了21个问题 | 采纳率95.2%
呵呵,数据结构有个有名的算法:归并排序,这个算法可以解决你的问题。自己可以网上找找,或找本数据结构的书,书里也有着算法。以下是严蔚敏的《数据结构(c语言版)》里归并排序里的核心算法,这个算法就是你要的把两个有序表归并成一个有序表。void Merge(RcdType SR[],RcdType &TR[],int i,int m,int n){ //将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n] for(j=m+1,k=i;i
4. 在双向链表中,每个结点包含有两个指针域,一个指向其_____ ______结点,另一个指向其_____ ____结
4. 在双向链表中,每个结点包含有两个指针域,一个指向其_____ ______结点,另一个指向其_____ ____结点
看看名字能有多长1年前1
bodede 共回答了17个问题 | 采纳率88.2%
前驱结点,后继结点.
C语言问题,求详解~~~~假定已建立一下链表结构,且指针p和q已指向如图所示的结点:则以下选项中可将q所指结点从链表中删
C语言问题,求详解~~~~

假定已建立一下链表结构,且指针p和q已指向如图所示的结点:

则以下选项中

可将q所指结点从链表中删除并释放该结点的语句组是

A)(*p).next=(*q).next; free(p);    B)p=q->next; free(q);

C)p=q; free(q);            D)p->next=q->next; free(q);


ait1121年前1
axin362003 共回答了11个问题 | 采纳率100%
删除q节点,
首先要把q的next的值赋给p的next域,即p->next=q->next
否则整个链表就断开了。
然后释放q.
所以选D
---------------------------------------
B、p=q->next是把指针p移动到q 的下一位,不能删除q,free(q)没用的。
A、p,q本就是指针加*取其内容再.next不知其意。
实现两个长整数相加:要求用链表(单链表或双向链表)实现两个任意位数的整数相加。例如,为存储100位的整数可以建立有100
实现两个长整数相加:要求用链表(单链表或双向链表)实现两个任意位数的整数相加。例如,为存储100位的整数可以建立有100个结点的单链表,每个结点存储1位(如果每个结点存储4位,建立25个结点的单链表也可以)
anyangzzh1年前1
filwy 共回答了22个问题 | 采纳率86.4%
根据你的想法我写了个 一位一个结点的 只是正长整数相加 负数没有考虑 你可以自己完善下!
代码如下:
#include
#include
#define X 101 //100位加1位进位
typedef struct NODE//单链表
{
int data;
struct NODE *next;
}List;
List *Create(char *n)//加数输入到链表
{
int i,ws=0,num=0;
char *x;
List *head,*p,*q;
x=n;
while(*x++) ws++;
head=p=(List *)malloc(sizeof(List));
//printf("%s",n);
for(i=ws-1;i>=0;i--)
{
q=(List *)malloc(sizeof(List));
q->data=n[i]-'0';
if(num==0)
{
p=q;
head=p;
}
else
p->next=q;
p=q;
num++;
}
for(i=0;idata=0;
p->next=q;
p=q;
}
q=(List *)malloc(sizeof(List));
q->data=0;
p->next=q;
p=q;p->next=NULL;
return head;
}
List *SUM(List *p,List *q)//求和
{
int jw=0,tem=0;//进位
List *head,*y;
head=(List *)malloc(sizeof(List));
head=NULL;
while(p!=NULL)
{
tem=p->data+q->data+jw;
if(tem>=10)
jw=1;
else
jw=0;
tem=tem%10;
y=(List *)malloc(sizeof(List));
y->data=tem;
y->next=head;
head=y;
p=p->next;q=q->next;
}
return head;
}
void Print(List *head)//输出结果
{
int num=0;
List *p;
p=head;
while(p!=NULL)
{
if(p->data!=0)num=1;
if(num==1)
{
printf("%d",p->data);
}
p=p->next;
}
}
main()
{
List *js1,*js2,*sum1;
char *p="654456793422",*q="4567898";
js1=Create(p);//加数输入到链表
js2=Create(q);//加数输入到链表

printf("加数1:%s",p);
printf("");
printf("加数2:%s",q);
sum1=SUM(js1,js2);//求和
printf("");
printf("求和:");
Print(sum1);
printf("");
}
数据结构1、 线性表有两种存储结构:一是顺序表,二是链表。试问:(1)如果有 n 个线性表同时并存,并且在处理过程中各表
数据结构
1、 线性表有两种存储结构:一是顺序表,二是链表。试问:
(1)如果有 n 个线性表同时并存,并且在处理过程中各表的长度会动态变化,线性表的
总数也会自动的改变。在此情况下,应选用哪种存储结构?为什么?
(2)若线性表的总数基本稳定,且很少进行插入和删除操作,但要求以最快的速度存取
线性表中的元素,那么应采取哪种存储结构?为什么? (8 分)
68251131年前1
ricky749 共回答了17个问题 | 采纳率100%
给你一个判断题:
顺序表结构适于进行顺序存取,而链表适于进行随机存取。请判断。
答案:错误。
刚好弄反了。
知道这,就能解决你的问题了。 谢谢加分~
设单链表中指针p指向结点ai,指针f指向将要插入的新结点 x,则当x插在链表中两个数据元素ai和ai+1之间时,
设单链表中指针p指向结点ai,指针f指向将要插入的新结点 x,则当x插在链表中两个数据元素ai和ai+1之间时,
只要先修改( )后修改p->next= f即可
A.f->next=p
B.p->next=
p->next->next
C.p->next=f->next
D.f->next= p->next
时空尽头1年前1
robert-s 共回答了16个问题 | 采纳率87.5%
答案:D
f->next = p->next;,使结点x 的下一个结点是ai+1;
p->nex = f; 使结点 ai 的下一个结点是 x; 这样就是 ai 下一个是x,x下一个ai+1,实现了插入
数据结构已知指针P指向双向链表中的一个结点(非首结点、非尾结点),则:(1)将结点S插入在P结点的直接
天下没有血1年前1
wanqinghui 共回答了15个问题 | 采纳率100%
/* 插入p的前面 */
int*q;
q=p->prior;
s->next=p;
s->prior=q;
q->next=s;
p->prior=s;
/* 插入p的后面 */
int*q;
q=p->next;
s->next=q;
s->prior=p;
q->prior=s;
p->next=s;
排序(用链表实现,用c实现)将一个杂乱无序的整数序列,按照从小到大的顺序排列并输出。用第二章的相关知识实现,即先初始化一
排序(用链表实现,用c实现)
将一个杂乱无序的整数序列,按照从小到大的顺序排列并输出。
用第二章的相关知识实现,即先初始化一个空的单链表,然后每读入一个数据,将该数据存入结点并插入单链表,当然,插入时要从头结点开始向后(或从尾结点开始向前)搜索合适的插入位置,以保证插入后仍然有序。
输出时,从头结点开始向后,顺序输出各结点的值。
输入
测试数据不止一组,每组测试数据:
1)先输入无序序列的整数个数n;(n不超过10000)
2)然后连续输入n个整数;
若n的值输入为0值,则输入结束.
输出
与每组输入的测试数据相对应,输出其按从小到大排好序后的整数序列.
注意:每组输出占一行.
中秋吃月饼1年前1
m_l_n 共回答了13个问题 | 采纳率84.6%
本人书写并调试近2小时,已经调试通过;将下面代码分别保存为data.h data.c user.c
然后编译user.c data.c即可;
/*
* data.h
* */
#ifndef __DATA_H__
typedef struct node {
int id;
struct node *p_next;
} node, *ll_head;
ll_head ll_create(void); /* create a linked list */
node *ll_input(node *);
void ll_insert(ll_head, node *); /* insert a node to the linked list */
void ll_delete(ll_head, node *); /* delete a node from the linked list */
node *ll_locate(ll_head, int); /* return if the node exists */
void ll_free(ll_head); /* free memory */
void ll_traversal(ll_head); /* traversal the linked list */
#endif /* __DATA_H__*/
/*
* data.c
* */
#include
#include
#include "data.h"
/* create a linked list */
ll_head ll_create(void)
{
node *new = malloc(sizeof(struct node));
if (new == NULL) {
perror("malloc");
return NULL;
}
new->p_next = NULL;
//printf("create linked list successfully !");
return new;
}
/* insert a node to the linked list */
void ll_insert(ll_head head, node * tmp)
{
if (ll_locate(head, tmp->id)) {
printf("the id(%d) has exited", tmp->id);
return;
}
node *new = malloc(sizeof(struct node));
if (new == NULL) {
perror("malloc");
return;
}
new->id = tmp->id;
new->p_next = NULL;
node *this = head;
for (this = head; this; this = this->p_next) {
/* insert id to link list in order */
if (this->p_next == NULL) {
this->p_next = new;
break;
} else if (this->p_next->id > tmp->id) {
new->p_next = this->p_next;
this->p_next = new;
break;
}
}
}
/* delete a node from the linked list */
void ll_delete(ll_head head, node *tmp)
{
node *this = head;
node *fro = this;
int flag = 0;
for (; this;) {
fro = this;
this = this->p_next;
if (this->id == tmp->id) {
fro->p_next = this->p_next;
free(this);
this = fro;
flag = 1;
printf("delete id(%d)", tmp->id);
}
}
if (this == NULL && flag == 0) {
printf("the node not exists");
}
}
/* free the memory of the linkedlist */
void ll_free(ll_head head)
{
node *fro = head;
node *this = head;
for (; this->p_next;) {
fro = this;
this = this->p_next;
fro->p_next = this->p_next;
//printf("free(%02d,%02d) ", this->x, this->y);
free(this);
this = fro;
}
//printf("");
}
/* return if the node exists */
node *ll_locate(ll_head head, int id)
{
node *this = head;
while (this = this->p_next) {
if (this->id == id) {
return this;
}
}
return NULL;
}
/* traversal the linked list */
void ll_traversal(ll_head head)
{
node *this = head;
while (this = this->p_next) {
printf("%d ", this->id);
}
printf("");
}
/*
* user.c
* */
#include
#include
#include "data.h"
int main()
{
node *ll_head = ll_create();
node tmp;
int num = 0;
while (num++
《数据结构》在线作业11. 在一个双链表中结点p之后插入一个结点s的操作是( )。A. s->right=p;s->le
《数据结构》在线作业
11. 在一个双链表中结点p之后插入一个结点s的操作是( )。
A. s->right=p;s->left=p->right;p->right->left=s;p->right=s
B. s->right=p->right;p->right->left=s;s->right=p;p->left=s
C. s->right=p->right;s->left=p;p->left->left=s;p->right=s
D. s->right=p;p->left->left=s;p->right=s;s->right=p->right
满分:2 分


12. 对于一个具有n个顶点和e条边的无向图,若采用邻接表表示,则表头向量的大小为( )。
A. n
B. n+1
C. n-l
D. n十e
满分:2 分


13. 非空二叉树在线索化后,仍不能有效求解的问题是( )。
A. 前序线索二叉树中求前序后继
B. 中序线索二叉树中求中序后继
C. 中序线索二叉树中求中序前趋
D. 后序线索二叉树中求后序后继
满分:2 分


14. 导致图的遍历序列不惟一的因素是()
A. 出发点的不同、遍历方法的不同
B. 出发点的不同、存储结构的不同
C. 遍历方法的不同、存储结构的不同
D. 出发点的不同、存储结构的不同、遍历方法的不同
满分:2 分


15. 在数据结构中,从逻辑上可以把数据结构分成()。
A. 动态结构和静态结构
B. 紧凑结构和非紧凑结构
C. 线性结构和非线性结构
D. 内部结构和非内部结构
满分:2 分


16. 一个栈的人栈序列是a,b,c,d,e,则栈的不可能的输出序列是()
A. edcba
B. decba
C. dceab
D. abcde
满分:2 分


17. 某非空二叉树的前序序列和后序序列正好相反,则二叉树-定是( )的二叉树。
A. 空或只有一个结点
B. 高度等于其结点数
C. 任一结点无左孩子
D. 任一结点无右孩子
满分:2 分


18. 任何一个带权无向连通图的最小生成树( )。
A. 是唯一的
B. 是不唯一的
C. 有可能不惟一
D. 有可能不存在
满分:2 分


19. 算法分析的目的是()
A. 找出数据结构的合理性
B. 研究算法中的输入和输出的关系
C. 分析算法的效率以求改进
D. 分析算法的易懂性和文档性
满分:2 分


20. 串的长度是()
A. 串中不同字母的个数
B. 串中不同字符的个数
C. 串中所含字符的个数,且大于0
D. 串中所含字符的个数
满分:2 分
k41501年前1
寒雨连江4 共回答了27个问题 | 采纳率96.3%
大工11秋《数据结构》在线作业1
一,单选题
1. B
2. B
3. B
4. A
5. A
6. C
7. B
8. B
9. C
10.B
二,判断题
1.B
2.A
3.B
4.B
5.B
6.A
7.B
8.B
9.B
10.A
大工11秋《数据结构》在线作业2
一,单选题
1. difference(A,B,C)表示求集合A和B的差集C.若A={b,c,d},B={c,e},则difference(A,B,C)运算后C=( ).
A. {b,c,d,e}
B. {c}
C. {b,d}
D. {b,c,c,d,e}
正确答案:C
2. 具有6个顶点的无向图至少应有()条边才能确保是一个连通图.
A. 5
B. 6
C. 7
D. 8
正确答案:A
3. min(A),函数的返回值是集合A的所有元素中按线性序最小的那个元素.则min({2,3,4})=( )
A. 2
B. 3
C. 4
D. 0
正确答案:A
4. index(s,t)表示子串定位运算.若串t是串s的子串,则函数返回值是串t在串s中第一次出现的开始位置,否则返回值是0.若s="ababa",t="ba",则index(s,t)=( ).
A. 0
B. 1
C. 2
D. 3
正确答案:C
5. 在一棵二叉树上第5层的结点数最多为(),设树根为第1层.
A. 16
B. 15
C. 8
D. 32
正确答案:A
6. intersection(A,B,C)表示求集合A和B的交集C.若A={b,c,d},B={c,e},则intersection(A,B,C)运算后C=( ).
A. {b,c,d,e}
B. {c}
C. {b,d}
D. {b,c,c,d,e}
正确答案:B
7. 在一个具有n个顶点和e条边的无向图的邻接表中,边结点的个数为().
A. n
B. ne
C. e
D. 2e
正确答案:D
8. union(A,B,C)表示求集合A和B的并集C.若A={b,c,d},B={c,e},则union(A,B,C)运算后C=( ).
A. {b,c,d,e}
B. {c}
C. {b,d}
D. {b,c,c,d,e}
正确答案:A
9. 在一个具有n个顶点和e条边的有向图的邻接表中,保存顶点单链表的表头指针向量的大小至少为().
A. n
B. 2n
C. e
D. 2e
正确答案:A
10. concat(s,t)表示连接运算.将串t连接在串s之后,形成新的串s.若s="beg",t="in",则concat(s,t)之后,s="( )".
A. begin
B. bein
C. begn
D. beggin
正确答案:A
二,判断题
1. 树中的结点数等于所有结点的度数加1.
A. 错误
B. 正确
正确答案:B
2. 有向图用邻接表表示,顶点i的度是对应顶点i链表中结点个数.
A. 错误
B. 正确
正确答案:A
3. 字典是一种特殊的集合,其中每个元素由关键码和属性组成.
A. 错误
B. 正确
正确答案:B
4. 有向图用邻接表表示,顶点i的出度是对应顶点i链表中结点个数.
A. 错误
B. 正确
正确答案:B
5. 一个图的邻接矩阵表示是惟一的.
A. 错误
B. 正确
正确答案:B
6. 有向图的邻接矩阵一定是对称矩阵.
A. 错误
B. 正确
正确答案:A
7. 无向图的邻接矩阵一定是对称矩阵.
A. 错误
B. 正确
正确答案:B
8. 一个图的邻接表表示是惟一的.
A. 错误
B. 正确
正确答案:A
9. 非空二叉树上叶子结点数等于双分支结点数加1.
A. 错误
B. 正确
正确答案:B
10. 连通图的生成树不一定是惟一的.
A. 错误
B. 正确
正确答案:B
大工11秋《数据结构》在线作业3
一,单选题
1. 下述几种排序方法中,要求内存量最大的是().
A. 插入排序
B. 选择排序
C. 堆排序
D. 归并排序
正确答案:D
2. 堆排序是一种()排序.
A. 插入
B. 选择
C. 交换
D. 归并
正确答案:B
3. 在长度为n的顺序表中进行顺序查找,查找失败时需与关键字比较次数是( ).
A. n
B. 1
C. n-1
D. n+1
正确答案:D
4. 用起泡排序方法对n个记录按排序码从小到大排序时,当初始序列是按排序码从大到小排列时,与排序码总比较次数是().
A. n-1
B. n
C. n+1
D. n(n-1)/2
正确答案:D
5. 对线性表进行顺序查找时,要求线性表的存储结构是().
A. 倒排表
B. 索引表
C. 顺序表或链表
D. 散列表
正确答案:C
6. 对于顺序存储的有序表(5,12,20,26,37,42,46,50,64),若采用折半查找,则查找元素26的查找长度为( ).
A. 2
B. 3
C. 4
D. 5
正确答案:C
7. 哈希表的平均查找长度和()无直接关系.
A. 哈希函数
B. 装填因子
C. 哈希表记录类型
D. 处理冲突的方法
正确答案:C
8. 排序方法中,从未排序序列中挑选元素,并将其依次放入已排序序列(初始时为空)的一端的方法,称为().
A. 希尔排序
B. 归并排序
C. 插入排序
D. 选择排序
正确答案:D
9. 磁带适合存储的文件类型是().
A. 索引文件
B. 顺序文件
C. 散列文件
D. 倒排文件
正确答案:B
10. 排序方法中,从未排序序列中依次取出元素与已排序序列(初始时为空)中的元素进行比较,将其放入已排序序列的正确位置上的方法,称为().
A. 插入排序
B. 冒泡排序
C. 希尔排序
D. 选择排序
正确答案:A
二,判断题
1. 散列表既是一种查找方法,又是一种存储方法.
A. 错误
B. 正确
正确答案:B
2. 在散列文件中删除记录时,只要对被删记录作一标记即可.
A. 错误
B. 正确
正确答案:B
3. 散列文件中存放一组记录的存储单位称为桶.
A. 错误
B. 正确
正确答案:B
4. 二分查找对线性表的存储结构无任何要求.
A. 错误
B. 正确
正确答案:A
5. 直接选择排序属于选择类排序,是一种稳定的排序方法.
A. 错误
B. 正确
正确答案:A
6. 哈希表查找无须进行关键字的比较.
A. 错误
B. 正确
正确答案:A
7. 对快速排序来说,初始序列为正序和反序都是最坏情况.
A. 错误
B. 正确
正确答案:B
8. 在执行某个排序过程中,出现排序码朝着最终位置相反方向移动,则该算法是不稳定的.
A. 错误
B. 正确
正确答案:A
9. 堆排序是一种不稳定的排序方法.
A. 错误
B. 正确
正确答案:B
10. 若待排序记录已按排序码基本有序,则应采用直接插入排序或起泡排序.
A. 错误
B. 正确
正确答案:B
C语言 数据结构 简单的链表!求助
C语言 数据结构 简单的链表!求助

六、 下图是一个链表,图中指针p指向当前正在访问的节点,指针pr指向指针p所指节点左侧的节点,p所指节点左侧的所有节点的链接方向都向左。(1)编写算法,实现从任一给定位置(pr,p)开始,将指针p右移1个节点,如果p移出链表,则将p置为NULL,并让pr留在链表最右边节点上。(2)编写算法,实现从任一给定位置(pr,p)开始,将指针p左移1个节点,如果pr移出链表,则将pr置为NULL,并让p留在链表最左边节点上。


eastling1年前1
**道 共回答了30个问题 | 采纳率86.7%
建议研究下单向链表的逆序
把题目要求的操作从头开始做到尾,链表就逆序了。
所以逆序搞懂了,你的题目只是其中的一次移动步骤
关于数据结构的题二、判断正误( )1. 链表的每个结点中都恰好包含一个指针。 ( )2. 链表的物理存储结构具有同链表一
关于数据结构的题
二、判断正误
( )1. 链表的每个结点中都恰好包含一个指针。
( )2. 链表的物理存储结构具有同链表一样的顺序。
( )3. 链表的删除算法很简单,因为当删除链中某个结点后,计算机会自动将后续各个单元向前移动。
( )4. 顺序表结构适宜于进行顺序存取,而链表适宜于进行随机存取。
( )5. 顺序存储方式的优点是存储密度大,且插入、删除运算效率高。
( )6. 线性表在物理存储空间中也一定是连续的。
( )7. 栈是一种对所有插入、删除操作限于在表的一端进行的线性表,是一种后进先出型结构。
( )8. 对于不同的使用者,一个表结构既可以是栈,也可以是队列,也可以是线性表。
( )9. 队是一种插入与删除操作分别在表的两端进行的线性表,是一种先进后出型结构。
( )10. 一个栈的输入序列是12345,则栈的输出序列不可能是12345。
39659441年前2
passkeye 共回答了19个问题 | 采纳率84.2%
( × )1. 链表的每个结点中都恰好包含一个指针。
答:错误。链表中的结点可含多个指针域,分别存放多个指针。例如,双向链表中的结点可以含有两个指针域,分别存放指向其直接前趋和直接后继结点的指针。
( × )2. 链表的物理存储结构具有同链表一样的顺序。
错,链表的存储结构特点是无序,而链表的示意图有序。
( × )3. 链表的删除算法很简单,因为当删除链...
对于双向循环链表,请写出在p指针所指的结点之后插入s指针所指结点的语句;并画出图示,标明语句执行的先后.
野狼人_tt1年前0
共回答了个问题 | 采纳率
一道关于线性链表的问题下列对线性链表说法正确的是:A、各数据节点的储存空间可以不连续,但他们的存储顺序与逻辑顺序必须一致
一道关于线性链表的问题
下列对线性链表说法正确的是:
A、各数据节点的储存空间可以不连续,但他们的存储顺序与逻辑顺序必须一致
B、各数据节点的存储顺序与逻辑顺序可以不一致,但他们的存储空间不需要连续
C、进行插入和删除数据时,不需要移动表中元素
D、上述都不正确
我明白C为什么对,求大神说下B怎么错的?
醉雨飘飘1年前0
共回答了个问题 | 采纳率
已知带表头结点的非空单链表L,指针P指向L链表中的一个结点(非首尾结点),试从下列选项中选择合适的语句序列
已知带表头结点的非空单链表L,指针P指向L链表中的一个结点(非首尾结点),试从下列选项中选择合适的语句序列
1,删除P节点的直接后继结点的语句是()
2.删除P节点的直接前驱结点的语句是()
3.删除P节点的语句序列是()
4.删除首节点的是()
5.删除尾节点的语句是()
a.P=p_>next;
b.p_>next=p
c.p_>next=p_>next_>next;
d.p=p_>next_>next;
e.while(p!=null) p=p_>next;
f.while(Q_>next!=NULL) {P=Q;Q=Q_>next;}
g.while(p_>next!=Q) P=P_>next;
h.while(p_>next_>next!=Q) p=p_>next;
i.while(p_>next_>next!=NULL) p=p_>next;
J.Q=P;
K.Q=P_>next;
l.p=L;
m.L=L_>next;
n.free(Q);
hotstar20081年前1
夜里来 共回答了20个问题 | 采纳率90%
1、k ->c->n
2、j->l->h->k->c->n
3、j->l->g->c->n
4、l->j->m->n
5、l->j->f->"p->next = NULL"->n //删除尾节点需要有个->next = NULL 的赋值吧,选项没有
求数据结构算法题详细解题步骤已知线性表中的结点以关键字非递减有序排列,并以带头结点的单链表作存储结构。请写一算法,删除表
求数据结构算法题详细解题步骤
已知线性表中的结点以关键字非递减有序排列,并以带头结点的单链表作存储结构。请写一算法,删除表中关键字值为K的结点,同时释放被删结点的空间
本痴1年前1
sinkc 共回答了21个问题 | 采纳率81%
#include
using namespace std;


typedef struct LNode
{
int data;
struct LNode *next;
}LinkList;

LNode *ptr;

void CreateHeadNode(LNode *&h)
{
h = (LNode*)malloc(sizeof(LNode));
h->next = NULL;
ptr = h;
}

void Destory(LNode *&h)
{
LNode*p = NULL;
while(h->next)
{
p = h;
h = h->next;
free(p);
}
}


void Insert(int value)
{
LNode *node;
node = (LNode*)malloc(sizeof(LNode));
node->data = value;
node->next = NULL;
ptr->next = node;
ptr = node;
}


void DeleteNode(LNode *&head, int data)
{
LNode *curr = head->next;//当前节点
LNode *pre = head;//当前节点的前驱节点
//找到删除位置
while (curr != NULL curr->data < data)
{
pre = curr;
curr = curr->next;
}

//删除节点,可能有连续多个需要删除
while (curr != NULL curr->data == data)
{
LNode*del = curr;
pre->next = curr->next;
curr = curr->next;
free(del);
}
}



void DispList(LinkList *L )
{
LinkList *p = L->next;
while(p != NULL)
{
cout<data<<" ";
p = p->next;
}
cout<}

int main()
{
int data;
LinkList *list;
int arr[] = {0, 1, 3, 3, 3 ,4, 5, 6, 7, 8};

CreateHeadNode(list);
for(int i = 0; i < sizeof(arr)/sizeof(arr[0]); i++)
{
Insert(arr[i]);
}

cout<<"删除前:";

DispList(list);

cout<<"输入待删除的节点值:";
cin>>data;
DeleteNode(list, data);

cout<<"删除后:";
DispList(list);

Destory(list);
return 0;
}

vs2005测试通过:
删除前:0 1 3 3 3 4 5 6 7 8 8 9
输入待删除的节点值:3
删除后:0 1 4 5 6 7 8 8 9
Press any key to continue . . .

删除前:0 1 3 3 3 4 5 6 7 8 8 9
输入待删除的节点值:5
删除后:0 1 3 3 3 4 6 7 8 8 9
Press any key to continue . . .

删除前:0 1 3 3 3 4 5 6 7 8 8 9
输入待删除的节点值:9
删除后:0 1 3 3 3 4 5 6 7 8 8
Press any key to continue . . .
数据结构问题一道填空题: 在单链表中,要在已知结点*P之前插入一新节点,需找到____,其时间复杂度为____,而在双链
数据结构问题
一道填空题: 在单链表中,要在已知结点*P之前插入一新节点,需找到____,其时间复杂度为____,而在双链表中,完成同样操作的时间复杂度为____。
还有一个: 在一个不带头结点的单链表中,在表头插入或删除与其在其他位置插入或删除操作的过程______。
转身然后不见1年前1
zj-1038065 共回答了12个问题 | 采纳率91.7%
很久没做题了,猜的啊,你问老师不是更好嘛。有标准答案了也贴上来给我学习学习哈:
一道填空题: 在单链表中,要在已知结点*P之前插入一新节点,需找到_(前一节点)___,其时间复杂度为_(O(n))___,而在双链表中,完成同样操作的时间复杂度为__(O(1))__。
这个补充的我也不知道是相同还是不同,猜一下吧……
问题补充:
还有一个: 在一个不带头结点的单链表中,在表头插入或删除与其在其他位置插入或删除操作的过程__(不同)____。
已知head为带头结点的单循环链表的头指针,链表中的数据元素依次为(a1,a2,a3,a4,…
已知head为带头结点的单循环链表的头指针,链表中的数据元素依次为(a1,a2,a3,a4,…
已知head为带头结点的单循环链表的头指针,链表中的数据元素依次为(a1,a2,a3,a4,…,an),A为指向空的顺序表的指针.阅读以下程序段,并回答问题:
(1)写出执行下列程序段后的顺序表A中的数据元素;
(2)简要叙述该程序段的功能.
if(head->next!=head)
{
p=head->next;
A->length=0;
while(p->next!=head)
{
p=p->next;
A->data[A->length++]=p->data;
if(p->next!=head)p=p->next;
}
}
jiajiameinv1年前1
7kdcc 共回答了20个问题 | 采纳率85%
1、A的data数组中元素依次为a2,a4,a6...,A的length元素为(n/2)下取整
2、该程序将单循环链表中排在偶数次序的元素(也就是第2,4,6,8,10...)赋值到顺序表A中
若要在一个不带头结点的单链表的首结点*p结点之前插入一个*s结点时,可执行下列操作:
若要在一个不带头结点的单链表的首结点*p结点之前插入一个*s结点时,可执行下列操作:
s->next=_____________;
p->next=s;
t=p->data;
p->data= _____________;
s->data=_____________;
【答案】(1)p->next (2)s->data (3) t
看图1年前1
sgzjj1600 共回答了29个问题 | 采纳率93.1%
这其实是玩了一点技巧,并非是在p之前插入s结点,而是在p之后插入s结点,完了后,再交换两个结点的数据,后面的数据就跑到前面去了
从存储的次序而言,其最终结果就像是真正地在p前插入结点s一样
已知L是带表头结点的非空单链表,且P结点既不是首元结点,也不是尾元结点,试从下列提供的答案中选择合适
已知L是带表头结点的非空单链表,且P结点既不是首元结点,也不是尾元结点,试从下列提供的答案中选择合适
删除P结点的直接前驱结点的语句序列是_ (10) (12) (8) (3) (14).
(3) P->next=P->next->next;
(8) while(P->next->next!=Q) P=P->next;
(10) Q=P;
(12) P=L;
(14) free(Q);
刚初学链表知识不太清楚,希望您能帮帮忙~
百年孤独451年前1
lisiyu015 共回答了19个问题 | 采纳率89.5%
(10)先用Q保存结点P的指针
(12)借用P变量来指到表头来准备遍历表L
(8)遍历整个表,直到定位到Q结点的前一个的前一个结点,保存到P
Q=P->next;
(3)连接要删除的结点前后相邻两个结点
(14)此时,Q结点已被孤立,可以安全删除了
在一个头指针为L的循环链表中,指针域为next,指针P所指结点(此结点是尾结点)的条件是( ).
pppyzy1年前1
chengmiwei 共回答了20个问题 | 采纳率75%
P->next==L
数据结构题目,求教图中问题详解,主要是什么叫逆置,以及十字链表表示方式
fjz0011年前1
小布丁00 共回答了18个问题 | 采纳率83.3%
你可以看看线性代数,里面有讲
指针回指的问题 p=p--;对于一个链表 假设 其倒数第二个节点处地址是 a ,最后一个节点处的地址是 b ,指针为p
指针回指的问题 p=p--;
对于一个链表 假设 其倒数第二个节点处地址是 a ,最后一个节点处的地址是 b ,指针为p .然而利用 p=p--;为什么 此时p 指向的地址不是a ,而是 c啊.(也就是说 为什么不指向它的前一个 地址) 原因是什么啊,怎么改 才能实现 p 指向a
拉古菲儿1年前1
娃哈哈6228 共回答了24个问题 | 采纳率91.7%
p=p--; 改成 p--;
长度为n的链表进行逆序操作,请问他的时间复杂度是多少,并说明理由。
长度为n的链表进行逆序操作,请问他的时间复杂度是多少,并说明理由。
2013年计算机考研真题第一题:已知长度为m和n的升序链表,合并成一个长度为m+n的降序链表,它在最坏的情况下的时间复杂度是()。
A。O(n) B。O(mxn) C。O(min(m,n)) D。O(max(m,n))
a1anynyoo71年前1
12少 共回答了14个问题 | 采纳率85.7%
这个过程无非就是每次比较这两个升序链表的当前第一个结点,谁小,谁就先被摘下,实施头插入法插入到新链表的表头就可以了,因为无论如何次序,这m + n个结点一定都会执行这个步骤,所以总时间复杂度一定是O(m + n),自然最合适的答案就是D了
设一棵m叉树的结点树为n,用多重链表表示其存储结构,则该树中有n(m-1)+1个空指针域,怎么算的?
致胜行业软件1年前1
小小阿拉 共回答了14个问题 | 采纳率92.9%
m叉树的多重链表中每个结点有m个指针域,n个结点共有n*m个指针域,非空指针域的个数(即分支的个数)共n-1个,所以空指针域有n*m-(n-1)=n(m-1)+1
杭电acm 1216 怎样用链表解决 满意者追加30分或更多!
杭电acm 1216 怎样用链表解决 满意者追加30分或更多!
原题:http://acm.hdu.edu.cn/showproblem.php?pid=1216
assistance required
problem description
after the 1997/1998 southwestern european regional contest (which was held in ulm) a large contest *** took place. the organization team invented a special mode of choosing those participants that were to assist with washing the dirty dishes. the contestants would line up in a queue, one behind the other. each contestant got a number starting with 2 for the first one, 3 for the second one, 4 for the third one, and so on, consecutively.
the first contestant in the queue was asked for his number (which was 2). he was freed from the washing up and could *** on, but every second contestant behind him had to go to the kitchen (those with numbers 4, 6, 8, etc). then the next contestant in the remaining queue had to tell his number. he answered 3 and was freed from assisting, but every third contestant behind him was to help (those with numbers 9, 15, 21, etc). the next in the remaining queue had number 5 and was free, but every fifth contestant behind him was selected (those with numbers 19, 35, 49, etc). the next had number 7 and was free, but every seventh behind him had to assist, and so on.
let us call the number of a contestant who does not need to assist with washing up a lucky number. continuing the selection scheme, the lucky numbers are the ordered sequence 2, 3, 5, 7, 11, 13, 17, etc. find out the lucky numbers to be prepared for the next contest ***.

input
the input contains several test cases. each test case consists of an integer n. you may assume that 1
m4861年前1
NOMAN_200 共回答了15个问题 | 采纳率93.3%
这道题确实是用链表做的,用链表进行筛选法筛数.题目比较简单,下面的代码使用数组模拟链表的程序.此题也跟POJ的2552题相同!
---------------------------------------------------
#include
#include
#include
int top;
int res[3011];
struct Node{
int v;
int next;
};
Node L[50001];
int N;int main()
{
int i,j,k,p;
for(i=2;i=3001 ) break;
j=i;
while(L[j].next!=-1)
{
k=0;
while(L[j].next!=-1&&k
我还是一个C初学者,请问顺序表中的L->length(L是定义的链表,length是长度)符号“->”具体什么意思
轩辕辛羽1年前1
欧阳橙儿 共回答了22个问题 | 采纳率86.4%
等价于(*L).length
一棵树的广义表表示为a(b,c(e,f(g)),d),当用左子女-右兄弟链表表示时,右指针域非空的结点个数为( ).
一棵树的广义表表示为a(b,c(e,f(g)),d),当用左子女-右兄弟链表表示时,右指针域非空的结点个数为( ).
A 1 B 2 C 3 D 4
答案为什么是C
andy8871年前1
xsq306 共回答了26个问题 | 采纳率84.6%
一个节点右指针域不空的条件,是该节点不是其父节点的最后一个子节点.
根据题目给出的数据,
a是根节点,可以认为它是其父的最后一个节点,所以右指针域为空;
a的三个子节点中,b和c不是最后子节点,所以右指针域不空,而d的右指针域为空;
同理,e的右指针域不空,而f和g的右指针域均为空.
所以,右指针域不空的节点分别为:b,c和e,共3个,选C.
该链表大致如下:
a
/
b

c
/
e d

f
/
g
线性表:设线性表有n个元素,以下操作中,()在顺序表上实现比在链表中实现效率更高.
线性表:设线性表有n个元素,以下操作中,()在顺序表上实现比在链表中实现效率更高.
A.输出第i(1≤i≤n)个元素值
B.交换第1个元素和第2个元素的值
额,答案是选A,就是帮忙解释下B为什么是错的
wskccss1年前1
vickii 共回答了24个问题 | 采纳率91.7%
B错主要在于
链表中交换2个值,只要变动下next指针即可,没有数据的拷贝复制,而线性表需要交换2个值,需要拷贝节点的内容,节点的内容如果是个结构或者类对象的话,还涉及到构造什么的,开销还是挺大的
交换值肯定是链表比线性表快
程序设计是非题,题号:16 题型:是非题 本题分数:5内容:下面正确定义了仅包含一个数据成员info的单链表的结点类型.
程序设计是非题,
题号:16 题型:是非题 本题分数:5
内容:
下面正确定义了仅包含一个数据成员info的单链表的结点类型.struct node { int info;struct node next;}
选项:
1、 错
2、 对
--------------------------------------------------------------------------------
题号:17 题型:是非题 本题分数:5
内容:
函数fscanf只能用于对二进制文件按指定的格式读.
选项:
1、 错
2、 对
--------------------------------------------------------------------------------
题号:18 题型:是非题 本题分数:5
内容:
设:int a=1,b=2;则表达式(++a==b--)?--a:++b的值为1.
选项:
1、 错
2、 对
--------------------------------------------------------------------------------
题号:19 题型:是非题 本题分数:5
内容:
设:static long x;则变量x在程序的整个生命周期中始终存在.
选项:
1、 错
2、 对
--------------------------------------------------------------------------------
题号:20 题型:是非题 本题分数:5
内容:
赋值表达式st=(char *)malloc(sizeof(char))*10的功能是使指针st指向具有10个字节的动态存储空间.
选项:
1、 错
2、 对
心生离意1年前1
cyceq 共回答了18个问题 | 采纳率94.4%
对错对对对
数据结构题目:双链表中,在*p结点之后插入一个结点*s的操作是?
数据结构题目:双链表中,在*p结点之后插入一个结点*s的操作是?
双链表中,在*p结点之后插入一个结点*s的操作是( )
A.s->prior=p;p->next=s;p->next->prior=s;s->next=p->next;
B.s->next=p->next;p->next->prior=s;p->next=s; s->prior=p;
C.p->next=s; s->prior=p;s->next=p->next;p->next->prior=s;
D.p->next->prior=s;s->next=p->next;s->prior=p;p->next=s;
D为什么不对呢?
大葫芦1年前1
aiai321 共回答了17个问题 | 采纳率88.2%
B D都正确.
我验证过的.你可以试试
#include
using namespace std;
struct list
{
int data;
list *prior;
list *next;
};
int main()
{
list *p, *s, *q;
p = new list;
q = new list;
s = new list;
p->data = 1;
s->data = 2;
q->data = 3;
p->next = q;
q->prior = p;
p->next->prior=s;s->next=p->next;s->prior=p;p->next=s;
cout data data next->data;
}
算法设计题:1、设有一个由正整数组成的单链表,编写完成下列功能的算法:① 找出最小值结点,且输出该数值;② 若最小值结点
算法设计题:
1、设有一个由正整数组成的单链表,编写完成下列功能的算法:
① 找出最小值结点,且输出该数值;
② 若最小值结点存在直接后继结点,则进行如下操作:若最小值结点的数值是奇数,则将其与直接后继结点的数值交换;若该数值是偶数,则将其直接后继结点删除.
2、编写递归算法计算二叉树的高度.
sweetfood2k1年前1
不是浪子123 共回答了15个问题 | 采纳率93.3%
2
Int subth(BTNode *t)
{
int l,r;
if(!t)
return 0;
l=subth(t-> left);
r=subth(t-> right);
if(l
数据结构 单链表 算法两个线性表,元素 按递减次序排列,存储结构为单链表,写出算法F将两个表归为一个表,这个表元素递增有
数据结构 单链表 算法
两个线性表,元素 按递减次序排列,存储结构为单链表,写出算法F将两个表归为一个表,这个表元素递增有序,并用缘来两个单链表的结点存放 合起来的那个单链表
乔在夏1年前1
gongchunsheng 共回答了17个问题 | 采纳率94.1%
#include
// 对于节点的定义
struct Node
{
int data;
struct Node *next;
};
// 合并两个递减有序的链表
struct Node *merge(struct Node *p1, struct Node *p2)
{
struct Node *head = NULL, *p = NULL, *pt;
// 当两链表均不空时的合并逻辑
while(p1 && p2)
{
// 将两链表当前节点中值较大的一个记录下来,
// 并后移指向该链表当前节点的指针
if(p1->data > p2->data)
{
pt = p1;
p1 = p1->next;
}
else
{
pt = p2;
p2 = p2->next;
}
if(p == NULL)
{
// 若当前新链表为空,将p和head指向找到的节点
head = p = pt;
}
else
{
// 将新节点链入当前链表尾部
p->next = pt;
p = pt;
}
}
// 找到隶完成合并的那个链表,将其链接到新链表的尾部
pt = p1 == NULL ? p2 : p1;
if(pt)
{
if(p == NULL)
{
// 如果新链表仍为空,直接指向非空的链表
head = p = pt;
}
else
{
// 将未完成合并的链表链接到新链表的尾部
p->next = pt;
}
}
return head;
}
// 链表倒置
struct Node *reverse(struct Node *head)
{
struct Node *newHead = NULL, *p;
if(!head)
{
return newHead;
}
// 先将新的头指针指向原链表的第一个节点
newHead = head;
head = head->next;
newHead->next = NULL;
// 将原链表中剩下的节点依次加到新链表的头部,以实现倒序
while(head)
{
p = head->next;
head->next = newHead;
newHead = head;
head = p;
}
return newHead;
}
int main()
{
struct Node *h1, *h2, *head;
// 生成原始的两个链表的逻辑请自行编写
// 首先,合并两个链表
head = merge(h1, h2);
// 然后,将合并后的链表倒置
head = reverse(head);
// 输出处理后的链表中的内容
while(head)
{
printf("%d ", head->data);
head = head->next;
}
getchar();
return 0;
}
以上程序是按照 zhangchaoyiay 所说的算法思路编写,其实在合并的过程中,可以直接完成倒序操作,这个楼主自己琢磨一下好了,呵呵
在单链表中存取倒数第K个元素的问题.能不能遍历一次计算出个数N,通过N-K+1实现
english2531年前1
gttony 共回答了29个问题 | 采纳率93.1%
莫笑农家腊酒浑丰年留客足鸡豚山重水复疑无路柳暗花明又一村萧鼓追随春社近
求单链表中倒数第k个元素.要求:不能利用链表中元素的个数.求完整程序.
zxjjx0031年前1
芸仔 共回答了16个问题 | 采纳率93.8%
既然不能用链表中的元素个数,那就得另想办法了.
我给你思想吧.程序你自己写了.
算法思想:
1、单链表如果知道头结点的指针,那么可以顺着结点的指针域一直找下去来遍历元素.
2、那么我们可以这样,从第一个结点开始取值,然后判断这个结点到单链表结束是不是倒数第k个,如果不是,继续往下取第二个结点值,然后判断这个结点到单链表结束是不是倒数第k个,后续依次.(其中要求判断的是个循环)
还有一种算法,最笨的 就是链表转换成顺序表,不过这个顺序表的空间可是个问题哦.
程序我不想代劳了.你自己练习吧.
求单链表中倒数第k个元素 条件:1.建立一个单链表 2.不能利用链表中的元素个数 3.k由键盘输入
求单链表中倒数第k个元素 条件:1.建立一个单链表 2.不能利用链表中的元素个数 3.k由键盘输入
求单链表中倒数第k个元素
条件:1.建立一个单链表 2.不能利用链表中的元素个数 3.k由键盘输入
用算法描述,
shi0005191年前1
ysdboco 共回答了18个问题 | 采纳率66.7%
未知长度单链表求倒数第K个元素解法:
1.指针a从链表头结点移动k个位置
2.指针b从头结点开始移动,同时指针a从第k个位置开始移动,当a到达链表尾部时,指针b到达倒数第k个元素位置.
设链表长度为n,a从k到尾部移动了n-k,所以b也移动了n-k,所以b的位置是倒数n-(n-k)=k
求 实现两个链表的合并一、 设计目的 1.掌握线性链表的建立。 2.掌握线性链表的基本操作。 三、 设计内容和要求 (1
求 实现两个链表的合并
一、 设计目的
1.掌握线性链表的建立。
2.掌握线性链表的基本操作。
三、 设计内容和要求
(1) 建立两个链表A和B,链表元素个数分别为m和n个。
(2) 假设元素分别为(x1,x2,…xm),和(y1,y2, …yn)。把它们合并成一个线形表C,使得:
当m>=n时,C=x1,y1,x2,y2,…xn,yn,…,xm
当n>m时,C=y1,x1,y2,x2,…ym,xm,…,yn
输出线形表C
(3) 用直接插入排序法对C进行升序排序,生成链表D,并输出链表D。
(4) 能删除指定单链表中指定位子和指定值的元素。
元旦快乐1号1年前1
奶奶来了 共回答了21个问题 | 采纳率90.5%
我下面这个代码自己测试通过,就是少了一个删除功能,很容易额,自己加上去吧(没有任何错误)#include
#include
int m, n;
int count = 1;struct Node
{
int data;
struct Node *next;
}*A,*B,*C,*D;
//打印AList列表
void printList(struct Node *AList)
{
struct Node *post; post = AList->next;
switch(count)
{
case 1:
printf("nListA: ");
break;
case 2:
printf("nListB: ");
break;
case 3:
printf("nListC: ");
break;
case 4:
printf("nListD: ");
break;
default:
printf("nList: ");
break;
} while (post)
{
printf("%d ",post->data);
post = post->next;
} count ++;
}
//初始化表头,列表含有表头
void init()
{
A = (struct Node*)malloc(sizeof(struct Node));
A->data = 0;
A->next = 0;
B = (struct Node*)malloc(sizeof(struct Node));
B->data = 0;
B->next = 0;
C = (struct Node*)malloc(sizeof(struct Node));
C->data = 0;
C->next = 0;
D = (struct Node*)malloc(sizeof(struct Node));
D->data = 0;
D->next = 0;
}//读取列表A和B
void ReadListAB()
{
int i;
struct Node *post;
struct Node *pre;
// 输入列表长度
printf("m="); scanf("%d",&m);
printf("n="); scanf("%d",&n);//读取列表A
pre = A;
for(i=1; idata);
post->next = 0;
pre->next = post;
pre = post;
}
//读取列表B
pre = B;
for(i=1; idata);
post->next = 0;
pre->next = post;
pre = post;
}
}
//合并列表A和B
void MergeABToC()
{
int i;
struct Node *pre, *postA, *postB, *postC; pre = C;
postA = A->next;
postB = B->next;

if(m >= n)
{
for(i=1; idata = postA->data;
postC->next = 0;
pre->next = postC;
pre = postC;
postC = (struct Node*)malloc(sizeof(struct Node));
postC->data = postB->data;
postC->next = 0;
pre->next = postC;
pre = postC; postA = postA->next;
postB = postB->next; }
for(i=n+1; idata = postA->data;
postC->next = 0;
pre->next = postC;
pre = postC;

postA = postA->next;
}
}
else
{
for(i=1; idata = postB->data;
postC->next = 0;
pre->next = postC;
pre = postC;
postC = (struct Node*)malloc(sizeof(struct Node));
postC->data = postA->data;
postC->next = 0;
pre->next = postC;
pre = postC; postA = postA->next;
postB = postB->next; }
for(i=m+1; idata = postB->data;
postC->next = 0;
pre->next = postC;
pre = postC;

postB = postB->next;
}
}

}//使用直接插入法,将C排序输出D
void SortCToD()
{
struct Node *pre, *postC, *postD, *lopD;
int len;
//表示总的长度
len = m + n;
pre = D; //指向D有序数列的尾指针
postC = C->next; //指向C列表 //列表D第一个节点加入
postD = (struct Node*)malloc(sizeof(struct Node));
postD->data = postC->data;
postD->next = 0; pre->next = postD;
pre = postD;
postC = postC->next;
while (postC)
{
//pre为指向插入的前一个节点,lopD是指向插入的后一个节点
pre = D;
lopD = D->next; while (lopD)
{
if (lopD->data > postC->data)
break;
else
{
pre = lopD;
lopD = lopD->next;
} } //将节点插入
postD = (struct Node*)malloc(sizeof(struct Node));
postD->data = postC->data;
postD->next = 0; pre->next = postD;
postD->next = lopD;


//循环条件
postC = postC->next;

}
}void main(void)
{
init();
ReadListAB();
MergeABToC();
SortCToD(); printList(A);
printList(B);
printList(C);
printList(D);
}
设用一个循环链表来表示一个队列,该队列只设一个尾指针,试分别编写向循环队列插入和删除一个结点的算法
golfer_lee1年前1
loveyy213 共回答了18个问题 | 采纳率83.3%
尾指针为L,
节点p入队
if(L==NULL) //空队列
{
p->next=p;
}
else
{
p->next=L->next;
L->next=p;
}
L=p;
出队:
node *p;
if(L==NULL) //空队列
return NULL;
if(L->next==L)//就一个节点
{
p=L;
L=NULL;
}
else
{
p=L->next;
L->next=p->next;
}
p->next=NULL; //可以不用
return p;
假设某个单向循环链表的长度大于1,且表中既无头结点也无头指针.已知s为指向链表中第s个元素,试编写算法
假设某个单向循环链表的长度大于1,且表中既无头结点也无头指针.已知s为指向链表中第s个元素,试编写算法
Sample Input
5
1 3 2 7 5
3
Sample Output
1 2 7 5
leeqjun1年前1
故mm情 共回答了16个问题 | 采纳率93.8%
题目的意思就是删除s指向的结点.算法为:将s的下一个元素的的值赋给s,然后删除s的下一个结点,(删除结点就是next指针的操作).时间复杂度是常数级.
如果一个逆序序列是用单链表表示的话.欲得到这个逆序排列的数据元素序列的正序输出序列的有效方法是什么
如果一个逆序序列是用单链表表示的话.欲得到这个逆序排列的数据元素序列的正序输出序列的有效方法是什么
河工大2010年计算机考研的一道问答题
xiaoran_11年前1
maqin1981 共回答了16个问题 | 采纳率100%
单链表倒置(使用头插法就可以轻松实现),然后从头到尾遍历一次,就是正序输出.不需要用到栈.
给定一棵用链表表示的二叉树,其根结点指针为t,编写求二叉树的叶子数目的算法。
给定一棵用链表表示的二叉树,其根结点指针为t,编写求二叉树的叶子数目的算法。
算法思想:可以用一个指针栈来实现,且其最大容量为maxsize,二叉树根指针为t,以二叉链表作存储结构。若一个结点的左孩子和右孩子均为空,则为叶子结点,若左或右不为空则进栈,计算栈内元素的个数即为叶子结点数。
qinhai81621年前1
妖精无泪呵 共回答了15个问题 | 采纳率93.3%
将二叉树遍历一边即可
static int count = 0;//记录二叉树叶子节点的个数
struct Node{
int data;
Node *rigthNode;//右孩子
Node *leftNode;//左孩子
};
int fine_Node(Node * t)//Node 表示二叉树节点
{
if(t == Null)
{
return 0;
}
else if((fine_Node(t->rigthNode)+fine_Node(t->leftNode)) != 0)
{
return 1;
}
else
{
count++;
return 1;
}
}
数据结构用单链表操作.统计英文文章单词出现个数.
鱼心冰1年前1
飞舞de风筝 共回答了16个问题 | 采纳率100%
你没说什么语言.
大概思路就是数空格
读文章开始前 建立链表头
以后每遇到空格就插入一个新的单链表以存储单词
最后
空格数+1=主链表节点数=单词数