数据结构上机第一次_3删除重复元素（顺序表/单链表）

数据结构上机第一次_3删除重复元素（顺序表/单链表）

题目

3．设线性表L，元素值为整型的且存在相同值，分别采用顺序结构和链式结构存储，编写函数，利用原空间，删除重复的元素值。

代码

（1）顺序结构

//设线性表L，元素值为整型的且存在相同值，分别采用顺序结构和链式结构存储，编写函数，利用原空间，删除重复的元素值。
#include<iostream>
#include<stdlib.h>
#include<malloc.h>
using namespace std;
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define PARA_ERROR 0
#define OVERFLOW -2 
#define LISTINITSIZE 256    //初次分配空间大小
#define LISTINCREMENT 128    //空间分配增量大小

typedef int ElemType;
typedef int Status;
typedef struct Seqlist
{
	ElemType *pdata;    //动态存储空间的基地址
	int length;    //存储数据元素的个数
	int size;    //当前已分配的存储空间大小	 
}Seqlist;

Status InitList(Seqlist &L)
{
	//初始化顺序表 
    L.pdata=(ElemType*) malloc (LISTINITSIZE*sizeof(ElemType));
    if(L.pdata==NULL)
    	exit (OVERFLOW);
	L.size=LISTINITSIZE;
	L.length=0;
	return OK; 
} 

Status CreateList(Seqlist &L)
{
	//创建顺序表
	cout<<"请输入顺序表长度：";
	cin>>L.length;
	cout<<"请输入顺序表元素：";
	for(int i=0;i<L.length;i++)
	{
		cin>>L.pdata[i];
	}
	cout<<"顺序表建立成功！"<<endl;
	return OK;	 
}

Status ListTraverse(Seqlist L)
{
	//遍历顺序表并依次输出其数据元素
	for(int i=0; i<L.length; i++)
	{
		cout<<L.pdata[i]<<" ";
	}
	cout<<endl;
	return 0;
} 

Status DeleteRepeatList(Seqlist &L)
{
	//删除重复元素
	for(int i=0;i<L.length;i++)
	{
		for(int j=i+1;j<L.length;j++)
		{
			if(L.pdata[j]==L.pdata[i])
			{
				for(int k=j;k<L.length-1;k++)
				{
					L.pdata[k]=L.pdata[k+1];
				}
				L.length-=1;
				j-=1;    //删除后j也要减一 
			}
		}
	} 
}

int main()
{
	Seqlist L;
	InitList(L);
	CreateList(L);
	cout<<"顺序表元素为："<<endl;
	ListTraverse(L);
	DeleteRepeatList(L);
    cout<<"删除后的顺序表元素为："<<endl;
	ListTraverse(L);
}
 

（2）链式结构

//设线性表L，元素值为整型的且存在相同值，分别采用顺序结构和链式结构存储，编写函数，利用原空间，删除重复的元素值。 
//单链表 
#include <iostream>
#include <stdlib.h>
#include <malloc.h>
using namespace std;
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define PARA_ERROR 0
#define OVERFLOW -2
typedef int ElemType;
typedef int Status;
typedef struct LNode
{
	ElemType data;    //数据域 
	struct LNode *next;    //指针域
}LNode, *LinkList;

Status InitList(LinkList &L)
{
	//初始化单链表 
	L=(LNode*) malloc (sizeof(LNode));
	if(L==NULL) exit(OVERFLOW);
	L->next=NULL;
	return OK; 
}

Status ListLength(LinkList L)
{
	//单链表长度
	int n=0;
	LNode *p;
	p=L->next;
	while (p)
	{
		n++;
		p=p->next;
	}
	return(n);
}

Status InsertElem(LinkList &L, int i, ElemType e)
{
	//在第i个位置插入e
	LNode *s=(LNode*)malloc(sizeof(LNode));    //申请新的节点s
	if(s==NULL) exit(OVERFLOW);    //申请节点失败 
	s->data=e;
	LNode *p;
	p=L->next;
	if(i==1)
	{
		s->next=p;
		L->next=s;
	}
	else if(i>1&&i<=ListLength(L))
	{
		for(int j=0;j<i-2;j++)
		{
			p=p->next;
		}
		s->next=p->next;
		p->next=s;
	}
	else if(i==ListLength(L)+1)
	{
		for(int j=0;j<i-2;j++)
		{
			p=p->next;
		}
		p->next=s;
		s->next=NULL;
	}
	else
	{
		cout<<"表中没有该位置！"<<endl;
	}
	return OK;
}

Status CreateList(LinkList &L)
{
	//建立单链表
	int i,len=0;
	ElemType e;
	cout<<"请输入单链表长度:";
	cin>>len;
	cout<<"请输入单链表元素数据:";
	for(i=1;i<len+1;i++)
	{
		cin>>e;
		InsertElem(L,i,e);
	}
	return OK;
}

Status ListTraverse(LinkList L)
{
	//遍历单链表
	LNode *p;
	p=L->next;
	while(p)
	{
		cout<<p->data<<" ";
		p=p->next;
	}
	cout<<endl;
	return OK;
}

Status DeleteRepeatList(LinkList &L)
{
	//删除重复元素
	LNode *p,*s;
	p=L->next;
	while(p)
	{
		LNode *q;
		q=p;
		while(q->next)
		{
			if(q->next->data==p->data)    //q->next是重复元素！！这样不需要用到前驱元素 
			{
				s=q->next;
				q->next=s->next;
				free(s);
			}
			else q=q->next;
		}
		p=p->next;
	} 
}

int main()
{
	LinkList L;
	InitList(L);
	CreateList(L);
	cout<<"单链表元素为："<<endl;
	ListTraverse(L);
	DeleteRepeatList(L);
	cout<<"删除后单链表元素为："<<endl;
	ListTraverse(L);
 } 

思想

顺序表：依次往前覆盖
单链表：把p->next设为重复元素比较方便