C语言-链表

#include<stdio.h>
#include<stdlib.h>//malloc()
#include<assert.h>
#include"List.h"

int main()
{
	List list;//定义一个链表
	initLink(&list);//初试化链表

	menu();
	DATA item;
	while (1)
	{
		int select = 0;
		printf("选择想要的操作\n");
		scanf("%d", &select);
		switch (select)
		{
		case 1:
			printf("输入push_back的数据：");
			while (scanf("%d", &item), item != -1)
			{
				push_back(&list, item);
			}
			//select = 4;
			break;
		case 2:
			printf("输入push_front的数据：");
			while (scanf("%d", &item), item != -1)
			{
				push_front(&list, item);
			}
			break;

		case 3:
			printf("删除元素：");
			pop_front(&list);
			
			break;

		case 4:
			printf("链表中的元素有：\n");
			display(&list);
			break;
		case 5:
			printf("输入查找元素：\n");
			scanf("%d", &item);
			Node* f = find(&list, item);
			if (f==NULL)
			{
				printf("没有找到元素%d",item);
			}
			else
			{
				printf("找到元素：%d地址为：%p", f->data, f);
			}
			
			break;
		case 6:
			sort(&list);
			printf("排序完成！！！");
			break;
		default:
			break;
		}
	}
	

	
	system("pause");
	return 0;
}

void initLink(List* list)
{
	list->size = 0;//初始化链表的数据元素个数为0
	list->front = NULL;//前结点为空
	list->tail = NULL;//尾结点为空
}

void menu()
{
	printf("********[1]链表尾添加元素***********\n");
	printf("********[2]链表头添加元素***********\n");
	printf("********[3]删除元素*****************\n");
	printf("********[4]显示元素*****************\n");
	printf("********[5]查找元素*****************\n");
	printf("********[6]冒泡排序*****************\n");
}
//尾入表
void push_back(List* list, DATA val)
{
	//如何插？？
	//先申请一个结点
	Node* node = (Node*)malloc(sizeof(Node));
	//判断是否申请内存成功
	assert(node != NULL);//为空的时候就会报错
	//把需要插入的值给新申请的结点
	node->data = val;
	node->next = NULL;
	//该链表是否为空链表，
	if (list->front!=NULL)//不为空链表
	{
		list->tail->next = node;
		list->tail = node;
	}
	else//为空链表
	{
		list->front = node;
		list->tail = node;
		list->size++;
	}

}
//头入表
void push_front(List* list, DATA val)
{
	Node* node = (Node*)malloc(sizeof(Node));
	//判断是否申请内存成功
	assert(node != NULL);//为空的时候就会报错
	//把需要插入的值给新申请的结点
	node->data = val;
	node->next = NULL;
	//该链表是否为空链表，
	if (list->front != NULL)//不为空链表
	{
		//新节点指向头结点
		node->next = list->front;
		list->front = node;
	}
	else//为空链表
	{
		list->front = node;
		list->tail = node;
		list->size++;
	}
}
//头出链表
//头出链表
void pop_front(List* list)
{
	if (list->front==NULL)
	{
		return;
	}
	Node* delNode = list->front; 
	list->front = list->front->next;
	free(delNode);
	list->size--;
}
//尾出链表
void pop_back(List* list)
{
	if (list->front == NULL)
	{
		return;
	}
	//只有一个元素时
	if (size(list)==1)
	{
		free(list);
		initLink(list);
	}
	else
	{
		Node* delNode = list->front;
		Node* curNode = list->front;
		Node* prevNode = list->front;
		while (curNode!=NULL)
		{
			prevNode = curNode;
			curNode = curNode->next;
		}
		free(curNode);
		list->tail = prevNode;
		list->tail->next = NULL; 
	}

	Node* delNode = list->tail;
	list->tail->next = list->tail;
	free(delNode);
}

//显示链表元素
void display(List* list)
{
	Node* curNode = list->front;
	while (curNode!=NULL)
	{
		printf("%-2d", curNode->data);
		curNode =curNode->next;
	}
}
//链表元素个数
int size(List* list)
{
	return list->size;
}
//查找元素
Node* find(List* list, DATA val)
{
	if (list->front==NULL)
	{
		return NULL;
	}
	Node* curNode = list->front;
	while (curNode!=NULL)
	{
		if (curNode->data==val)
		{
			return curNode;
		}
		curNode = curNode->next;

	}
	return NULL;
}

//冒泡排序
void sort(List*list)
{
	if (size(list)<=1)
	{
		return;
	}
	for (Node* i = list->front->next; i->next != NULL; i = i->next)
	{
		for (Node* k = list->front;  k->next != NULL; k = k->next)
		{
			if (k->data> k->next->data)
			{
				DATA temp = k->data;
				k->data = k->next->data;
				k->next->data = temp;
			}    
		} 
	}

}

#pragma once
#ifndef __LIST_H
#define __LIST_H

//ADT abstract data type抽象数据类型
typedef int DATA;
typedef struct Node_tag {

	DATA data;
	struct Node_tag* next;
}Node;

typedef struct List_tag {
	int size;//元素个数
	Node* front;//头结点
	Node* tail;//尾结点
}List;

void initLink(List *list);//链表初始化
void menu();//菜单
void push_back(List* list, DATA val);//尾插入值
void display(List* list);//显示元素
void push_front(List* list, DATA val);//头插值 
void pop_front(List* list);//头出表
void pop_back(List* list);//尾出表
Node* find(List* list, DATA val);//查找元素
int size(List* list);
void sort(List* list);//冒泡排序
#endif // !__LIST_J