设线性表A =（a1,a2,…,am）,B=（b1,b2,…,bn）,试写一个算法

#include
#include
#define MAXSIZE 100
typedef int ElemType;
typedef struct list
{
ElemType *elem;
int listsize;
int length;
}Sqlist;
void initlist_sq(Sqlist *L)
{
L->elem=(ElemType *)malloc(MAXSIZE*sizeof(ElemType));
if(!L->elem) exit(0);
L->length=0;
L->listsize=MAXSIZE;
}
void insert_sq(Sqlist *L,int n,int x)
{
int i=0;
if(n(L->length))
{printf("错误");
exit(1);}
if(L->length==MAXSIZE)
{printf("overflow");
exit(1);
}
if(n>=0&&nlength)
*(L->elem+n)=x;
if(n==(L->length))
{*(L->elem+n)=x;
L->length=L->length+1;}
//printf("n");
printf("X=EXIT,C=CREAT,P=DISPLAY,I=INSER,S=SEARCT,D=DELETEn");
break;
case 'S':
case 's':
printf("please input the number wantedn");
scanf("%d",&temp);
printf("位置:%dn",Search_sq(&L1,temp));
printf("X=EXIT,C=CREAT,P=DISPLAY,I=INSERT,S=SEARC,D=DELETEn");
break;
case 'P':
case 'p':
display_sq(&L1);
printf("X=EXIT,C=CREAT,P=DISPLAY,I=INSERT,S=SEARC,D=DELETEn");
break;
case 'X':
case 'x':
free(L1.elem);
return 1;
case 'd':
case 'D':
printf("请输入要删除的位置n");
scanf("%d",&temp);
delete_sq(&L1,temp-1);
printf("X=EXIT,C=CREAT,P=DISPLAY,I=INSERT,S=SEARC,D=DELETEn");
break;

default:break;
}
}

//getchar();
return 1;
}

1.假设αr可由α1,α2,.,αr-1线性表出,则
αr=k1α1+k2kα2+…+kr-1αr-1
由条件知
β=P1α1+P2α2+…+Prαr
∴β=P1α1+P2α2+…+Pr(k1α1+k2kα2+…+kr-1αr-1)
可整理成
β=(P1+Prk1)α1+(P2+Prk2)α2+…+(Pr-1+Prkr-1)αr-1
即β可由α1,α2,.,αr-1线性表出,这与题设矛盾
故αr不能由α1,α2,.,αr-1线性表出
2.Pr必不等于0,因为如果等于0,则β可由α1,α2,.,αr-1线性表出,这与题设矛盾
β=P1α1+P2α2+…+Prαr
由于Pr≠0,两边同除以Pr,再移项,就可以看到αr已由α1,α2,.,αr-1,β线性表出,各项系数都是存在的
因此αr能由α1,α2,.,αr-1,β线性表出

(a1,a2,a3,a4) =
-1 2 -1 15
1 -1 2 -7
2 1 7 10
-1 -3 -6 -25
r2+r1,r3+2r1,r4-r1
-1 2 -1 15
0 1 1 8
0 5 5 40
0 -5 -5 -40
r1-2r2,r3-5r2,r4+5r2,r1*(-1)
1 0 3 1
0 1 1 8
0 0 0 0
0 0 0 0
所以 a1,a2 是一个极大无关组
a3 = 3a1+a2
a4 = a1+8a2

如果是指定值为x的元素的话那就没有顺序表与链表的差别了,都是从第一个元素开始顺序查找.假设长度为n的线性表中只有一个值为x的元素,则从第一个元素起到找到值为x(假设为第i个元素）比较i次,删除i后,第i+1个元素到第n个元素都要移动,移动n-(i+1)+1即n-i次,故比较元素和移动元素的总次数为n次.注：以上答案是针对线性表中只有一个值为x的元素,若有多个值为x的元素则总次数是不确定的.

|A|=0与A的行（或列）向量组线性相关等价,因此,|A|=0,则A中必有一列向量可由其余列向量线性表出的结论是对的.
矩阵的行秩与列秩相等,对于方阵而言不可能出现行向量组线性相关而列向量组线性无关的情况.但对于非方阵,则有可能

#include
#define MAXSIZE 50
using namespace std;typedef struct node //链式结构线性表结点
{
int data;
struct node *next;
}SLink;typedef struct list //顺序结构线性表结点
{
int length;
int data[MAXSIZE];
}List;void LinkList() //链式
{
//初始化链表
SLink *La=(SLink *)malloc(sizeof(SLink));
SLink *n1=(SLink *)malloc(sizeof(SLink));
SLink *n2=(SLink *)malloc(sizeof(SLink));
SLink *n3=(SLink *)malloc(sizeof(SLink));
SLink *n4=(SLink *)malloc(sizeof(SLink));
SLink *n5=(SLink *)malloc(sizeof(SLink));
La->next=n1;//La为头指针
n1->data=1;
n1->next=n2;
n2->data=2;
n2->next=n3;
n3->data=3;
n3->next=n4;
n4->data=4;
n4->next=n5;
n5->data=5;
n5->next=NULL;
//输出链表的值
coutnext;
La->next=q;
}
//输出逆序后链表
cout

二分查找的最大查找次数为 [ log2 n ] + 1
所以 256 个节点就是 9 次
100 个节点就是 8 次

(α2,α3)=1,说明α2,α3线性相关,α3能被α2表出,从而能被α1,α2表出
所以α1,α2上加一个α3,不会增加秩.

假设插入的是第i个 0

因为 a1是a2,a3,.,as的线性组合
所以
存在k2,...ks使得
a1=k2a2+k3a3+.++ks-1as-1+ksas
从而
ksas=a1-k2a2-k3a3-.-k(s-1)a(s-1)
假设ks≠0
则
as=1/ksa1-k2/ksa2-.-k(s-1)/ks a(s-1)
与已知as不能由a1,a2,.,as-1表示矛盾
所以
假设不成立,即ks=0
从而
a1=k2a2+k3a3+.++ks-1as-1
即
a1可以由a2,a3,.,as-1线性表示.

时间复杂度为O(n)、空间复杂度为O(1)?
那就一个一个去比较是不是item值,
假设 第m到第n个 是item 值,那就 把第n+1个元素替换第m个,依次下去

选A
因为向量可由向量组线性表示,例如向量a=k1*a1+k2*a2+...+kn*an,把等式左边的a移到右边去,就变成k1*a1+k2*a2+...+kn*an-a=0,而a与a1,a2,...,an线性相关,故存在一组不全为0的数,使得上边等式成立.

是的
定理:向量组线性相关的的充分必要条件是至少存在一个向量可由其余向量线性表示
或 向量组线性无关的充分必要条件是任一向量都不能由其余向量线性表示

如满意，望及时采纳，如有问题请追问
#include
#include
#define M 5
#define N 6
typedef struct node
{
int data;
struct node *next;
}LinkNode, *LinkList;
LinkList Creat(int *arr, int n)
{
int i;
LinkList p = NULL;
LinkList q = NULL;
LinkList head = NULL;
head = (LinkList) malloc (sizeof(LinkNode));
head->next = NULL;
q = head;
for (i=0; inext = NULL;
p->data = arr[i];
q->next = p;
q = p;
}
return head;
}
void Merger(LinkList LA, LinkList LB)
{
LinkList p1 = LA->next;
LinkList p2 = LB->next;
LinkList p3 = NULL;
LinkList tmp = NULL;
p3 = LA;
free(LB);
while ((NULL != p1) && (NULL != p2))
{
if (p1->data data)
{
p3 = p1;
p1 = p1->next;
}
else
{
tmp = p2->next;
p2->next = p1;
p3->next = p2;
p3 = p2;
p2 = tmp;
}
}
if (NULL == p1)
{
p3->next = p2;
}
else
{
p3->next = p1;
}
}
void Output(LinkList head)
{
LinkList p = head->next;
while (NULL != p)
{
printf("%d ", p->data);
p = p->next;
}
printf("n");
}
int main(void)
{
int arrOne[M] = {3, 5, 8, 11, 24};
int arrTwo[N] = {2, 6, 8, 9, 11, 20};
LinkList LA = NULL;
LinkList LB = NULL;
LA = Creat(arrOne, M);
LB = Creat(arrTwo, N);
Merger(LA, LB);
Output(LA);
return 0;
}

#include
using namespace std;
struct Node
{
int data;
Node *next;
};
class LinkList
{
public:
Node * intLinkList(int a[],int n)
{
first=new Node;
first->next=NULL;
for(int i=(n-1);i>=0;i--)
{
Node *s;
s=new Node;
s->data=a[i];
s->next=first->next;
first->next=s;
}
x05 return first;
}
void PrintList()
{
Node *p;
p=first->next;
while(p)
{
coutnext;
while(p && q)
{
if(p->datadata)
{
A->next=p->next;
p=p->next;
}
else if(p->data>q->data) q=q->next;
else{
p=p->next;
q=q->next;
}
}
}
void Bingji(Node *A,Node *B)
{
Node *p,*q,*r;
p=A->next; q=B->next;
while(p&&q)
{
if(p->datadata){ r=p; p=p->next;}
else if(p->data>q->data)
{
B->next=q->next;
q->next=p;
r->next=q;
q=B;
}
else if(p->data=q->data){
x05x05x05 r=p;
p=p->next;
q=q->next;
}
x05x05
}
r->next=q;
}
void Chaji(Node *A,Node *B)
{
Node *p,*q;
p=A->next; q=B->next;
while(p &&q)
{
Node *r;
if(p->datadata)
{
r=p;
p=p->next;
}
else if(p->data>q->data) q=q->next;
else{
Node *s;
s=p;
r->next=p->next;
p=r->next;
delete s;
}
}
}
void main()
{
x05cout

给你一个判断题：
顺序表结构适于进行顺序存取，而链表适于进行随机存取。请判断。
答案：错误。
刚好弄反了。
知道这，就能解决你的问题了。 谢谢加分~

选择题是可以有技巧的
题目说的是n和i,也就是说n和i是具有通用性的,对任何数字都成立,那么
你想想长度为5的表,你要在第四位插入一个数,是什么样的结果呢?
就是前三位不动,然后你挤进去一个第四位数,原来的第四第五位数就只能往后移了,也就是移了两个
那么2当然应该是等于5-4+1
选B

设(m+1)个数x1,x2,…xm,y满足x1a1+x2a2+…+xmam+y(kB1+B2)=0,(1)
若y≠0,则B2=(x1a1+x2a2+…+xmam)/y-kB1,
B1可由a1 a2 .am线性表示,B2不能由他们线性表示, 矛盾.
∴y=0,由（1）得x1=…=xm=0,命题成立.

主要是写charu函数,其他的细节你自己看着写吧~!
算法思想很简单：就是从最后一个数据开始,将第wh个数据及之后的数据都向后移就行了,最后将要插入的数据放到第wh个位置
数据结构语言?这是什么语言?c#? java? .asp?...你们学的是什么版的数据结构? 这说的麻烦,你要有时间百度hi我吧
int st[20]={2,3,4,22,5,6,12,3};
int n=8;
charu(int num,int wh)//num是要插入的数据,wh是要插入的位置,wh指的是数组的下标
{
int i;
for(i=n-1;i>=wh;i--)
{
st[i+1]=st[i];
}
st[i+1]=num;//循环结束后,i已经指到了要插入位置的前一个元素,所以加1
}
main()
{int i=0;
for(i=0;i

不用,它是一个引入量,其实只起到辅助的作用,最后对结果都没有影像的.
你不明白的那个,你看下设的方程a1=a11b1+a21b2,a2=a12b1+a22b2,a3=a13b1+a23b2
在把他带入原来的方程x1a1+x2a2+x3a3
x1a1+x2a2+x3a3=x1(a11b1+a21b2)+x2(a12b1+a22b2)+x3(a13b1+a23b2)=(a11x1+a12x2+a13x3)b1+(a21x1+a22x2+a23x3)b2
你把它拆开合并同类项.比较下系数,就是
x1a1+x2a2+x3a3方程跟后面方程对照,就会出现多出一些项,这样的话这些项必须等于0
所以必须满足a11x1+a12x2+a13x3=0
a21x1+a22x2+a23x3=0
这样说明理解吗?

是的.

你需要了解的是线性方程组的向量形式
将A按列分块, A=(a1,...,an)
X=(x1,...,xn)
则由分块矩阵的乘法 Ax=b 可写为 x1a1+...+xnan = b
所以 Ax=b 有解的充分必要条件是 b 可由A的列向量线性表出, 组合系数即解向量的分量.

当A可逆时, Ax=b 有唯一解
故此时b可由A的列向量线性表出, 且表示方法唯一.

向量组a1,a2,.an【n大于或等于2】线性相关的充要条件是 向量组a1,a2,.an中至少有一个向量能由其余n-1个向量线性表示.所以向量组a1,a2,.an线性无关的充要条件是 a1,a2,.an中不存在一个向量能由其他n-1个向量线性表示.选C.

1 p->next=p->next->next;
2 q=head->next;
while(q&&q->next!=p) q=q->next;
q->next=p->next;
3 p=head;
while(p->next->data==x){p=p->next; printf("yes");return;}
printf("no");

因为是顺序表,例如S列第一个元素就比K大,直接就可以抛出
而二分的B列,是中中间开始的,因此不能直接抛出.

#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 . . .

对的

｛32,75,29,638,4,94,256,3,81,70,94,80｝,12个值
HT[0,...,12],13个空间
12个值的地址空间怎么会是13个呢?
不理解了,你是不是搞错了?

问题一；向量组2的意思就是方程组的极大无关组,个数也就是秩；
问题二；那个部分线性组就是把矩阵进行初等变换后得到的极大无关组,不能随便去掉一行,但得到的极大无关组也并不唯一,就是说把对应成比例的去掉只剩一个就行了.
初等变换会吧,就是化成行阶梯形.

(D) 正确, A中必有列向量可由其余向量线性表示
|A|=0 A的列向量组线性相关.

存取任意指定序号的元素用顺序表更方便，单循环链表必须从链表头一个一个向下寻找指定序号的元素，不能很方便地直接存取任意指定序号的元素。
最后进行插入和删除运算，感觉说得不是很清楚，我理解是在表的最后插入与删除，那当然顺序表更方便一点，单循环链表还要修改前后链表的指针数据。
希望对你有帮助，有问题还可以再HI我。~

分析：
用你上面图中的十个格子举例子,编号1-10,要删除第3,4个元素.此时,i = 2(从0开始算,第三个元素就是i = 2), k = 2（要删除2个元素）
这里for循环循环了三次,循环第一次,将第3个元素的值替换为第5个元素的值,循环第二次就是将第4个元素的值替换为第6个元素的值.循环第三次,将第5个元素的值替换为第7个元素的值.
for循环后面一条语句的意思是a列表的长度减2.
结论：
这个逻辑是有问题的,的确是有你所说的空隙存在.正确的写法应该是for(j = 0; j < a.length -i - k; j++)这个for循环才是把后面的元素全部往前覆盖2个元素的位置.

二次为2个
四次的为8个
平均查找长度为（1x1+2x2+3x4+4x8+5x5)/20=74/20
先构造长度为20的折半查找判定树,其他的就OK了,判定树如下
10
/
5 15
/ /
2 7 12 18
/ / / /
1 3 6 8 11 13 16 19

4 9 14 17 20

A的属于特征值λ=-1的特征向量都是齐次线性方程组 (λE-A)X = 0 的解. ----这个是关键!
因为 r(-E-A) = 2, A是3阶方阵
所以齐次线性方程组 (-E-A)X=0 的基础解系所含解向量的个数为 3-2 = 1.
所以 属于特征值 -1 的线性无关的特征向量只有一个
所以 ξ 是齐次线性方程组 (-E-A)X=0 的基础解系
属于特征值 -1 的特征向量都可由 ξ 线性表示.
其他的属于特征值 -1 的特征向量都可由 (-E-A)X=0 的基础解系 线性表示, 当然与ξ 线性相关.

log2（n）

#include
#include
#include
typedef int status;
typedef int ElemType;
#define TRUE 1
#define ERROR 0
#define FALSE 0
#define OK 1
#define OVERFLOW -2
#define list_init_size 100
#define listincrement 10
typedef struct{
x05ElemType *elem;
x05int length;
x05int listsize;
}sqlist;
status equal(ElemType a,ElemType b)
{if(a==b)
return TRUE;
else
return FALSE;
}
int listlength(sqlist l)
{ return l.length;}
status listinsert(sqlist *l,int i,ElemType e)
{
x05ElemType *newbase,*q,*p;
x05if(i(*l).length+1)
x05return ERROR;
x05if((*l).length>=(*l).listsize){
x05x05newbase=(ElemType*)realloc((*l).elem,((*l).listsize+listincrement)*sizeof(ElemType));
if(!newbase) exit(OVERFLOW);
x05 (*l).elem=newbase;
x05 (*l).listsize+=listincrement;
}
q=&((*l).elem[i-1]);
for(p=&((*l).elem[(*l).length-1]);p>=q;--p)
x05 *(p+1)=*p;
*q=e;
++(*l).length;
return OK;
}
status initlist(sqlist *l){
x05(*l).elem=(ElemType*)malloc(list_init_size*sizeof(ElemType));
x05if(!(*l).elem)
x05x05exit(OVERFLOW);
x05(*l).length=0;
x05(*l).listsize=list_init_size;
x05return OK;
}
status getelem(sqlist l,int i,ElemType *e)
{ if(il.length)
exit(ERROR);
*e=*(l.elem+i-1);
return OK;
}
int LocateElem(sqlist L,ElemType e,status(*compare)(ElemType,ElemType))
{
ElemType *p;
int i=1;
p=L.elem;
while(i

设A组向量为(a1,a2,...,an),
B组向量为(b1,b2,...,bn)
C组向量为(c1,c2,...,cn)
则由题意可知：存在非零实数p,q使得ai=pbi,bi=qci
所以ai=pqci (i=1,2,...,n)
即：A组向量也可用C组向量线性表出.

证明：
由向量组[a+c,b+c]线性相关,得线性关系
b+c=k(a+c)+m
化解得
(1-k)c=k*a+m-b
假设k=1,得
0=a+m-b,即
b=a+m 线性关系
这与已知向量组[a,b]线性无关相矛盾,所以假设不成立
即k不等于1
所以
c=k/(1-k)*a-b/(1-k)+m/(1-k)
即
向量c可由[a,b]线性表出

1.如果A不能由B线性表出,是不是RA就大于RB了?
不是.这时候不一定哪个大
2.一般情况不能推出有效信息
比如你考虑20维向量,A的后10个分量都是0,B组的前10个分量都是0
那么A,B组谁也不能表示谁
他们的秩在 1到10之间,不一定哪个大.
但也有特殊情况,这要根据题的已知条件.
比如,一个3维向量 若不能由一个由3个3维向量构成的向量组线性表示
那么,那个向量组一定是线性相关的.

1.A 2.B 3.B 4.C 5.B 6.D 7.D 8.B 9.C 10.B 11.B 12.C 13.C 14.D 15B

最糟糕的情况应该是比较到线性表最后一个值,也没有查找到所需要的值,那么从线性表的第0个值开始比较,每次取出一个值比较,不符合,再取下一个值,依次比较,一直到最后一个,那么长度为N,就需要比较N次.

#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 所说的算法思路编写，其实在合并的过程中，可以直接完成倒序操作，这个楼主自己琢磨一下好了，呵呵

复杂度O(n)的意思的 ：该代码的算法能力与n的一次方有关系的.
在这道题目里面 在第i个位置插入后 需要让线性表向后移动n+1-i.该算法与n的一次方有关系 所以是复杂度O(n) .虽然 平均数的算法是n/2
但是 复杂度的表示只有O(1) O(n) O(logn) .

前几天刚写了合并的链表,留下邮箱,明天发给你,看了我的之后你肯定能写出这个题,只需修改一段代码即可

你要的是算法还是程序?如果是程序,是C还是C++或者其他语言?

(1)2.211/3(2)2.2

你上面第2个矩阵写错了
因为β不能用α1,α2,α3线性表出,所以拓展矩阵
[1 2 0 | 3]
[4 7 1 | 10] 无解
[0 1 -1 | b]
[2 3 a | 4]
然后在行变换得出
[1 2 0 | 3]
[0 -1 1 | -2]
[0 0 a-1 | 6]
[0 0 0 | b-2]
根据举证当a=1或者b不等于2时,矩阵的秩小于拓展矩阵的秩,无解,β不能用α1,α2,α3线性表出
当a不等于1,且b=2时,有解,β可以用α1,α2,α3线性表出,
然后就解个矩阵就行了,时间关系,不做了,如果有疑问,再问我吧

n个元素,就是插入在第一个位置,所有的都移动