数据结构：顺序表

今天学习数据结构，差点没把我绕死。

搞到半夜终于搞好了，自制了一个顺序表，今天的代码有点长。

先发头文件 

#ifndef _SEQUENCE_H_
#define _SEQUENCE_H_

#define INTO_SIZE 100      //表示表的初始长度
#define INADD_SIZE 20      //表示如果表长度不够，要增加的长度      
#define FALSE -1 
#define TRUE 0
typedef int SEQUENCE;      //表示这个顺序表的变量类型，可以随时改

typedef struct sequence
{
	SEQUENCE * p;
	int max_len;
	int len;
}SEQ;

SEQ * mkseq();    //创建顺序表

void deseq(SEQ *s);  //删除序列表

int addlen(SEQ *s);  //增加长度

int add_last(SEQ *s,SEQUENCE data); //插入数据：尾增

int add_head(SEQ *s,SEQUENCE data); //插入数据：头增

 //插入数据：在pos位插入一个数据 
int add_pos(SEQ *s,int pos,SEQUENCE data);   

void readseq(SEQ *s);   //输出顺序表
    
//查找元素，找到pos下标的元素，将元素的值给x
int find_pos(SEQ *s,int pos,SEQUENCE *x);

//查找元素，如果找到，将该元素的下标给x(只能找到第一个)
int find_seq(SEQ *s,SEQUENCE data,int *x);

// 删除 pos 下标的元素
int del_pos(SEQ *s,int pos);

// 逆序
int nixu(SEQ *s);

// 从小到大排序
int sort(SEQ *s);

//清全所有内容
int del_all(SEQ *s);

//将两个顺序表合并成一张顺序表
// 合并后的表要求是从小到大排列的，函数返回新表的指针
SEQ* merge_seq(SEQ *s1,SEQ *s2);

#endif 

再发代码

#include"sequence.h"
#include<stdlib.h>
#include<stdio.h>

SEQ * mkseq()    //创建顺序表
{
	SEQ *s = (SEQ *)malloc(sizeof(SEQ)/sizeof(char));
	if (s == NULL)
	{
		return NULL;
	}
	s->p = (SEQUENCE *)malloc((sizeof(SEQUENCE)/sizeof(char))*INTO_SIZE);
	if (s->p == NULL )
	{
		free(s);
		return NULL;
	}
	s->max_len = INTO_SIZE;
	s->len = 0;

	return s;
}

void deseq(SEQ * s)  //删除顺序表
{
	if (s == NULL)
		return ;
	free (s->p);
	free (s);
}

int addlen(SEQ *s)   //增加长度
{
	if (s==NULL)
		return FALSE;
	int i = sizeof(SEQUENCE)/sizeof(char)*(INTO_SIZE+INADD_SIZE);
	SEQUENCE* tmp = (SEQUENCE*)realloc(s->p,i);
	s->p = tmp;
	s->max_len = INTO_SIZE + INADD_SIZE;
	return TRUE;
}

int add_last(SEQ *s,SEQUENCE data)   //插入数据：尾增
{
	if (s == NULL)
		return FALSE;
	if (s->len == s->max_len)
	{
		if(addlen(s) == FALSE)
			return FALSE;
	}
	
	s->p[s->len] = data;
	s->len++;
	return TRUE;
}

int add_head(SEQ *s,SEQUENCE data)   //插入数据：头增
{

	if (s == NULL)
		return FALSE;
	if (s->len == s->max_len)
	{
		if(addlen(s) == FALSE)
			return FALSE;
	}
	int i;
	for (i=s->len-1;i>=0;i--)
	{
		s->p[i+1] = s->p[i];
	}
	s->p[0] = data;
	s->len++;
	return TRUE;
}

int add_pos(SEQ *s,int pos,SEQUENCE data)     //在pos位插入一个数据
{
	if (s == NULL)
		return FALSE;
	int i;
	for(i=s->len-1;i>=pos;i--)
	{
		s->p[i+1] = s->p[i];	
	}
	s->p[pos] = data;
	s->len++;
	return TRUE;
}

void readseq(SEQ *s)   //输出顺序表
{
	if (s==NULL)
		return ;
	int i;
	for (i=0;i<s->len;i++)
	{
		if (i!=0)
			if(i%4==0)
				putchar('\n');
		printf("%5d",s->p[i]);
	}
	printf("\n");
}

//查找元素:找到pos下标的元素	
int find_pos(SEQ *s,int pos,SEQUENCE *x)
{
	if ( s==NULL || pos>s->len || x==NULL)
		return FALSE;
	*x = s->p[pos];
	return TRUE;
}

//查找元素:如果找到，将该元素的下标给x
int find_seq(SEQ *s,SEQUENCE data,int *x)
{
	if ( s==NULL || x==NULL)
		return FALSE;
	int i;
	int flag = 0;
	for (i=0;i<s->len;i++)
	{
		if(data == s->p[i])
		{
			*x = i;
			flag = 1;
			break;
		}
	}
	if (flag == 0)
		return FALSE;
	else return TRUE;
}

// 删除 pos 下标的元素
int del_pos(SEQ *s,int pos)
{
	if (s == NULL)
		return FALSE;
	
	int i;
	if(pos<s->len-1)
	{
		for (i=pos;i<s->len-1;i++)
			s->p[i] = s->p[i+1];
	}
	s->len--;
	return TRUE;
}

//逆序
int nixu(SEQ *s)
{
	if (s == NULL)
		return FALSE;
	int min = 0;
	int max = s->len-1;
	SEQUENCE tmp ;
	while (min<max)
	{
		tmp = s->p[min];
		s->p[min++] = s->p[max];
		s->p[max--] = tmp;
	}
	return TRUE;
}

// 从小到大排序
int sort(SEQ *s)
{
	if (s == NULL)
		return FALSE;
	int i,j;
	SEQUENCE tmp ;
	for (i=0;i<s->len-1;i++)
		for (j=0;j<s->len-1-i;j++)
		{
			if (s->p[j] >s->p[j+1])
			{
				tmp 	  = s->p[j];
				s->p[j]   = s->p[j+1];
				s->p[j+1] = tmp;
			}
		}
	return TRUE;
}

//清全所有内容
int del_all(SEQ *s)
{
	if (s == NULL)
		return FALSE;		
	s->len = 0;
	return TRUE;
}

//将两个顺序表合并成一张顺序表
// 合并后的表要求是从小到大排列的，函数返回新表的指针
SEQ* merge_seq(SEQ *s1,SEQ *s2)
{
	if(s1 == NULL || s2 == NULL)
		return NULL;
	if (sort(s1)==FALSE || sort(s2)==FALSE)
		return NULL;
	
	SEQ *s3 = (SEQ *)malloc(sizeof(SEQ)/sizeof(char));
	if (s3 == NULL)
	{
		return NULL;
	}
	int len = sizeof(SEQUENCE)/sizeof(char)*(s1->len+s2->len);
	s3->p = (SEQUENCE *)malloc(len);
	if (s3->p == NULL )
	{
		free(s3);
		return NULL;
	}
	s3->len = s1->len+s2->len;
	s3->max_len = s3->len;
	
	int i=0;     //遍历s1
	int j=0;     //遍历s2
	int k=0;	 //遍历s3
	while(i<s1->len && j<s2->len)
	{
		if (s1->p[i] < s2->p[j])
			s3->p[k++] = s1->p[i++];
		else
			s3->p[k++] = s2->p[j++];
	}
	while (i<s1->len)
		s3->p[k++] = s1->p[i++];
	while (j<s2->len)
		s3->p[k++] = s2->p[j++];
	
	return s3;
}

最后发我的测试主函数

#include<stdio.h>
#include"sequence.h"

int main1()
{
	SEQ *s = mkseq();     //创建表s
	if (s == NULL)
	{
		printf("创建失败\n");
		return -1;
	}
	printf("创建成功\n");
	printf("s表信息：\n");
	int i;
	for(i=0;i<20;i++)     //尾插20个
	{	
		add_last(s,i);
	}

	for(i=0;i<20;i++)     //头插20个
	{	
		add_head(s,i);
	}
	readseq(s);
	
	putchar('\n');        //根据pos位插入数据    输出正常
	add_pos(s,5,1000);
	readseq(s);

	SEQUENCE x ;          //查找pos位的数据   输出14  正常
	putchar('\n'); 
	if (find_pos(s,6,&x)==FALSE)
		printf("找不到该元素\n");
	else printf("%d\n",x);
	
	int a;                //查找下标         输出5  正常
	putchar('\n'); 
	if (find_seq(s,1000,&a)==FALSE) 
		printf("找不到该元素\n");
	else printf("%d\n",a);
	
	if (del_pos(s,4)==FALSE)   //删除下标4为多少的元素   成功
		printf("删除失败\n");
	else readseq(s);
	 
	putchar('\n');         //逆序   成功
	if (nixu(s)==FALSE)   
		printf("逆序失败\n");        
	readseq(s);
	
	putchar('\n');         //排序   成功
	if (sort(s)==FALSE)   
		printf("逆序失败\n");        
	readseq(s);
	
	if (del_all(s)==FALSE)  //清空   
		printf("清空失败\n");  
	
	deseq(s);             //删除表
	s = NULL;
	printf("销毁表s成功\n");
	
	return 0;
	}

int main()
{
	int i;
	SEQ *s1 = mkseq();     //创建表s1
	if (s1 == NULL)
	{
		printf("创建s1失败\n");
		return -1;
	}
	SEQ *s2 = mkseq();     //创建表s2
	if (s2 == NULL)
	{
		printf("创建s2失败\n");
		return -1;
	}
	for(i=0;i<20;i++)     //尾插20个偶数给s1
	{	
		add_last(s1,2*i);
	}
	for(i=0;i<30;i++)     //头插30个奇数给s2
	{	
		add_last(s2,i*2+1);
	}

	SEQ *s3 = merge_seq(s1,s2);   //检验是否成功  成功排序输出
	readseq(s3);
	
	deseq(s3);             //删除表
	s3 = NULL;
	printf("销毁表s3成功\n");
	return 0;
}