顺序表的逆置算法
① 试用一个算法，实现顺序表的就地逆置，
int a[n]; //....
for(int i=0;i<n/2;i++)
{
int t=a[i];
a[i]=a[10-i-1];
a[10-i-1]=t;
}
② 顺序表逆置的算法思想和算法实现是什么
试写一算法，实现顺序表的就地逆置。
即利用原表的存储空间将线性表(a1,a2,…,an)
逆置为(an,an-1,…,a1)。
实现下列函数：
void Inverse(SqList &L);
顺序表类型定义如下：
typedef struct {
ElemType *elem;
int length;
int listsize;
} SqList;
void Inverse(SqList &L)
③ 写一个算法，实现顺序表的就地逆置，即在原表的存储空间将线性表（a1,a2,...an-1,an）逆置为（an,an-1,...
运行过了，没有任何问题，有什么不明白的可以交流下！！
#include <stdio.h>
int main()
{
typedef struct Lnod
{
int data;
struct Lnod *next;
}Lnod,*Linklist;
Linklist p,m,n,r,L,a,b;
int i;
L=(Linklist)malloc(sizeof(Lnod)*5);
if(!L)exit(0);
L->next=NULL;
for(i=0;i<5;i++)
{
p=(Linklist)malloc(sizeof(Lnod));
if(!p)exit(0);
scanf("%d",&p->data);
p->next=L->next;
L->next=p;
}
a=L->next;
printf("原来的链表中的元素为：\n");
while(a)
{
printf("%d, ",a->data);
a=a->next;
}
printf("\n");
m=L->next;
n=m->next;
while(n->next)
{
r=n->next;
n->next=m;
m=n;
n=r;
}
n->next=m;
L->next->next=NULL;
L->next=n;
b=L->next;
printf("\n\n逆置之后链表中的元素为：\n");
while(b)
{
printf("%d, ",b->data);
b=b->next;
}
printf("\n");
return 0;
}
c编程高手团队正在招新，有意者速速行动，一起学习，一起努力！！！
④ 【数据结构】线性表(包括有序表)在顺序表和链表上的插入、删除、逆置操作算法
1）初始化指针p和q，分别指向链表中相邻的两个元素；
2）当p->next不为空时，做如下处理：
①若相邻两元素不相等时，p和q都向后推一步；
②否则，当相邻元素相等时，删除多余元素。
【算法源代码】
void Delete_Equal(LinkList *L)
{ p=(*L)->next;q=p->next; /*p和q指向相邻的两个元素*/
while(p->next)
{ if(p->data!=q->data) /*若相邻两元素不相等时，p和q都向后推一步*/
{ p=p->next; q=p->next; }
else
{ while(q->data==p->data) /*当相邻元素相等时删除多余元素*/
{ r=q;
q=q->next;
free(r);
}
p->next=q;p=q;q=p->next;
}/*else*/
}/*while*/
}/*Delete_Equal */
试设计一个算法，对带头结点的单链表实现就地逆置。
【算法分析】
1）空表或长度为1的表，不做任何处理；
2）表长大于2时，做如下处理：
①首先将整个链表一分为二，即从链表的第一元素结点处断开；
②逐个地把剩余链表的当前元素q插入到链表的头部。
【算法源代码】
void LinkList_reverse(LinkList L)
{ if(!L->next||!L->next->next) return;
p=L->next; q=p->next; s=q->next; p->next=NULL; /*从链表的第一元素结点处断开*/
while(s->next)
{q->next=p;p=q;
q=s;s=s->next; /*把L的元素逐个插入新表表头*/
}
q->next=p;s->next=q;L->next=s;
}/*LinkList_reverse*/
⑤ 数据结构:设计一个高效算法，将顺序表中的所有元素逆置，要求算法空间复杂度为O(1)。
数据结构的高效算法：for(int i = 0; i < array.length / 2; i++) {swap(array[i], array[array.length - i - 1])}
只有swap函数需要一个字节的内存，所以空间复杂度O（1）。