线性表详解（c语言版）

放假回家第三天，接着复习。啦啦啦：

1. 线性表：线性表是最常用且最简单的一种数据结构，一个线性表就是若干个数据元素的有限序列。

线性表的操作：

InitList（&L）构造一个空的线性表

DestroyList（&L）销毁线性表

ClearList（&L）清空线性表

ListEmpty（L） 判断线性表是否为空

ListLength（L）获取线性表的长度

GetElem（L，i，&e）获取线性表L中的第i个元素，返回结果保存在e中

ListInsert（&L，i，e）向线性表L中第i-1个位置插入元素e

ListDelete（&L，i，&e）将线性表L中第i个位置的元素，并用e返回其值

2. 线性表的实现方式：

顺序线性表：数据元素按顺序依次排列，在存储空间的位置为连续的存储区域，优点是便于存取，能根据下标获取相应的元素，缺点是必须有连续的存储空间（可以按数组理解）。

链式线性表 （单链表）:数据元素依次排列，每一个数据元素中都含有指向下一个元素的指针，通过指针来将所有的元素连接在一起形成线性表。优点是可以充分的利用碎片化的存储空间，不要求必须都是连续的，缺点是不能根据下标来直接找到元素，而是要从头开始，根据指针来一次寻找。

顺序表的实现（C语言版）

/**顺序线性表的实现**/

#include<stdio.h>
#include<malloc.h>
#define OVERFLOW_ERROR 0
#define ERROR 1
#define OK 2
/*线性表的初始大小*/
#define LIST_INIT_SIZE 100
/*线性表每次的增量*/
#define LIST_INCREMENT 10

/*定义顺序线性表的结构体*/
typedef struct{
int *elem;//基址指针
int length;//当前数组长度
int listsize;//数组的大小
}Sqlist;

/*初始化线性表*/
int InitList_Sq(Sqlist *L){

L->elem = (int *)malloc(LIST_INIT_SIZE*sizeof(int));

if(!L->elem){
exit(OVERFLOW_ERROR);
}
L->length = 0;
L->listsize = LIST_INIT_SIZE;
return OK;
}

/*向线性表第position个位置前插入元素*/
int InsertList_Sq(Sqlist *L,int position,int insert_elem){

//判断插入的位置是否合法
if(position<1 || position>L->length+1){
return ERROR;
}
//判断当前的数组大小是否超过了已申请到的存储空间
if(L->length>= L->listsize){
int *newbase = (int *)realloc(L->elem,(L->listsize + LIST_INCREMENT)*sizeof(int));
//判断是否重新申请到了空间
if(!newbase){
exit(OVERFLOW_ERROR);
}
L->elem = newbase;
L->listsize += LIST_INCREMENT;
}
//记录要插入的位置
int *insert_pointer = &(L->elem[position-1]);
//将要插入位置后的元素后移
int *temp= &(L->elem[L->length-1]);
for(temp;temp>=insert_pointer;temp){
*(temp+1) = (*temp);
}
*insert_pointer = insert_elem;
++L->length;
return OK;
}
/*删除顺序线性表中的第position个元素，并用elem返回其值*/
int ListDelete(Sqlist *L,int position,int *elem){
//检查position的合法性
if( (position<1) || (position>L->length) ){
return ERROR;
}
int *delete_pointer = &(L->elem[position-1]);
elem = delete_pointer;
int *temp = (L->elem + L->length-1);

for(++delete_pointer;delete_pointer<=temp;++delete_pointer){
*(delete_pointer-1) = *delete_pointer;
}

--(L->length);
return OK;

}

/*获取线性表的当前长度*/
int ListLength_Sq(Sqlist L){
return L.length;
}

/*主函数*/
int main(){
void ShowList(Sqlist list);
Sqlist list;
//初始化数组
int init_flag = InitList_Sq(&list);
//向数组中插入元素
InsertList_Sq(&list,1,23);
InsertList_Sq(&list,2,34);
InsertList_Sq(&list,3,56);

ShowList(list);

int elem = 0;
init_flag = ListDelete(&list,2,&elem);//删除第二个元素

ShowList(list);
return 0;
}

void ShowList(Sqlist list){

int i = 0;
for(i;i<list.length;i++){
printf("%d\n",list.elem[i]);
}
printf("数组长度为\t%d\n",list.length);
}

单链表的实现（C语言版）：

/**单链表的实现(头插法)**/

#include<stdio.h>
#include<malloc.h>
#define OVERFLOW_ERROR 0
#define ERROR 1
#define OK 2

/*定义链表的结构体*/
typedef struct LNode{
int data;//数据
struct LNode *next;//指向下一个结点
}LNode,*LinkList;

/*初始化一个单链表

LinkList *L 是一个指向LinkList的指针，存放链表头结点的地址
int length 是一个整形，用于明确链表的长度

*/
int InitList_L(LinkList *L,int length){
*L = (LinkList)malloc(sizeof(LNode));

if((*L) == NULL){
return ERROR;
}
(*L)->next = NULL;

for(length;length>0;--length){
LinkList newNode = malloc(sizeof(LNode));
if(newNode == NULL){
return ERROR;
}

scanf("%d",&(newNode->data));
newNode->next = (*L)->next;
(*L)->next = newNode;

}
return OK;
}
/*
插入节点
LinkList *L 插入的链表
int position 在position之前插入节点
int elem 要插入的元素
*/
int InsertList_L(LinkList *L,int position,int elem){

LinkList p = *L;//记录下链表的初识位置
int num = 0;
//找到要插入的位置
while(p&&num<(position-1)){
p = p->next;
num++;
}
//如果链表为空，或者是超出了表长
if(!p || num>position-1){
return ERROR;
}
//申请新的节点
LinkList temp = (LinkList)malloc(sizeof(LNode));
temp->data = elem;
temp->next = p->next;
p->next = temp;
return OK;
}
/*
删除链表中第position个元素，并用elem返回其值
*/
int DeleteList_L(LinkList *L,int position,int *elem){

LinkList temp = *L;
int num = 0;
//将指针指向要删除节点的前一个元素
while((temp->next)&&(num<position-1)){
temp = temp->next;
num++;
}
printf("现在指向的元素是%d",temp->data);
if( (!temp->next) || num>position-1){
return ERROR;
}
LinkList deleteNode = temp->next;
temp->next = deleteNode->next;
*elem = deleteNode->data;
free(deleteNode);
return OK;
}

/*
打印链表
*/
int ShowList(LinkList L){

//打印输出一下链表
while( L->next != NULL){
L = L->next;
printf("%d\n",L->data);
}

}

/*主函数*/
int main(){

int length = 0;
LinkList linkList;
printf("请输入链表长度\n");
scanf("%d",&length);
//初始化链表
int flag = InitList_L(&linkList,length);

if(flag == OK){
printf("初始化成功\n");
}else{
printf("初始化失败");
}
ShowList(linkList);

//插入新节点
flag = ERROR;
flag = InsertList_L(&linkList,2,34);
if(flag == OK){
printf("插入成功\n");
ShowList(linkList);
}else{
printf("插入失败");
}

//删除链表
int deleteNum = 0;
flag = ERROR;
flag = DeleteList_L(&linkList,3,&deleteNum);
if(flag == OK){
printf("删除成功\n");
ShowList(linkList);
printf("被删除元素为%d",deleteNum);
}else{
printf("删除失败");
}
}