菜鸟学习历程【11】数据结构

数据结构

一、线性表

1.定义：定义n个数据元素的有限序列，记作（a1, a2, …, an），ai 是表中数据元素，n 是线性表的长度。

2.特点：

     直接前驱：除第一个元素外，其他每一个元素有且仅有一个前驱；

     直接后继：除最后一个元素外，其他每一个元素有且仅有一个后继。    

二、顺序表

1.定义：将线性表中的元素相继存放在一个连续的存储空间中。         

2.特点：可利用一维数组描述存储结构、线性表的顺序存储方式、顺序访问, 可以随机存取 。

下面介绍一个顺序表的程序：

    基本功能：元素的插入、定位、遍历、删除、顺序表的判空；

    首先是头文件:Sequence.h

#ifndef _SEQUENCE_H_             // #ifndef xxxxxxxx ....  #endif  是头文件的固定格式
#define _SEQUENCE_H_
#define MAXSIZE      10
#define FAILURE      100000
#define SUCCESS      100001 
#define FAUSE        100002
#define TRUE         100003
typedef int ElemType;

struct sequence 
{
    ElemType *data;
    int size;
    int length;
};

typedef struct sequence SeList;

int InitList(SeList *s);        //初始化函数
int EmptyList(SeList s);        //顺序表判空函数
int LengthList(SeList s);       //顺序表长度求取函数
int InsertList(SeList *s, int i, ElemType e);      //指定位置插入元素函数
int LocateElem(SeList s, int e, int (*compare)(ElemType, ElemType));   //定位函数
int GetElem(SeList s, int p);   //获取元素内容函数
int ListTraverse(SeList s, void(*compare)(ElemType));    //遍历函数
int DeleteList(SeList *s, int pos);    //删除函数

#endif

      

       main.c

int equal(ElemType a, ElemType b)   //equal 与 large 为函数指针，后面会调用到
{
    return (a == b) ? TRUE : FAUSE;
}

int large(ElemType a, ElemType b)
{
    return (a <= b) ? TRUE : FAUSE;
}

void visit(ElemType e)                  //visit 与 add  为函数指针，后面会调用
{
    printf("%d ",e);
}

void add(ElemType e)
{
    printf("%d ", e + 1);
}
int main()
{
    SeList Slist;                     //定义一个SeList 的变量
    int ret, i, place, val, pos, j;  //ret 变量用来接各个函数的返回值
    int a[10]={0};

//********初始化部分*************
    ret = InitList(&Slist);           //初始化用使用到地址传递，值传递分配的内存并不会保留
	
    if(ret == SUCCESS)                //初始化判断
    {
        printf("Init SUCCESS\n");
    }
    else
        printf("Init FAULIE\n");
     for(i = 0;i < MAXSIZE;i++)      //使用for循环调用Insert函数插入0~9十个数
    {
        ret = InsertList(&Slist, i, i + 1);
        if(SUCCESS == ret)
           printf("Insert %d Success\n", i);
        else
           printf("Insert %d Failure\n", i);
      }

//***********判断是否为空顺序表*********
	ret = EmptyList(Slist);
	if(TRUE == ret)
	{
		printf("List is empty\n");
	}
	else
	{
		printf("List is't empty\n");
	}

	printf("Length:%d\n", LengthList(Slist));  //调用length求取函数，输出长度

//*************获取指定位置元素***********
	place = 3;                                //指定获取的位置为3
	ret = GetElem(Slist, place);
	if(ret == FAUSE)                          //提示获取失败、获取成功打印
	{
		printf("Elem %d is not found\n", place);
	}
	else
	{
		printf("Elem %d  is %d\n", place, ret);
	}

//************遍历顺序表，实现函数功能并打印**********
	ret = ListTraverse(Slist, add);          //add为函数指针，实现加一操作再输出
	if(ret == SUCCESS)
	{
		printf("SUCCESS\n");
	}
	else
	{
		printf("Failure\n");
	}

//*********返回顺序表中data内容满足函数要求的下标**********
	val = 4;                                   
	ret = LocateList(Slist, val, equal);       //设定值为4，返回满足equal函数要求的元素下标
	if(ret == FAUSE)
	{
		printf("NOT FOUND\n");
	}
	else
	{
		printf("%d is %dth\n", val, ret);
	}

//*************获取值，按顺序插入顺序表中***********
//	for(i = 0;i < 10;i++)                     //这两部分要与上面分开，是单独加的功能
//	{                                         //终端获取指定插入值，并按从小到大排列
//         	printf("Please input a number:\n");
//		scanf("%d", &a[i]);
//		ret = LocateList(Slist, a[i], large);
//		InsertList(&Slist, ret, a[i]);	
//	}
//	ListTraverse(Slist, visit);
//	printf("\n");

//******从终端获取指定删除的位置，实现删除的功能********
//      printf("Please input the position:\n");
//      scanf("%d", &pos);
//      ret = DeleteList(&Slist, pos);
//      j = 0;
//      if(ret == FAUSE)
//     {
//         printf("Unkown!\n");
//      }
//      while(Slist.length != 0)
//     {
//         printf("%d ", Slist.data[j]);
//         Slist.length--;
//         j++;
//      }
//      printf("\n");
        return 0;
}

接口部分：Sequence.c

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

int InitList(SeList *s)
{                                     //为data分配10个ElemType单位的内存，存放十个数据
	s->data = (ElemType *)malloc(sizeof(ElemType) * MAXSIZE);
	if(s->data == NULL)           //分配内存检查
	{
		return FAILURE;
	}
	s->size = MAXSIZE;
	s->length = 0;

	return SUCCESS;
}

int InsertList(SeList *s, int i, ElemType e)
{
	int k;                               //判断输入的插入位置是否合法
	if((i < 0 || i >= MAXSIZE) || s->length > MAXSIZE)
	{
		return FAILURE;
	}
	
	for(k = 0;k < s->length - i;k++ )   //将插入位置之后的所有元素依次向后挪一位
	{
		s->data[s->length - k] = s->data[s->length - k -1];
	}
	s->data[i] = e;                    //挪位完成后，插入数据
	s->length++;                       //将表的长度加1，size是表的容量，即最大长度

	return SUCCESS;
}

int EmptyList(SeList s)                   //判断表的长度是否为0，0即空表
{
	return (s.length == 0) ? TRUE : FAUSE;
}

int LengthList(SeList s)
{
	return s.length;
}

int GetElem(SeList s, int p)
{
	int ret = 0;
	if(p < 0 || p >= 10)    //判断输入的获取位置是否合法
	{
	    return FAUSE;
	}
	ret = s.data[p];    
	return ret;
	
}

int ListTraverse(SeList s,void (*look)(ElemType))  //遍历满足函数指针要求的元素
{
	int i;
	for(i = 0;i < s.length;i++)
	{
		look(s.data[i]);
	}
	return SUCCESS;
}

int LocateList(SeList s, int e,int (*compare)(ElemType, ElemType))
{
	int i = 0;

	for(i = 0;i < s.length;i++)
	{
		if(compare(e, s.data[i]) == TRUE)
			break;
	}
	return i;

}

int DeleteList(SeList *s, int pos)
{
	int i;
	if(pos < 0 || pos > 10)
	{
		return FAUSE;
	}
	else
	{
		for(i = pos;i < s->length;i++)
		{
			s->data[i] = s->data[i+1];
		}
		s->length--;
		return SUCCESS;
	}
}