数据结构学习笔记之链表

链式表：
元素的数据项：
数据域：可以是各种类型的若干个数据项
指针域：指向下一元素
由若干个元素通过指针域连接在一起形成链式表。

不带头节点：第一个元素的数据域存储的就是有效的数据。
添加删除时可以会修改头节点指针，参数需要使用二维指针。
同时需要获取到上一个节点的指针，而头节点没有上一个节点，因此需要额外处理。

带头节点：第一个元素不使用，仅仅是为了用它来指向下一元素。

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define TYPE int

// 设计链表的节点
typedef struct Node
{
	TYPE data; 			// 节点的数据域
	struct Node* next;  // 节点的指针域
}Node;

// 创建节点
Node* create_node(TYPE data)
{
	// 分配节点所需要的内存
	Node* node = malloc(sizeof(Node));
	node->data = data;
	node->next = NULL;
	return node;
}

// 添加
void add_list(Node** head,TYPE data)
{
	Node* node = create_node(data);
	node->next = *head;
	*head = node;
}

// 删除
bool del_value_list(Node** head,TYPE data)
{
	for(Node* n=*head; NULL!=n->next; n=n->next)
	{
		// 找到待删除节点的上一个
		if(n->next->data == data)
		{
			// 备份待删除节点
			Node* temp = n->next;
			// 连接上一个与下一个节点
			n->next = temp->next;
			// 删除
			free(temp);
			return true;
		}
	}

	if((*head)->data == data)
	{
		Node* temp = *head;
		*head = temp->next;
		free(temp);
		return true;
	}
	
	return false;

}

// 访问
bool access_list(Node* head, int index , TYPE* val)
{
	Node* n = head;
	for(int i=0; NULL!=n && i<index; i++)
	{
		n=n->next;
	}
	

	if(NULL==n) return false;
	
	*val = n->data;
	return true;

}

// 遍历 
void show_list(Node* head)
{
	for(Node* n=head; NULL!=n; n=n->next)
	{
		printf("%d ",n->data);
	}
	printf("\n");
}

// 排序
void sort_list(Node* head)
{
	for(Node* i=head; NULL!=i->next; i=i->next)
	{
		for(Node* j=i->next; NULL!=j; j=j->next)
		{
			if(i->data > j->data)
			{
				TYPE temp = i->data;
				i->data = j->data;
				j->data = temp;
			}
		}
	}
}

bool del_index_list(Node** head,int index)
{
	if(0 == index)
	{
		Node* temp = *head;
		*head = temp->next;
		free(temp);
		return true;
	}
	Node* n = *head;
	while(--index>0)
	{
		n = n->next;
		if(NULL == n->next) return false;
	}
	Node* temp = n->next;
	n->next = temp->next;
	free(temp);
	return true;
}

int main(int argc,const char* argv[])
{
	/*
	Node* n1 = create_node(1);	
	Node* n2 = create_node(2);	
	Node* n3 = create_node(3);	
	Node* n4 = create_node(4);	
	Node* n5 = create_node(5);	
	Node* n6 = create_node(6);	
	n1->next = n2;
	n2->next = n3;
	n3->next = n4;
	n4->next = n5;
	n5->next = n6;
	for(Node* n=n1; n!=NULL; n=n->next)
	{
		printf("%d ",n->data);
	}
	*/

	Node* head = NULL;
	for(int i=0; i<10; i++)
	{
		add_list(&head,rand()%100);
	}
	
	show_list(head);
	sort_list(head);
	show_list(head);
	del_index_list(&head,6);
	show_list(head);

}

带头节点的链表

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define TYPE int

// 设计链表的节点
typedef struct Node
{
	TYPE data; 			// 节点的数据域
	struct Node* next;  // 节点的指针域
}Node;

// 创建节点
Node* create_node(TYPE data)
{
	// 分配节点所需要的内存
	Node* node = malloc(sizeof(Node));
	node->data = data;
	node->next = NULL;
	return node;
}

// 头添加
void add_head_list(Node* head,TYPE val)
{
	Node* node = create_node(val);
	node->next = head->next;
	head->next = node;
}

// 尾添加
void add_tail_list(Node* head,TYPE val)
{
	// 创建一个新节点
	Node* node = create_node(val);

	// 找到最后一个节点
	Node* n = head;
	while(NULL!=n->next) n = n->next;
	
	// 最后一个节点指向新的节点
	n->next = node;

}

// 按位置删除
bool del_index_list(Node* head,int index)
{
	// 上到待删除的上一个节点
	Node* n = head;
	for(int i=0; i<index; i++)
	{
		n=n->next;
		if(NULL == n->next) return false;
	}

	// 备份待删除的节点
	Node* temp = n->next;
	n->next = temp->next;
	free(temp);
	return true;

}

// 按值删除
bool del_value_list(Node* head,TYPE val)
{
	Node* n = head;
	while(NULL != n->next)
	{
		if(val == n->next->data)
		{
			Node* temp = n->next;
			n->next = temp->next;
			free(temp);
			return true;
		}
		n = n->next;
	}
	return false;
}

// 插入
bool inster_list(Node* head,int index,TYPE val)
{
	Node* n = head;
	for(int i=0; i<index; i++)
	{
		n = n->next;
		if(NULL == n->next) return false;
	}
	Node* node = create_node(val);
	node->next = n->next;
	n->next = node;
	return true;
}

// 修改
bool modify_list(Node* head,TYPE old,TYPE val)
{
	for(Node* n=head->next; NULL!=n; n=n->next)
	{
		if(old == n->data)
		{
			n->data = val;
			return true;
		}
	}
	return false;
}

// 访问

bool access_list(Node* head,int index,TYPE* val)
{
	Node* n = head->next;
	for(int i=0; i<index; i++)
	{
		n = n->next;
		if(NULL == n) return false;
	}

	*val = n->data;
	return true;

}

// 排序
void sort_list(Node* head)
{
	for(Node* i=head->next; NULL!=i->next; i=i->next)
	{
		for(Node* j=i->next; NULL!=j; j=j->next)
		{
			if(i->data > j->data)
			{
				TYPE temp = i->data;
				i->data = j->data;
				j->data = temp;
			}
		}
	}
}

// 查询
int query_list(Node* head,TYPE key)
{
	Node* n = head->next;
	for(int i=0; n!=NULL; i++)
	{
		if(key == n->data)
			return i;
		n = n->next;
	}

	return -1;

}

// 遍历
void show_list(Node* head)
{
	for(Node* n=head->next; NULL!=n; n=n->next)
	{
		printf("%d ",n->data);
	}
	printf("\n");
}

int main(int argc,const char* argv[])
{
	Node* head = create_node(0);
	for(int i=0; i<10; i++)
	{
		add_tail_list(head,rand()%100);
	}
	show_list(head);
	TYPE val;
	access_list(head,9,&val);
	printf("%d\n",val);
	sort_list(head);
	show_list(head);
	printf("%d\n",query_list(head,100));
}