头节点链表C程序

main.c文件

#include <stdio.h>
#include "headNode.h"


int main()
{
	// 创建链表，空链表
	Node *head = Create_List();
	if (head == NULL)
		return -1;
	
	int i;
	for (i = 0; i < 20; i++)
	{
		Insert_Head(head, i);
	}
	
	for (i = 0; i < 20; i++)
	{
		;//Insert_Last(head, i);
	}
	
	// 错误1：空表的情况下插入节点
	//Insert_Pos(head, 0, 2);  
	
	// 正确：空表的情况下在第一个节点处插入
	//Insert_Pos(head, 1, 2);   
	
	// 错误2：空表的情况下在非第一个节点处插入
	//Insert_Pos(head, 2, 2);  
	
	// 正确：在最后一个节点后面插入
	//Insert_Pos(head, 2, 2); 
	
	// 错误3：越界
	//Insert_Pos(head, 5, 2); 
	//Insert_Pos(head, 11, 200); 
	
	DisPlay_List(head);
	
	//Reverse_List(head);
	
	//Delete_Data(head, 11);
	
	//Delete_Pos(head, 1);
	
	if (Find_Element(head, 300) == OK)
		printf ("有\n");
	else
		printf ("没有\n");
	
	printf ("%d\n", Get_Element(head, 5));
	
	printf ("len = %d\n", Get_Len(head));
	
	DisPlay_List(head);
	
	
	
	return 0;
}

headNode.c文件

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

// 创建链表，所谓创建链表，就是创建一个头结点
Node* Create_List()
{
	Node* head = (Node*)malloc(sizeof(Node)/sizeof(char));
	if (head == NULL)
		return NULL;
	
	// 空表
	head->next = NULL; 
	
	
	return head;
}

int Insert_Head(Node* head, ElementType data)
{
	if (head == NULL)
		return ERROR;
	
	Node *node = (Node*)malloc(sizeof(Node)/sizeof(char));
	if (node == NULL)
	{
		return ERROR;
	}
	node->data = data;
	
	node->next = head->next; // 让新结点指向当前的第一个结点
	head->next = node;       // node变成了当前的第一个结点
	
	return OK;
}

int Insert_Last(Node* head, ElementType data)
{
	if (head == NULL)
	{
		return ERROR;
	}
	Node *node = (Node*)malloc(sizeof(Node)/sizeof(char));
	if (node == NULL)
	{
		return ERROR;
	}
	node->data = data;
	node->next = NULL;
	
	
	// 找到next为空的结点
	Node *tmp = head;
	while(tmp->next)
	{
		tmp = tmp->next;
	}
	
	tmp->next = node;
	
	return OK;
}

int Insert_Pos(Node* head, int pos, ElementType data)
{
	if (head == NULL || pos < 1)
	{
		printf ("参数有误\n");
		return ERROR;
	}
		
	
	Node *tmp = head;
	int k = 0;
	
	while (tmp != NULL && k < pos -1)
	{
		tmp = tmp->next;
		k++;
	}
	
	if (tmp == NULL)  // 越界
	{
		printf ("插入位置越界\n");
		return ERROR;
	}
	
	Node *node = (Node*)malloc(sizeof(Node)/sizeof(char));
	if (node == NULL)
	{
		return ERROR;
	}
	node->data = data;
	
	node->next = tmp->next;
	tmp->next = node;
	
	return OK;
	
	
}

int Reverse_List(Node *head)
{
	// head->next == NULL  空表
	// head->next->next == NULL  只有一个结点
	if (head == NULL ||  head->next == NULL || head->next->next == NULL)
	{
		return OK;
	}
	
	Node *p    = head->next->next;     // 第二个结点 
	Node *q    = head->next;           // 第一个结点
	Node *temp;
	
	while (p)
	{
		temp = p->next;
		p->next = q;
		q = p;
		p = temp;
	}
	
	// 把第一个节点的下一个节点置为空
	head->next->next = NULL;
	// 重置头节点的next
    head->next = q;
	return OK;
	
}

int Delete_Data(Node* head, ElementType data)
{
	if (head == NULL)
	{
		return ERROR;
	}
	
	Node *tmp = head;
	while(tmp->next)
	{
		if (tmp->next->data == data)
			break;
		
		tmp = tmp->next;
	}
	
	if (tmp->next != NULL)   // 找到了存data结点的前一个结点
	{
		Node *p = tmp->next;
		tmp->next = p->next;
		free(p);
	}
	
	return OK;
}

int Delete_Pos(Node* head, int pos)
{
	if (head == NULL || pos < 1)
	{
		printf ("参数有误\n");
		return ERROR;
	}
		
	Node *tmp = head;
	int k = 0;
	
	while (tmp != NULL && k < pos -1)
	{
		tmp = tmp->next;
		k++;
	}
	
	if (tmp == NULL || tmp->next == NULL)  // 越界
	{
		printf ("删除位置越界\n");
		return ERROR;
	}
	
	Node *p = tmp->next;
	tmp->next = p->next;
	free(p);
	
	return OK;
}

int Find_Element(Node* head, ElementType data)
{
	
	if (head == NULL)
	{
		return ERROR;
	}
	
	Node *tmp = head->next;
	while(tmp)
	{
		if (tmp->data == data)
			break;
		
		tmp = tmp->next;
	}
	
	if (tmp == NULL)
		return ERROR;
	
	return OK;
}

ElementType Get_Element(Node* head, int pos)
{
	if (head == NULL || pos < 1)
	{
		printf ("参数有误\n");
		return ERROR;
	}
		
	
	Node *tmp = head->next;
	int k = 1;
	
	while (tmp != NULL && k < pos)
	{
		tmp = tmp->next;
		k++;
	}
	
	if (tmp == NULL)
	{
		return ERROR;
	}
	
	return tmp->data;
}

int Get_Len(Node * head)
{
	if (head == NULL)
		return ERROR;
	
	int count = 0;
	Node *tmp = head->next;
	while (tmp)
	{
		count++;
		tmp = tmp->next;
	}
	
	return count;
}

void DisPlay_List(Node* head)
{
	Node *tmp = head->next;
	int count = 0;
	while(tmp)
	{
		//count++ % 4 == 0 && putchar('\n');
		if (count++ % 4 == 0)
			putchar('\n');
		printf ("%8d", tmp->data);
		tmp = tmp->next;
	}
	putchar('\n');
}

int Clean_List(Node * head)
{
	if (head == NULL)
		return ERROR;
	
	Node *tmp = head;
	while (tmp->next)
	{
		Delete_Pos(head, 1);
	}
	
	return OK;
}

int Destroy(Node *head)
{
	Clean_List(head);
	
	free(head);  // 释放头节点
	
	return OK;
}

headNode.h文件

#ifndef __HEADNODE_H__
#define __HEADNODE_H__

#define OK      0
#define ERROR  -1

typedef int ElementType;
// 链表的节点
typedef struct _Node
{
	ElementType data;     // 链表节点数据   : 数据域
	struct _Node *next;   // 链表节点的指针 : 指针域
}Node;

// 创建链表
Node* Create_List();

// 插入数据：头插法
int Insert_Head(Node* head, ElementType data);

// 插入数据：尾插法
int Insert_Last(Node* head, ElementType data);

// 在 第 pos 个节点处插入数据 约定：链表没有第0个节点，从第一个节点开始
int Insert_Pos(Node* s, int pos, ElementType data);

// 逆序
int Reverse_List(Node *head);

// 链表数据打印
void DisPlay_List(Node* head);

// 删除指定数据
int Delete_Data(Node*, ElementType data);

//删除 第 pos 个结点
int Delete_Pos(Node*, int pos);

// 查找元素：查看顺序表中是否有对应的元素，有返回元素的索引
int Find_Element(Node* s, ElementType data);

// 获取顺序表中的元素：通过下标获取
ElementType Get_Element(Node* s, int pos);

int Get_Len(Node * head);

int Clean_List(Node * head);

// 销毁顺序表
int Destroy(Node *);

#endif // __HEADNODE_H__