请教两个问题？？？？

[drmao]

1.有一无序的顺序表可能有一个或一个以上的重复元素，要求用一个效率较高的算法删除所有的重复元素（即有重复就只留一个）
2.用C语言实现一个双端队列的基本算法。

[drmao]

1。要求用较高的效率执行
typedef struct Sqlist{
ElemType *elem;
int length;
int size;
}SqList;
void DeleteRedundance(SqList *L){int i,j; int k=0;
for(i=0;i<L->length;++i){ k=0;
for(j=i+1;j<L->length;++j){
if(L->elem[j]==L->elem[i])++k;
else L->elem[j-k]=L->elem[j];
} L->length-=k;
}
}
2。是双向队列

[ZeroZZZ000]

1、应该是先排序或建立索引效率会较高
2、是要数组队列还是链式队列啊？

[短歌如风]

1：先排序，然后去重复，时间复杂度为O(N*logN)——当选择O(N*logN)的排序算法时——或O(N)——当选择O(N)的排序算法时。
如果要求去重复后顺序不变，可以用一个BST或Hash实现的集合，如果元素不在集合中则删除，否则加入到集合。时间复杂度为O(N)*(O(Insert)+O(Find))
2：
可能有错误，自己改一下：
typedef int element_t;
#define COUNTPERNODE 64
typedef struct _node
{
struct _node* prev, *next;
element_t elem[COUNTPERNODE];
} node_t, *node_ptr_t;

typedef struct _queue
{
node_ptr_t first, last;
int first_index, last_index;
} queue_t, *queue_ptr_t;

int queue_isempty(queue_ptr_t queue)
{
assert(queue != NULL);
return = queue->first == NULL;
}
void queue_init(queue_ptr_t queue)
{
assert(queue != NULL);
queue->first = queue->last = NULL;
queue->first_index = queue->last_index = 0;
}

void queue_clear(queue_ptr_t queue)
{
assert(queue != NULL);
while(queue->first != NULL)
{
node_ptr_t node;
node = queue->first;
queue->first = node -> next;
free(node);
}
queue_init(queue);
}

void queue_push_back(queue_ptr_t queue, element_t value)
{
assert(queue != NULL);
if(queue->last == NULL)
{
queue->first = queue->last = (node_ptr_t)malloc(sizeof(node_t));
queue->first->prev = queue->first->next = NULL;
}
if (queue->last_index == COUNTPERNODE)
{
node_ptr_t node;
node = (node_ptr_t)malloc(sizeof(node_t));
queue->last ->next = node;
node->prev = queue->last;
node->next = NULL;
queue->last = node;
queue->last_index = 0;
}
queue->last->elem[queue->last_index++] = value;
}

element_t queue_pop_back(queue_ptr_t queue)
{
assert(queue != NULL && !queue_isempty(queue));
element_t result;
if(queue->last_index == 0)
{
node_ptr_t node;
node = queue->last;
queue->last = node->prev;
queue->last->next = NULL;
free(node);
queue->last_index = COUNTPERNODE;
}
result = queue->last->elem[--queue->last_index];
if (queue->last == queue->first && queue->last_index == queue->first_index)
{
free(queue->last);
queue_init(queue);
}
return result;
}

void queue_push_front(queue_ptr_t queue, element_t value)
{
assert(queue != NULL);
if(queue->last == NULL)
{
queue->first = queue->last = (node_ptr_t)malloc(sizeof(node_t));
queue->first->prev = queue->first->next = NULL;
}
if (queue->first_index == 0)
{
node_ptr_t node;
node = (node_ptr_t)malloc(sizeof(node_t));
queue->first ->prev = node;
node->next = queue->first;
node->prev = NULL;
queue->first = node;
queue->first_index = COUNTPERNODE;
}
queue->first->elem[--queue->first_index] = value;
}

element_t queue_pop_front(queue_ptr_t queue)
{
assert(queue != NULL && !queue_isempty(queue));
element_t result;
result = queue->first->elem[queue->first_index++];
if (queue->last == queue->first && queue->last_index == queue->first_index)
{
free(queue->last);
queue_init(queue);
}
else if(queue->first_index == COUNTPERNODE)
{
node_ptr_t node;
node = queue->first;
queue->first = node->next;
queue->first->prev = NULL;
free(node);
queue->first_index = 0;
}
return result;
}

[blueclu0281]

1
用扫描的办法可以吗？
2
是双向队列吗？