順序表的逆置演算法

① 試用一個演算法，實現順序表的就地逆置，

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）。