（C语言）设计并验证以下算法：设顺序表L中的数据元素为整且非递增有序，删除其值相同的多于元素，既顺序表L中相的元素只保留一个，并逆置删除后的顺序表L。

 （C语言）设计并验证以下算法：设顺序表L中的数据元素为整且非递增有序，删除其值相同的多于元素，既顺序表L中相的元素只保留一个，并逆置删除后的顺序表L。

1. 根据键盘输入数据建立顺序表L。
2. 输出顺序表L、删除值相同的多余元素后的顺序表L、逆置的顺序表L。
3. 假设顺序表L的长度为n，要求以O（n）的时间复杂度完成对值相同多余元素的删除

 

 //创建顺序表

typedef struct
    {	
        ElemType *elem;
        int length;
    	int listsize;
	}Sqlist;

//初始化线性表（构造一个空的线性表）

int InitList(Sqlist &L)
    {
    	L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));
    	if(!L.elem) exit(-1);
    	L.length = 0;
		L.listsize = LIST_INIT_SIZE;
		return 0;
	}

//删除线性表相同元素

 

void DelateElem(Sqlist &L)
    {
    	int i,j,n;
    	n = L.length;
    	i = 0;
       while(L.elem[i] != NULL)
        { 
            if(L.elem[i] == L.elem[i+1])
                {
                    for(j = i + 1;j < L.length;j++)
                        {
                        	L.elem[j] = L.elem[j + 1];
						}
                        
                	L.length--;
				}
			else 
				{
					i = i + 1;	
				}
		}
	}

//线性表逆置 

 

    {
    	int i,n,temp;
    	n = L.length;
    	for(i = 0;i < n / 2;i++)
    	    {
    	    	temp = L.elem[i];
    	    	L.elem[i] = L.elem[n-i-1];
    	    	L.elem[n-i-1] = temp;
			}
	}

//完整代码

//第一题

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

#define LIST_INIT_SIZE   15
#define LISTINCREMENT    5

typedef int ElemType;

//创建顺序表 
typedef struct
    {	
        ElemType *elem;
        int length;
    	int listsize;
	}Sqlist;


//初始化线性表（构造一个空的线性表） 
int InitList(Sqlist &L)
    {
    	L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));
    	if(!L.elem) exit(-1);
    	L.length = 0;
		L.listsize = LIST_INIT_SIZE;
		return 0;
	}


//线性表输入 
int ListInput(Sqlist &L)
    {
        int i,n;
        printf("请输入数据元素个数：\n");
    	scanf("%d",&n);
        L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));
        if(!L.elem) return(-1);
        else
            {
            	printf("按非递增有序输入数据元素：\n");
            	for(i = 0;i < n;i++)
            	{
            		scanf("%d",&L.elem[i]);
            	    L.length++;	
				}
			}
	}
	

//删除线性表相同元素
void DelateElem(Sqlist &L)
    {
    	int i,j,n;
    	n = L.length;
    	i = 0;
       while(L.elem[i] != NULL)
        { 
            if(L.elem[i] == L.elem[i+1])
                {
                    for(j = i + 1;j < L.length;j++)
                        {
                        	L.elem[j] = L.elem[j + 1];
						}
                        
                	L.length--;
				}
			else 
				{
					i = i + 1;	
				}
		}
	}


//线性表逆置 
void ReverseList(Sqlist L)
    {
    	int i,n,temp;
    	n = L.length;
    	for(i = 0;i < n / 2;i++)
    	    {
    	    	temp = L.elem[i];
    	    	L.elem[i] = L.elem[n-i-1];
    	    	L.elem[n-i-1] = temp;
			}
	}

//线性表输出
void OutputList(Sqlist L)
    {
    	int i;	
    	for(i = 0;i < L.length;i++)
    	{
    		printf("%d ",L.elem[i]);
		}
	 } 

int main()
    {
    	Sqlist L;
    	InitList(L);
    	ListInput(L); 
		printf("\n打印输入后的顺序表:");	
    	OutputList(L);
		ReverseList(L);
		printf("\n打印逆置后的顺序表:");
		OutputList(L);
    	DelateElem(L);
    	printf("\n打印删除相同元素后的顺序表：");
        OutputList(L);
        return 0;
	}