数据结构之线性表03(顺序表、单链表、静态链表 代码实现)

顺序表的插入和删除

代码实现：

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define MAX 100
typedef struct Node
{
	int* data;
	int length;
}Node;
Node  NullList() //创建一个空线性表
{
	Node L;
	L.data = (int*)malloc(MAX * sizeof(Node));
	if (!L.data)
	{
		printf("重来");
	}
	L.length = 0;
	return L;

}


Node CreateList() //随机生成一个线性表
{
	Node	L;
	int		i;
	int		len;
	int     x;
	srand(time(0));
	L = NullList();
	printf_s("请输入线性表的长度len：");
	scanf_s("%d", &len);

	for (i = 1; i <= len; i++)
	{
		x = rand() % 100 + 1;
		L.data[i - 1] = x;
		L.length++;
	}
	return L;
}



void PrintfList(Node L) //打印链表
{
	int j;
	for (j = 0; j < L.length; j++)
	{
		printf("%d ", L.data[j]);
	}
	printf("\n");
}



Node InsertList(Node L, int i, int e)
{

	int		j;

	if (i<1 || i>L.length + 1)
	{
		printf("超出范围");
	}
	if (L.length >= MAX)
	{
		L.data = (int*)realloc(L.data, sizeof(Node)); //重新分配内存空间，将就的内存复制到新内存中
	}
	for (j = L.length - 1; j >= i - 1; j--)
	{
		L.data[j + 1] = L.data[j];

	}
	L.data[i - 1] = e;
	L.length++;
	return L;
}

Node DeleteList(Node L, int i)
{
	int j;
	if (i<1 || i>L.length + 1)
	{
		printf("超出范围");
	}
	for (j = i; j < L.length; j++)
	{
		L.data[j - 1] = L.data[j];
	}
	L.length--;
	return L;
}


void main()
{
	Node L;
	int i;
	int e;
	L = CreateList();
	printf_s("随机生成链表L：");
	PrintfList(L);


	//插入
	
	printf_s("插入元素的位置为：");
	scanf_s("%d", &i);
	printf_s("插入的元素为：");
	scanf_s("%d", &e);
	L = InsertList(L, i, e);
	PrintfList(L);
	

	//删除
	
	printf_s("删除元素的位置为：");
	scanf_s("%d", &i);
	L = DeleteList(L, i);
	PrintfList(L);


	system("pause");
}

结果:

单链表的插入和删除

代码实现：

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
typedef struct Node
{
	int data;
	Node* Next;
}Node;

//创建长度为len的链表
Node* CreateList(int len)  
{
	Node* p;
	Node* head;
	int  n;
	int i;
	srand(time(0));
	head = (Node*)malloc(sizeof(Node));
	head->Next = NULL;
	for (i = 0; i < len; i++)
	{
		p = (Node*)malloc(sizeof(Node));
		p->data = rand() % 100 + 1;

		p->Next = head->Next;
		head->Next= p;
	}
	return head;

}

//打印链表
void PrintfList(Node *L) 
{
	Node* head;
	head = L->Next;
	if (head->Next == NULL)
	{
		printf("重来");
	}
	while(head != NULL)
	{
		printf("%d  ", head->data);
		head = head->Next;
	}
	printf("\n");


}

//插入元素
Node* InsertList(Node* L, int i, int e) //在线性表L的第i个位置插入e
{
	Node* head;
	Node* p;
	head = L;
	int j;
	for (j = 1; j <= i-1; j++)
	{
		if (head->data == NULL)
		{
			printf("重来");
		}
		head = head->Next;
	}
	p = (Node*)malloc(sizeof(Node));
	p->data = e;

	p->Next = head->Next;
	head->Next = p;

	return L;
}

//删除元素
Node* DeleteList(Node* L, int i) //删除线性表L的第i个元素
{
	
	Node* p;
	int j;
	
    p = L;
	for (j = 1; j < i ; j++)
	{
		p = p->Next;
	}

	p->Next = p->Next->Next;
	return L;
}

void main()
{
	Node* L;
	int len = 0;
	int i = 0;
	int e = 0;
	printf("链表的长度为:");
	scanf_s("%d", &len);
	printf_s("随机生成链表L：");
	L = CreateList(len); 
	PrintfList(L);

	//插入元素
	printf("插入元素的位置为:");
	scanf_s("%d", &i);
	printf("插入的元素为:");
	scanf_s("%d", &e);
	L = InsertList(L, i, e);
	PrintfList(L);
	


	//删除元素
	printf("删除元素的位置为:");
	scanf_s("%d", &i);
	L = DeleteList(L, i);
	PrintfList(L);


	system("pause");
}

结果：

静态链表的插入和删除

代码实现：

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define MAX 10
typedef struct Node
{
	int data;  //数据域
	int cur;   //游标
}Node;

//创建备用链表
void CreateSpareList(Node* list) 
{
	int i;
	for (i = 0; i < MAX; i++)  //使当前的游标指向下一个节点
	{
		list[i].cur = i + 1;
	}
	list[MAX - 1].cur = 0; //最后一个节点的游标指向0
}

//寻找链表中空闲的空间
int SpaceNullList(Node * list)
{
	int i;
	i =  list[0].cur; //将空闲的节点位置赋给i
	if (list[0].cur )  //list[0].cur == 0 表示链表已满
	{
		list[0].cur = list[i].cur;
	}
	return i;
}

//初始化链表
int InitList(Node* list ,int len) 
{
	int i;
	int j;  //更新链表中的空节点
	int n;  //生成的随机数
	int my1; //更新链表中的空节点
	int tail; //指向链表的最后一个节点

	srand(time(0));
	CreateSpareList(list);
	my1 = SpaceNullList(list); 
	tail = my1;

	for (i = 0; i < len; i++)
	{
		n = rand() % 100 + 1;
		j = SpaceNullList(list);
		list[tail].cur = j;
		list[j].data = n;
		tail = j;
	}
	list[tail].cur = 0;
	return my1;
}

//打印链表
void PrintfList(Node* list, int my)
{    //由于静态链表的第一个地址（list[0]）不存储元素，所以为乱码
	int my1;
	my1 = my;
	while (list[my1].cur) //输出链表
	{
		printf("%d,%d  \n", list[my1].data, list[my1].cur);
		my1 = list[my1].cur;
	}
	printf("%d,%d  \n", list[my1].data, list[my1].cur); //输出链表的最后一个元素
}

//插入元素
void InsertList(Node* list, int my, int m, int e) //在链表list的m的位置插入e
{
	int i;
	int my1;
	int p;
	my1 = my;
	
	for (i = 1; i < m; i++)  //寻找插入的位置
	{
		my1 = list[my1].cur;
	}
	p = SpaceNullList(list); //p 为链表中空闲的节点

	list[p].cur = list[my1].cur;
	list[p].data = e;
	list[my1].cur = p;
}

//删除元素
void DeleteList(Node* list, int my, int e)
{
	int my1;
	int p;
	my1 = my;
	while (list[my1].data != e)
	{
		my1 = list[my1].cur;
		if (my1 == 0)
		{
			printf("再来一次");
			return;
		}
	}
	p = my1; //将要删除元素的节点赋个p

	my1 = my; //初始化
	while (list[my1].cur != p) //找到要删除元素的上一个节点
	{
		my1 = list[my1].cur;
	}
	list[my1].cur = list[p].cur;

	//回收节点
	list[p].cur = list[0].cur;
	list[0].cur = p;
}

void main()
{
	Node list[MAX];
	int my;  //初始化后的链表
	int len;
	int M;
	int e;
	printf_s("链表的长度为len(len<MAX):");
	scanf_s("%d",&len);
	my = InitList(list, len );
	printf("静态链表为：\n");
	PrintfList(list, my);

	//插入元素
	printf_s("插入元素的位置为M:");
	scanf_s("%d", &M);
	printf_s("插入的元素为e:");
	scanf_s("%d", &e);
	InsertList(list, my, M, e);
	PrintfList(list, my);

	//删除元素
	printf_s("删除的元素为e:");
	scanf_s("%d", &e);
	DeleteList(list, my, e);
	PrintfList(list, my);
	system("pause");
}

结果：