数据结构（顺序单链表、链式单链表、顺序栈、链式栈、顺序队列、链式队列）

最新推荐文章于 2023-11-10 11:58:00 发布

_HQ

最新推荐文章于 2023-11-10 11:58:00 发布

阅读量901

点赞数

分类专栏：学习笔记（备忘） C基础文章标签：数据结构

本文链接：https://blog.csdn.net/u013499771/article/details/23922929

版权

学习笔记（备忘）同时被 2 个专栏收录

34 篇文章 0 订阅

订阅专栏

C基础

8 篇文章 0 订阅

订阅专栏

/*顺序单链表*/
#include 
   
   
    
     <stdio.h>
#define N 10

typedef int data_t;
typedef struct
{
	data_t data[N];
	int len;
}seqlist_t;
//创建顺序表
seqlist_t *create_seqlist()
{
	seqlist_t *sl = (seqlist_t *)malloc(sizeof(seqlist_t));
	sl->len = 0;

	return sl;
}
//销毁顺序表
int destroy_seqlist(seqlist_t *sl)
{
	free(sl);

	return 0;
}
//清空顺序表
int clear_seqlist(seqlist_t *sl)
{
	sl->len = 0;
	return 0;
}
//判断顺序表是否满了
int full_seqlist(seqlist_t *sl)
{
	return sl->len == N ? 0 : -1;
}
//判断顺序表是否为空
int empty_seqlist(seqlist_t *sl)
{
	return sl->len == 0 ? 0 : -1;
}
//顺序插入元素，将data插入到最后一个有效元素的后一个位置
int insert_seqlist(seqlist_t *sl, data_t *data)
{
	if(full_seqlist(sl) == 0)
		return -1;
	sl->data[sl->len] = *data;
	sl->len++;

	return 0;
}
//指定位置插入元素
int insert_seqlist_index(seqlist_t *sl, data_t *data, int index)
{
	if(index < 0 || index > sl->len || full_seqlist(sl) == 0)
		return -1;
	int i;
	for(i = sl->len - 1; i >= index; i--)
	{
		sl->data[i + 1] = sl->data[i];
	}
	sl->data[index] = *data;
	sl->len++;

	return 0;
}

//顺序删除
int delete_seqlist(seqlist_t *sl)
{
	if(empty_seqlist(sl) == 0)
		return -1;
	sl->len--;

	return 0;
}

int delete_seqlist_index(seqlist_t *sl, int index)
{
	int i;
	if(index < 0 || index > sl->len - 1 || empty_seqlist(sl) == 0)
		return -1;
	for(i = index; i < sl->len - 1; i++)
		sl->data[i] = sl->data[i + 1];
	sl->len--;

	return 0;
}

int getdata_seqlist(seqlist_t *sl, int index, data_t *data)
{
	if(index < 0 || index > sl->len - 1)
		return -1;
	*data = sl->data[index];

	return 0;
}



void print_seqlist(seqlist_t *sl)
{
	int i;
	for(i = 0; i < sl->len; i++)
		printf("%d ", sl->data[i]);

	putchar(10);
	return;
}


int main(int argc, const char *argv[])
{
	seqlist_t * seqlist = create_seqlist();
	int i;
	for(i = 0; i < N; i++)
		insert_seqlist(seqlist, &i);
	print_seqlist(seqlist);
	delete_seqlist(seqlist);
	delete_seqlist_index(seqlist, 2);
	print_seqlist(seqlist);
	return 0;
}

/*链式单链表*/
#include <stdio.h>
#include <stdlib.h>

typedef char data_t;
typedef struct node_t {
	data_t data;
	struct node_t *next;
}linklist_t, linknode_t;

//创建链表
//1.创建头结点malloc
//2.将头结点的next置为NULL
//3.返回创建好的头结点的首地址
linklist_t *create_linklist();
//删除一个节点，删除ll节点的下一个节点
int delete_linklist(linklist_t *ll);

int delete_linklist_index(linklist_t *ll, int index);
//头插法和尾插法
//1.创建一个节点
//2.对创建的节点进行赋值
//3.进行插入
int insert_linklist(linklist_t *ll, data_t *data);

int insert_linklist_index(linklist_t *ll, data_t *data, int index);
//长度
int length_linklist(linklist_t *ll);
//清空链表
int clear_linklist(linklist_t *ll);
//销毁
int destroy_linklist(linklist_t *ll);
int getdata_linklist(linklist_t *ll, int index, data_t *data);
void print_linklist(linklist_t *ll);
int main(int argc, const char *argv[])
{
	linklist_t *ll = create_linklist();
	int i;
	char j;
	for(i = 0; i < 6; i++)
	{
		scanf("%c", &j);
		insert_linklist(ll, &j);
	}
	print_linklist(ll);
	j = 'E';
	insert_linklist_index(ll, &j, 1);
	print_linklist(ll);
	delete_linklist(ll);
	delete_linklist_index(ll, 3);
	print_linklist(ll);
	return 0;
}
//创建链表
//1.创建头结点malloc
//2.将头结点的next置为NULL
//3.返回创建好的头结点的首地址
linklist_t *create_linklist()
{
	linklist_t *ll = (linklist_t *)malloc(sizeof(linklist_t));
	ll->next = NULL;

	return ll;
}
//删除一个节点，删除ll节点的下一个节点
int delete_linklist(linklist_t *ll)
{
	if(ll->next == NULL)
		return -1;

	linklist_t *p = ll->next;
	ll->next = p->next;
	free(p);

	return 0;
}

int delete_linklist_index(linklist_t *ll, int index)
{
	if(ll->next == NULL || index < 0)
		return -1;
	int i;
	for(i = 0; i < index; i++)
	{
		ll = ll->next;
		if(ll->next == NULL)
			break;
	}
	if(i != index)
		return -1;
	delete_linklist(ll);


	return 0;
}
//头插法和尾插法
//1.创建一个节点
//2.对创建的节点进行赋值
//3.进行插入
int insert_linklist(linklist_t *ll, data_t *data)
{
	linklist_t *node = (linklist_t *)malloc(sizeof(linklist_t));
	node->data = *data;

	node->next = ll->next;
	ll->next = node;

	return 0;
}

int insert_linklist_index(linklist_t *ll, data_t *data, int index)
{
	if(index < 0)
		return -1;
	int i;
	for(i = 0; i < index; i++)
	{
		ll = ll->next;
		if(ll->next == NULL)
			break;
	}
	if(i != index)
		return -1;
	insert_linklist(ll, data);


	return 0;

}
//长度
int length_linklist(linklist_t *ll)
{
	int len = 0;
	while(ll->next != NULL)
	{
		len++;
		ll = ll->next;
	}

	return len;
}
//清空链表
int clear_linklist(linklist_t *ll)
{
	while(ll->next != NULL)
		delete_linklist(ll);

	return 0;
}
//销毁
int destroy_linklist(linklist_t *ll)
{
	clear_linklist(ll);
	free(ll);

	return 0;
}
int getdata_linklist(linklist_t *ll, int index, data_t *data)
{
	if(index < 0)
		return -1;
	int i;
	for(i = 0; i <= index; i++)
	{
		ll = ll->next;
		if(ll == NULL)
			break;
	}
	if(i != index + 1)
		return -1;
	*data = ll->data;

	return 0;
}
void print_linklist(linklist_t *ll)
{
	while(ll->next != NULL)
	{
		printf("%c ", ll->next->data);
		ll = ll->next;
	}
	putchar(10);
}

/*顺序栈*/
#include <stdio.h>
#include <stdlib.h>

typedef int data_t;
typedef struct {
	data_t *data;
	int top;
	int max_len;
}seqstack_t;

//创建顺序栈
//1.开辟一个顺序表的空间
//2.开辟数据区域的空间
//3.给每一个顺序表的成员赋值
//4.返回顺序表的首地址
seqstack_t *create_seqstack(int len);
//销毁顺序表
//释放数据区域，再释放顺序表
int destroy_seqstack(seqstack_t *ss);

//清空
int clear_seqstack(seqstack_t *ss);
//入栈
int push_seqstack(seqstack_t *ss, data_t *data);
//出栈
int pop_seqstack(seqstack_t *ss, data_t *data);
//获得栈顶元素的数据
int gettop_seqstack(seqstack_t *ss, data_t *data);
//判断栈是否为空
int empty_seqstack(seqstack_t *ss);
//判断栈是否为满
int full_seqstack(seqstack_t *ss);

int get_pro(char opt)
{
	switch(opt)
	{
	case '*':
	case '/':
		return 1;
	case '+':
	case '-':
		return 2;
	}

	return 1000;
}

int my_calc(int opd_1, char opt, int opd_2)
{
	switch(opt)
	{
	case '*':
		return opd_1 * opd_2;
	case '/':
		return opd_1 / opd_2;
	case '+':
		return opd_1 + opd_2;
	case '-':
		return opd_1 - opd_2;	
	}

	return -1;
}

int main(int argc, const char *argv[])
{
	if(argc != 2)
	{
		printf("Input error!\n");
		return -1;
	}
	const char *p = argv[1];
	int opd_1, opd_2, opt;
	seqstack_t *operand, *operator;
	operand = create_seqstack(10);
	operator = create_seqstack(10);
	while(*p != '\0')
	{
		if(*p <= '9' && *p >= '0')
		{
			opd_1 = 0;
			while(*p >= '0' && *p <= '9')
			{
				opd_1 = opd_1 * 10 + *p - '0';
				p++;
			}
			push_seqstack(operand, &opd_1);
			continue;		 
		}
		else
		{
			while(1)
			{
				if(empty_seqstack(operator) == 0)
				{
					opt = *p;
					push_seqstack(operator, &opt);
					break;
				}
				else
				{
					gettop_seqstack(operator, &opt);
					if(get_pro(*p) < get_pro(opt))
					{
						opt = *p;
						push_seqstack(operator, &opt);
						break;
					}
					else
					{
						pop_seqstack(operand, &opd_2);
						pop_seqstack(operand, &opd_1);
						pop_seqstack(operand, &opt);
						opd_1 = my_calc(opd_1, (char)opt, opd_2);
						push_seqstack(operand, &opd_1);
					}
				}
			}
		}
		p++;
	}
	while(empty_seqstack(operator) != 0)
	{
		pop_seqstack(operand, &opd_2);
		pop_seqstack(operand, &opd_1);
		pop_seqstack(operand, &opt);
		opd_1 = my_calc(opd_1, (char)opt, opd_2);
		push_seqstack(operand, &opd_1);
	}
	pop_seqstack(operand, &opd_2);
	destroy_seqstack(operand);
	destroy_seqstack(operator);
	printf("The result is :%d\n", opd_2);

	return 0;
}
//创建顺序栈
//1.开辟一个顺序表的空间
//2.开辟数据区域的空间
//3.给每一个顺序表的成员赋值
//4.返回顺序表的首地址
seqstack_t *create_seqstack(int len)
{
	seqstack_t *ss = (seqstack_t *)malloc(sizeof(seqstack_t));
	ss->data = (data_t *)malloc(sizeof(data_t) * len);
	ss->top = -1;//初始化栈，表明栈当前为空
	ss->max_len = len;

	return ss;
}
//销毁顺序表
//释放数据区域，再释放顺序表
int destroy_seqstack(seqstack_t *ss)
{
	free(ss->data);
	free(ss);

	return 0;
}

//清空
int clear_seqstack(seqstack_t *ss)
{
	ss->top = -1;

	return 0;
}
//入栈
int push_seqstack(seqstack_t *ss, data_t *data)
{
	if(full_seqstack(ss) == 0)
		return -1;
	ss->top++;
	//ss->data[ss->top] = *data;
	*(ss->data + ss->top) = *data;

	return 0;
}
//出栈
int pop_seqstack(seqstack_t *ss, data_t *data)
{
	if(empty_seqstack(ss) == 0)
		return -1;
	*data = *(ss->data + ss->top);
	ss->top--;

	return 0;
}
//获得栈顶元素的数据
int gettop_seqstack(seqstack_t *ss, data_t *data)
{
	if(empty_seqstack(ss) == 0)
		return -1;
	*data = *(ss->data + ss->top);

	return 0;
}

int  empty_seqstack(seqstack_t *ss)
{
	return ss->top == -1 ? 0 : -1;
}

int full_seqstack(seqstack_t *ss)
{
	return ss->top + 1 == ss->max_len ? 0 : -1;
}

/*链式栈*/
#include <stdio.h>
#include <stdlib.h>
#include "mytypes.h"

//创建链表
//1.创建头节点malloc
//2.将头节点的next置NULL
//3.返回头节点首地址
linkstack_t *create_linkstack()
{
	linkstack_t *ls = (linkstack_t *)malloc(sizeof(linkstack_t));
	ls->next = NULL;
	return ls;
}

int clear_linkstack(linkstack_t *ls)
{
	while(ls->next != NULL)
	{
		linkstack_t *p = ls->next;
		ls->next = p->next;
		free(p);
	}
	return 0;
}

int destroy_linkstack(linkstack_t *ls)
{
	clear_linkstack(ls);
	free(ls);
	return 0;
}

int push_linkstack(linkstack_t *ls, ln_data_t *data)
{
	linkstack_t *node = (linkstack_t *)malloc(sizeof(linkstack_t));
	node->data = *data;
	
	node->next = ls->next;
	ls->next = node;

	return 0;
}
int pop_linkstack(linkstack_t *ls, ln_data_t *data)
{
	if(ls->next == NULL)
		return -1;
	*data = ls->next->data;
	linkstack_t *p = ls->next;
	ls->next = p->next;
	free(p);

	return 0;
}

int empty_linkstack(linkstack_t *ls)
{
	return ls->next == NULL ? 0 : -1;
}

int gettop_linkstack(linkstack_t *ls,ln_data_t *data)
{
	*data = ls->next->data;
	return 0;
}

/*顺序队列*/
#include <stdlib.h>
#include "mytypes.h"

//创建
//1.开辟顺序队列的大小
//2.开辟数据区域的大小
//3.给成员赋值
// 1)sq->front = sq->rear = 0;
// 2)seq->max_len = len;
//4.返回创建好的队列的首地址
sequeue_t *create_sequeue(int len)
{
	sequeue_t *sq = (sequeue_t *)malloc(sizeof(sequeue_t));
	sq->data = (q_data_t *)malloc(sizeof(q_data_t) * len);
	sq->front = sq->rear = 0;
	sq->max_len = len;

	return sq;
}
//销毁
int destroy_sequeue(sequeue_t *sq)
{
	free(sq->data);
	free(sq);

	return 0;
}
//清空队列
int clear_sequeue(sequeue_t *sq)
{
	sq->front = sq->rear;

	return 0;
}

//入队操作
int en_sequeue(sequeue_t *sq, q_data_t *data)
{
	sq->rear = (sq->rear + 1) % sq->max_len;
	sq->data[sq->rear] = *data;

	return 0;
}
//出队
int de_sequeue(sequeue_t *sq, q_data_t *data)
{
	sq->front = (sq->front + 1) % sq->max_len;
	*data = *(sq->front + sq->data);

	return 0;
}
//获得队头元素
int getfront_sequeue(sequeue_t *sq, q_data_t *data)
{
	*data = sq->data[(sq->front + 1) % sq->max_len];

	return 0;
}

int empty_sequeue(sequeue_t *sq)
{
	return sq->front == sq->rear ? 0 : -1;
}

int full_sequeue(sequeue_t *sq)
{
	return (sq->rear + 1) % sq->max_len == sq->front ? 0 : -1;
}

/*链式队列*/
#include <stdio.h>
#include <stdlib.h>
#include "mytypes.h"
//创建
linkqueue_t *create_linkqueue()
{
	linkqueue_t *lq = (linkqueue_t *)malloc(sizeof(linkqueue_t));
	lq->front = lq->rear = (linknode_t *)malloc(sizeof(linknode_t));
	lq->len = 0;
	lq->rear->next = NULL;
	return lq;
}

int empty_linkqueue(linkqueue_t *lq)
{
	return lq->front == lq->rear ? 0 : -1;
}

int de_linkqueue(linkqueue_t *lq, n_data_t *data)
{
	if(empty_linkqueue(lq) == 0)
		return -1;
	linknode_t *q = lq->front;
	lq->front = lq->front->next;
	free(q);
	*data = lq->front->data;
	lq->len--;

	return 0;
}

int clear_linkqueue(linkqueue_t *lq)
{
	n_data_t data;
	while(de_linkqueue(lq, &data) == 0);

	return 0;
}

int destroy_linkqueue(linkqueue_t *lq)
{
	clear_linkqueue(lq);
	free(lq->front);
	free(lq);

	return 0;
}

int en_linkqueue(linkqueue_t *lq, n_data_t *data)
{
	linknode_t *node = (linknode_t *)malloc(sizeof(linknode_t));
	node->data = *data;
	node->next = NULL;
	lq->rear->next = node;
	lq->rear = node;
	lq->len++;

	return 0;
}

int getfront_linkqueue(linkqueue_t *lq, n_data_t *data)
{
	if(empty_linkqueue(lq) == 0)
		return -1;
	*data = lq->front->next->data;

	return 0;
}