最好的方法就是用一个中间变量,比如TEMP,把第一个元素和最后一个元素调换位置,第二个与倒数第二个调换,以此类推,最后中间两个调换,或中间一个不变
具体的程序根据这样的思路编就行了

#define N 255
main()
{  int a[N],i,t,n;
   printf("请输入数组的个数n:\n");
   scanf("%d",&n);
   printf("Enter array a:\n");
   for(i=0;i<n;i++)
       scanf("%d",&a[i]);
   printf("array a:\n");
   for(i=0;i<n;i++)
       printf("%4d",a[i]);
   for(i=0;i<n/2;i++)
      { t=a[i];
        a[i]=a[n-i-1];
        a[n-i-1]=t;

   } 
   printf("\nNow array a:\n");
   for(i=0;i<n;i++)
       printf("%4d",a[i]);
   printf("\n");

}


  这是一个逆置的程序,可以帮你逆置所有数.若想输入更多就将#define 的N增大!

恩,有几部不怎么看得懂啊?

void Inverse(SqList &L)
{
 int i,j,temp;
 for(i=0,j=L.length-1;i<j;i++,j--)
   {
    temp=L.elem[i];
    L.elem[i]=L.elem[j];
    L.elem[j]=temp;
   }
}

这样应该看得清楚了吧

(一)数组的逆置
(1)算法

#indclude<stdio.h>

#define N  8

main()
{ 

    int array[N] = {100,90,80,70,60,50,50,40};
    int i,j,t;

    for(i=0,j=N-1;i<j; i++, j--)     
    {     
            t        = array[i];
         array[i] = array[j];
         array[j] = t;
     }

     for(i=0,i<listsize;i++)
          printf("%d",qlist.data[i])
}

(2)时间复杂度
由于只需循环N/2即可完成逆置,所以时间复杂度为O(N/2).


(二)单向链表的逆置

(1)算法

//定义结构体
struct  t_node
{
  int data;
  struct t_node *next;
};
//定义别名
typedef struct  t_node Node;

//定义链表变量
Node  * example_link = NULL;

/*
*功能：逆转链表
*输入：x = 原链表
*输出：无
*返回值：逆转后的新链表
*/
Node reverse( Node * x)
{
  if( NULL==x )
    return NULL;
  
  link t=NULL;
  link r=NULL, y=x;  //(0)
  while(y!=NULL)
  {
    t = y->next;   //(1)
    y->next = r;   //(2)
    r = y;         //(3) 
    y = t;         //(4)
   }

  return r;     //返回逆置后的链表
}

/*
*功能：初始化链表
*输入：无
*输出：无
*返回值：无
*/
void Init_Link(void)
{  
  Node *pNext = NULL; //游标
   //头节点
   example_link = (Node *)malloc( sizeof(Node) );    
   if(NULL == example_link)
       return;
   example_link->data = 100;
   example_link->next = NULL;

  //中间节点
  pNext = example_link; //为游标赋值
  for(i=1,i<N,i++)
  { 
    pNext->next = (Node *)malloc( sizeof(Node) );    
     if(NULL == pNext->next)
       return;
    pNext->next->data = 100 - i*10;
    pNext->next->next = NULL;
    pNext = pNext->next; //移动游标
  }

}


main()
{ 
  int i,n;
  Node *pNext = NULL;
  Node *reverse_link = NULL;

  //初始化链表
  Init_Link();

  if(NULL == example_link)
       return;

   //显示原链表
   printf("原链表数值:\n");
   pNext = example_link;   
   while(pNext != NULL)
   {
      printf("%d, ",pNext->data);
      pNext = pNext->next;
   }
   printf("\n");

   //逆置链表
   reverse_link = reverse(example_link);

   printf("逆置后的链表数值:\n");
   pNext = reverse_link;   
   while(pNext != NULL)
   {
      printf("%d, ",pNext->data);
      pNext = pNext->next;
   }

   getch();

}//endmain()

(2)时间复杂度
由于 reverse函数须遍历整个链表,所以时间复杂度为O(N).