21.1线性表顺序存储结构作业

1.写一个函数，功能为去除线性表中的重复元素（例如：1、1、1、2、3、4、4、5、6，去 

重之后为1、2、3、4、5、6）；

2、写一个函数，功能为线性表的合并La = La U Lb（例如：La：1、2、3、4；Lb：4、5、 6、7；合并之后La：1、2、3、4,、5、6、7；Lb：4、5、6、7）；

一共两道题，看上去还挺没思路的。

一个是去重操作，一个是合并，在实现之前我们先理清思路看看如何去实现。

一.去重操作

理解题目，理清思路，划分解题思路。

1. 那么我们来进行画图，现在假如我们有个线性表，也就是一个数组，那么它的里面存着1、1、1、2、3、4、4、5、6，这几个数据，那么我们怎么进行去重呢
2. 

 

看到上面的图，我们思路就很清晰了，两个循环就搞定了，外层负责i的移动，内层负责j的移动，从顺序表中删除元素，我们直接封装成函数就可以了。

但是这种出现了一个弊端当，前面有好几个相同的数据的时候我们就删除不掉，漏判断了，所以j的加加需要条件来判定。

还是我们之前说的几个步骤

1. 整体的框架搭建，实现一些基本的函数操作，后面的逻辑直接调用就可以
2. 理清关键算法的思路，现在我们也明确了
3. 然后我们就开始实现吧。

为了熟悉顺序表的操作，我们从上一节的框架搭建开始进行编写。

三个文件sqlist.c sqlist.h test.c

首先我们先将test.c中的框架先搭建一下

1. 我们要进行去重操作，先将数据准备好，新建一个数组，填充上要去重的数据。
2. 创建一个顺序表，然后将数据插入到顺序表中，打印一下当前顺序表中的数据
3. 然后进行去重操作，然后在查看一下顺序表中的数据
4. 清除一下当前的队列，然后就完工。

剩下的就是一些基础函数的实现，如何创建顺序表，向顺序表中插入数据，删除指定位置的数据，清顺序表操作，然后就是我们的去重函数的逻辑实现。

 

在sqlist.c中就是我们的一些基础函数，创建顺序表，删除顺序表，打印顺序表数据

插入数据，删除指定位置数据，获取当前顺序表长度，目前的测试用这些函数就够了，那么开始分别进行实现。

第一个创建函数

malloc 进行内存分配，然后进行是否成功判断，然后进行顺序表的参数初始化。

有创建就有删除，主要就是一个内存的释放，释放之前判断一下是否为空。

下面就是在指定位置插入和在指定位置删除了，这个就是顺序表的两个关键操作。

插入就是将插入位置后面的数据全都往后移，然后空出位置，将数据放入。

删除一样的操作，这也就导致了顺序表插入和删除是很麻烦的效率很低。

第一步移动出位置，第二步插入数据，第三步表尾+1.在插入之前进行合法性判断。

二.合并

下面来进行线性表的合并，合并的意思就是把不同的元素合并到另外一个线性表中。

那么思路也就将两个数组准备好，然后开始捋一下合并的操作。

这个我们有一个特别清晰的思路。

假如有两个数组La Lb，我们将我们lb中的数据逐个和la中的数据进行比较，如果没有就从尾部插入，这个时候还要对插入进行一下判断，当空间满后，插入会失败。

1.检查是否有这个元素，没有就尾部插入，很简单。

三.代码实现

那么下面就写出两道题的代码实现

1.去重的代码实现

#include "stdio.h"
#include "sqlist.h"

void purge(p_sqlist L);

int main(int argc,const char *argv[])
{
	int i;
	data_t temp[]={1,1,1,2,3,3,4,4,5,6};
	p_sqlist L = NULL;

	L = creat_sqlist();
	for(i = 0;i < sizeof(temp) / sizeof(data_t); i++){
		insert_sqlist(L,temp[i],i);
	}

	show_sqlist(L);
	purge(L);
	show_sqlist(L);
	clear_sqlist(L);

	return 0;
}
void purge(p_sqlist L)
{
	int i,j;
	if(L->last == 0)
	{
		return;
	}

	for(i = 0;i < get_length_seqlist(L);i++){
		j = i + 1;
		while(j < get_length_seqlist(L)){

			if(L->data[i] == L->data[j]){
				delete_sqlist(L,j);
			}
			else
			{	
				j++;
			}
		}
		
	}
}

2.合并的代码实现

#include "stdio.h"
#include "sqlist.h"

void merge(p_sqlist La,p_sqlist Lb);

int main(int argc,const char *argv[])
{
	int i;
	data_t la_temp[]={1,2,3,4,5};
	data_t lb_temp[]={4,5,6,7};
	
	p_sqlist La,Lb;

	La = creat_sqlist();
	if(La == NULL){
		printf("La creat failed");
		return 0;
	}
	Lb = creat_sqlist();
	if(La == NULL){
		printf("Lb creat failed");
		return 0;
	}
	for(i = 0;i <= sizeof(la_temp) / sizeof(data_t); i++){
		insert_sqlist(La,la_temp[i],i);
	}
	for(i = 0;i <= sizeof(lb_temp) / sizeof(data_t); i++){
		insert_sqlist(Lb,lb_temp[i],i);
	}
	
	show_sqlist(La);
	show_sqlist(Lb);
	merge(La,Lb);
	show_sqlist(La);
	show_sqlist(Lb);
	clear_sqlist(La);
	clear_sqlist(Lb);

	return 0;
}
void merge(p_sqlist La,p_sqlist Lb)
{
	int i,j,k;
	
	for(i = 0;i < (Lb->last+1);i++)
	{
		j = search_sqlist(La,Lb->data[i]);
		if(j == -1){
			k = insert_sqlist(La, Lb->data[i], La->last);
			if(k == -1)
			{
				printf("merge failed");
			}
		}
	}
}

3.下面就是顺序表的一些基础函数和结构体定义

sqlist.h

#ifndef _SQLIST_H
#define _SQLIST_H

#define max_size 100
typedef int data_t;

typedef struct{

	data_t data[max_size];
	int last;

}sqlist,*p_sqlist;
p_sqlist creat_sqlist(void);   //create
void clear_sqlist(p_sqlist L); //clear
void show_sqlist(p_sqlist L); //show sqlist

int insert_sqlist(p_sqlist L,data_t x, data_t pos); //澧?
void delete_sqlist(p_sqlist L,data_t pos); 			//鍒?
int change_sqlist(p_sqlist L,data_t x,data_t pos); 	//鏀?
int search_sqlist(p_sqlist L,data_t x); 			//鏌?

int get_length_seqlist(p_sqlist L);
int search_sqlist(p_sqlist L,data_t x);

#endif

sqlist.c

#include "stdio.h"
#include "sqlist.h"
#include <stdlib.h>
#include <string.h>

p_sqlist creat_sqlist(void)
{
	p_sqlist L=NULL;

	L = (p_sqlist)malloc(sizeof(sqlist));
	if(L == NULL)
	{
		printf("failed to creat");
		return L;
	}
	memset(L,0,sizeof(sqlist));
	L->last = -1;
	
	return L;	
}
void clear_sqlist(p_sqlist L)
{
	if(NULL == L)
	{
		printf("sqlist is NULL\n");
		return;
	}
	free(L);
	return;
}
void show_sqlist(p_sqlist L)
{
	int i;
	if(NULL == L)
	{
		printf("sqlist is NULL\n");
		return;
	}
	for(i = 0;i < L->last;i++)
	{
		printf("%d ",L->data[i]);
	}
	puts("");
	return;
}
int insert_sqlist(p_sqlist L,data_t x, data_t pos)
{
	int i;
	if((pos < 0) || (pos > L->last+1))
	{
		printf("input pos is invalid");
		return -1;
	}
	if(L->last >= max_size-1)
	{
		printf("full");
		return -1;
	}
	for(i = L->last; i > pos; i--)
	{
		L->data[i+1] = L->data[i];
	}
	L->data[pos] = x;
	L->last++;
	
 	return 0;
}
void delete_sqlist(p_sqlist L,data_t pos)
{
	int i;
	if((pos < 0) || (pos > L->last))
	{
		printf("input pos is invalid");
		return;
	}
	for(i = pos; i< L->last; i++)
	{
		L->data[i] = L->data[i+1];
	}
	L->last--;
 	return;

}
int get_length_seqlist(p_sqlist L)
{
	if(NULL == L)
	{
		printf("sqlist is NULL\n");
		return -1;
	}
	return (L->last);
}
int search_sqlist(p_sqlist L,data_t x)
{
	int i;
	for(i=0;i<L->last;i++)
	{
		if(L->data[i] == x)
			return i;
	}
	return -1;
}