线性链表是存储结构还是逻辑结构

正确的是：A
链表是不能采用二分查找的,因为链表不具备随机访问特性.
二分查找的必要条件是：
线性表,有序；

答案是全错.
正确答案是
pt1 = q->next; free(q); p->next = pt1;
原因：
设这个链表依次是p->q->A->……
如果要删除q,其实就是变成p->A->……
关键在于,直接free(q)的话,q->next,也就是A的地址就丢失了.
所以在free(q)之前,先要保存A的地址.
pt1 = q->next; // q的next就是A的地址
free(q);
p->next = pt1; // p的next变成A的地址

这个我不懂

线性表、栈、队列属于线性结构，只有二叉树是非线性结构。这题选A

首先实现一个单链表，代码如下：#include #include #include #include typedef struct student { int data; struct student *...

第一题：var a:array[1..10]of longint; i,maxans,minans:longint;function max(x,y:longint):longint;begin if x>y then exit(x) else exit(y);end;function min(x,y:longint):longint;begin if xy then...

/*---reverseList.c---------逆置现行链表的demo，
外加了创建和打印链表的函数。希望对你有用--------------------------------------*/
#include
#include
typedef struct point{
int data;
struct point *next;
} node;
node *reverse(node *list) /*反转*/
{
node *t1=NULL,*t2;
while (list)
{
t2=t1;
t1=list;
list=list->next ;
t1->next =t2;

}
return t1;
}
node *creatList(void)
{
node *list=NULL;
int i;
scanf("%d",&i);
if (i!=-1) {
list=malloc(sizeof(node));
list->data =i;
list->next =creatList();
}
return list;
}
void printList(node *list)
{
while (list!=NULL)
{
printf("%dt",list->data );
list=list->next ;
}
}
int main(void)
{
node *list=creatList();
printList(list);
putchar(10);
list=reverse(list);
printList(list);
return 0;
}

我下面这个代码自己测试通过，就是少了一个删除功能，很容易额，自己加上去吧（没有任何错误）#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);
}