单向链表基础操作（删除、插入、查询）代码实现及进阶（反转、排序、逆置、查找倒数第K个节点、查找中间节点）

最新推荐文章于 2022-01-04 22:38:11 发布
最新推荐文章于 2022-01-04 22:38:11 发布
阅读量280 收藏 1
点赞数
分类专栏： 代码 single_linked_list 文章标签： 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Faded0104/article/details/107923884
版权

single_linked_list.h

 

/*
          **功能：应用C语言实现单链表的各项操作
          **                  1：建立节点
          **                  2：打印单链表    
          **                  3：尾插
          **                  4：尾删
          **                  5：头插       
          **                  6：头删    
          **                  7：清空整个链表   
          **                  8：获取链表长度    
          **                  9：查找数据    
          **                10：在某位置后插入数据    
          **                11：删除某位置的数据
*//*
          //      进阶应用
          **                12：删除一个无头单链表的非尾节点
          **                13：在无头单链表的一个非头节点前插入一个节点
          **                14：查找中间节点
          **                15：查找倒数第k个节点(要求只能遍历一次)
          **                16：倒着打印单链表
          **                17：逆置单链表
          **                18：合并两个有序链表（合并后依然有序）
          **                19：冒泡排序
          **                                                         
 */

#ifndef __SINGLE_LINKED_LIST_
#define __SINGLE_LINKED_LIST_

typedef struct single_list
{
	struct single_list* next;
	DataType data;
}single_list_node;
/*
          **功能：应用C语言实现单链表的各项操作
          **                  1：建立节点
          **                  2：打印单链表    
          **                  3：尾插
          **                  4：尾删
          **                  5：头插       
          **                  6：头删    
          **                  7：清空整个链表   
          **                  8：获取链表长度    
          **                  9：查找数据    
          **                10：在某位置后插入数据    
          **                11：删除某位置的数据
*/

single_list_node* CreateSingleList(DataType data);
void destroySingleList(single_list_node* head);

single_list_node* SingleList_insertTail(single_list_node* head, DataType data);
single_list_node* SingleList_DeleteNodeTail(single_list_node* head);

single_list_node* SingleList_insertHead(single_list_node* head, DataType data);
single_list_node* SingleList_DeleteNodeHead(single_list_node* head);

single_list_node* singleList_insert_byPos(single_list_node* head, int pos, DataType data);
single_list_node* SingleList_NodeDelete_byPos(single_list_node* head,int pos);

single_list_node* SinleList_search_byData(single_list_node* head, DataType data);
single_list_node* SingleList_search_byPos(single_list_node* head, int pos);

void SingleList_showdata(single_list_node* head);
int Get_SingleList_Length(single_list_node* head);

void deleteListNode(single_list_node* node);
single_list_node* SingleList_BuyNode(DataType data);
single_list_node* SingleList_search_TailNode(single_list_node* head, single_list_node** tail_pre);


/*
		  //      进阶应用
          **                12：删除一个无头单链表的非尾节点
          **                13：在无头单链表的一个非头节点前插入一个节点
          **                14：查找中间节点
          **                15：查找倒数第k个节点(要求只能遍历一次)
          **                16：倒着打印单链表
          **                17：逆置单链表
          **                18：合并两个有序链表（合并后依然有序）
          **                19：冒泡排序
          **                                                         
 */
/*15：查找倒数第k个节点(要求只能遍历一次)*/
single_list_node* find_Reverse_order_nth_number(single_list_node* head, int n);

/* 17：逆置单链表 */
single_list_node* Reverse_List(single_list_node* head);
/*合并两个有序链表*/
single_list_node* Merge_two_ordered_list(single_list_node* list1, single_list_node* list2);
/* 16：倒着打印单链表 */
void Reverse_print_linked_list(single_list_node* head);

/*链表排序*/
single_list_node* SortList(single_list_node* head);

/*查找中间节点*/
single_list_node* Find_middle_node(single_list_node* head);

#endif

sing_linked_list.c

#include "public.h"
#include "stack.h"
#include "single_linked_list.h"




/*创建链表，创建有一个节点的链表*/
single_list_node* CreateSingleList(DataType data)
{
	single_list_node* node = NULL;
	node = SingleList_BuyNode(data);
	return node;
}
/*销毁整个链表*/
void destroySingleList(single_list_node* head)
{
	single_list_node* next = NULL, *p = head;

	while(NULL != p)
	{
		next = p->next;
		deleteListNode(p);
		p = next;
	}
}
/*链表尾部插入节点*/
single_list_node* SingleList_insertTail(single_list_node* head, DataType data)
{
	single_list_node *p = NULL, *tail = NULL;
	single_list_node *new_node = NULL;
	single_list_node* tail_pre = NULL;
	new_node = SingleList_BuyNode(data);

	
	p = SingleList_search_TailNode(head, &tail_pre);
	if(NULL == p)
	{
		return new_node;
	}
	p->next = new_node;

	return head;
	
}
/*尾部删除一个节点*/
single_list_node* SingleList_DeleteNodeTail(single_list_node* head)
{
	single_list_node* p = head, *pre = NULL;
	single_list_node* tail_pre = NULL;
	if(NULL == head)
	{
		printf("head is NULL,no node can be deleted.\n");
		return NULL;
	}

	p = SingleList_search_TailNode(head, &tail_pre);
	if(head == p)
	{
		deleteListNode(p);
		printf("delete head node when SingleList_DeleteNodeTail..\n");
		return NULL;
	}
	deleteListNode(p);
	tail_pre->next = NULL;
	return head;
}
/*头插一个节点, 返回新的头结点*/
single_list_node* SingleList_insertHead(single_list_node* head, DataType data)
{
	single_list_node *node = NULL, *p = head;

	node = SingleList_BuyNode(data);
	if(node == NULL)
	{
		printf("malloc Failed when SingleList_insertHead,so head not change.\n ");
		return head;
	}

	node->next = head;


	return node;
}
/*头删除一个节点*/
single_list_node* SingleList_DeleteNodeHead(single_list_node* head)
{
	single_list_node* p = head, *head_next = NULL;

	if(NULL == p)
	{
		printf("head is NULL when SingleList_DeleteNodeHead.\n ");
		return NULL;
	}

	head_next = head->next;
	deleteListNode(p);
	return head_next;
}

/*指定位置后面插入一个节点，比如要插入1位置，则pos=0, 0位置插入不能用这个函数*/
single_list_node* singleList_insert_byPos(single_list_node* head, int pos, DataType data)
{
	single_list_node* p = NULL, *new_node = NULL;
	single_list_node* p_pos = NULL;

	p_pos = SingleList_search_byPos(head, pos);
	if(NULL != p_pos)
	{
		p = p_pos->next;
		new_node = SingleList_BuyNode(data);
		p_pos->next = new_node;
		new_node->next = p;
	}
	else
	{
		printf("Not find the pos when singleList_insert_byPos.\n ");
		return head;
	}
	return head;
}


/*删除指定位置的节点*/
single_list_node* SingleList_NodeDelete_byPos(single_list_node* head, int pos)
{
	single_list_node* p_pos = NULL, *p = NULL;
	single_list_node* pre = NULL;

	p_pos = SingleList_search_byPos(head, pos);
	if(NULL == p_pos)
	{
		printf("Not find pos in list when SingleList_NodeDelete_byPos.\n ");
		return head;
	}

	//p指向删除节点的next
	p = p_pos->next;

	//删除的节点是0位置，头结点变化
	if(head == p_pos)
	{
		deleteListNode(p_pos);
		return p;
	}

	//找要删除节点的前驱
	pre = head;
	while(1)
	{
		if(pre->next == p_pos)
		{
			break;
		}
		pre = pre->next;
	}
	//删除节点的next指向删除节点的下一个节点
	pre->next = p;
	deleteListNode(p_pos);

	return head;
}

/*指定位置查询*/
single_list_node* SingleList_search_byPos(single_list_node* head, int pos)
{
	int i = 0;
	single_list_node* p = head;

	while(p != NULL)
	{
		if(i == pos)
		{
			return p;
		}
		++i;
		p = p->next;
	}
	printf("List length is shorter than pos when SingleList_search_byPos.\n");
	return NULL;
}
/*查找第一个数据是data的节点，并返回该节点指针*/
single_list_node* SinleList_search_byData(single_list_node* head, DataType data)
{
	single_list_node* p = head;

	while(NULL != p)
	{
		if(data == p->data)
		{
			return p;
		}
		p = p->next;
	}
	if(NULL == p)
	{
		printf("Single List not find the data:%d.\n", data);
		return NULL;
	}
	return 0;
}

/*删除节点*/
void deleteListNode(single_list_node* node)
{
	if(NULL != node)
	{
		free(node);
		node = NULL;
	}
}
/*malloc一个节点  并赋值*/
single_list_node* SingleList_BuyNode(DataType data)
{
	single_list_node* node = (single_list_node*)malloc(sizeof(single_list_node));
	node->data = data;
	node->next = NULL;
	return node;
}
/*显示数据*/
void SingleList_showdata(single_list_node* head)
{
	single_list_node* p = head;
	while(NULL != p)
	{
		printf("%d	", p->data);
		p = p->next;
	}
	printf("\n");
	printf("-------------------------------\n\n");
}
/*获取链表长度*/
int Get_SingleList_Length(single_list_node* head)
{
	int len = 0;
	single_list_node* p = head;
	while(NULL != p)
	{
		++len;
		p = p->next;
	}
	return len;
}
/*返回链表的尾部节点指针*/
single_list_node* SingleList_search_TailNode(single_list_node* head, single_list_node** tail_pre)
{
	single_list_node* p = head;
	*tail_pre = NULL;

	if(NULL == p)
	{
		return NULL;
	}

	while(p->next != NULL)
	{
		*tail_pre = p;
		p = p->next;
	}
	return p;
}
//
/*15：查找倒数第k个节点(要求只能遍历一次)*/
single_list_node* find_Reverse_order_nth_number(single_list_node* head, int n)
{
	int i = 0;
	single_list_node* p1 = head, *p2 = head;

	if(n <=0)
	{
		printf("input %d is InValid.\n",n);
		return NULL;
	}
	while(p1 != NULL)
	{
		++i;
		if(i == n)
		{
			break;
		}
		p1 = p1->next;
	}
	if(i != n)
	{
		printf("The List's Length is less than n = %d\n", n);
		return NULL;
	}
	while(p1->next != NULL)
	{
		p1 = p1->next;
		p2 = p2->next;
	}

	return p2;
}
/* 16：倒着打印单链表 */
void Reverse_print_linked_list(single_list_node* head)
{
	single_list_node* p = head;
	stack* st = createStack();
	
	while(p != NULL)
	{
		push(st, p->data );
		p = p->next;
	}
	while(!StackIsEmpty(st))
	{
		printf("%d	",GetTop(st));
		pop(st);
	}
	printf("\n");
	
}
/* 17：逆置单链表 */
single_list_node* Reverse_List(single_list_node* head)
{
	single_list_node *p = NULL, *p_left = NULL, *p_right = NULL;

	p_left = head ;
	if(NULL == head)
	{
		return NULL;
	}

	/*p指向即将反转指向的节点，p_left指向被反转后的链表的尾部节点
	  p_right指向还没处理的部分的第一个节点*/
	p = head->next;
	p_left->next = NULL;

	while(p != NULL)
	{
		p_right = p->next;
		p->next = p_left;
		p_left = p;
		p = p_right;
	}
	return p_left;
}

/*链表排序：冒泡*/
single_list_node* SortList(single_list_node* head)
{
	single_list_node *p = NULL, *p_left = NULL, *p_right = NULL;
	single_list_node *tmp = NULL, *prev = NULL;

	p_left = head;

	if(head == NULL)
	{
		return NULL;
	}

	p = head->next;
	p_left->next = NULL;
	/*p_left指向已拍好序的链表的头结点
	  p_right指向还没排序的头节点
	  p是从未排序的链表的头部取下来，即将有序插入已排好序的p_left指向的链表*/
	while(p != NULL)
	{
		p_right = p->next;

		tmp  = p_left;
		/*tmp遍历已排好序的链表，找p的data应该放的位置
		   prev是最终p的前驱，tmp是p的后继*/
		prev = NULL;
		while(tmp != NULL && tmp->data < p->data)
		{
			prev = tmp;
			tmp = tmp->next;
		}

		//比已排好序的链表的第一个元素还小，头插
		if(NULL == prev)
		{
			p->next = p_left;
			p_left = p;
			p = p_right;

			continue;
		}

		prev->next = p;
		p->next = tmp;

		p = p_right;

	}

	return p_left;
}


/*合并两个有序链表*/
/*思想：可以这样想，是将两个链表list1, list2合成一个第三个链表merge_list的过程。
1. 先从两个链表的头中选择小的节点，初始化作为合成链表merge_list的头，
2. 然后从两个链表头开始，选择两个链表头节点小的那一个，开始找，找到全部小于另外一个链表头的所有节点，
3. 将这部分加到merge_list，然后这个链表的头更新，
继续开始重复2， 直到有一个链表到达结尾null*/
single_list_node* Merge_two_ordered_list(single_list_node* list1, single_list_node* list2)
{
	single_list_node *last1 = NULL, *p1 = NULL, *last2 = NULL, *p2 = NULL;
	single_list_node *tmp1 = NULL, *tmp2 = NULL;
	single_list_node* head = NULL;
	
	if(NULL == list1)
	{
		return list2;
	}
	if(NULL == list2)
	{
		return list1;
	}
	
	p1 = list1;
	p2 = list2;
	
	/*两个链表都是从小到大的，因此两个头中小的那一个是合并后链表的头节点*/
	if(p1->data <= p2->data)
	{
		head = p1;
	}
	else
	{
		head = p2;
	}
	

	/*两个指针p1 p2分别指向两个链表中本次在比较的数字，
	  举例子，假设p1->data <= p2->data情况:
	  选取小的那个节点所在的链表p1，从p1开始向后找，在list1中找到大于p2节点的前一个节点last1,
	  则p1到last1之间的数字都是小于p2节点的，将last1->next指向p2，即将list1中小于p2节点的节点从list1中插入到p2前面了。
	   此时p1更新为last1的下一个节点，开始新一次的处理*/
	while(p1 != NULL && p2 != NULL)
	{
		if(p1->data <= p2->data)
		{
			tmp1 = p1;
			while(tmp1 != NULL && tmp1->data <= p2->data)
			{
				last1 = tmp1;
				tmp1 = tmp1->next;
			}
			last1->next = p2;
			p1 = tmp1;
			last1 = NULL;
		}
		else
		{
			tmp2 = p2;
			while(tmp2 != NULL && tmp2->data <= p1->data)
			{
				last2 = tmp2;
				tmp2 = tmp2->next;
			}
			last2->next = p1;
			p2 = tmp2;
			last2 = NULL;
		}
	}
	return head;
	
}



/*查找中间节点*/
/*思想很简单，两个指针，同时开始从头走，一个一次走两步，一个一次走一步，
偶数节点时候，中间的返回前面或后面的都可，奇数个节点的时候返回中间节点*/
single_list_node* Find_middle_node(single_list_node* head)
{
	single_list_node *p1 = NULL, *p2 = NULL;

	if(NULL == head)
	{
		return NULL;
	}
	p1 = p2 = head;
	while(p1 != NULL)
	{
		p1 = p1->next;
		if(NULL == p1)
		{
			break;
		}		
		p1 = p1->next;
		p2 = p2->next;
	}
	return p2;
}

 

Faded0104
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表操作之删除倒数第k个结点
John的博客
06-10 5844
****单链表操作之删除倒数第k个结点**** //函数功能：删除链表的倒数第k个结点；1 //自定义的结点结构体和头指针结构体： //函数原型：void DelKNode(pLinList pList, int k)； ps：我在博客中每次的思路分析，只是将我的对每道题的理解和思考列出来，里面会有我做题时思考的经过，各种失败的尝试等等，希望我的
单链表的创建、查找、排序、插入、删除、倒置和合并等操作
m198984的博客
12-09 641
单链表的创建、查找、排序、插入、删除、倒置和合并等操作 #ifndef __LINKLIST_H__ #define __LINKLIST_H__ #include <stdio.h> #include <stdlib.h> #include <stdbool.h> typedef int datatype; typedef struct linknode ...
线性表——单链表的增删改查（头插法，尾插法，按序号查找，按值查找，某个位置插入元素，某个位置删除元素）
weixin_46398446的博客
01-04 1481
目录一、链表的特点二、链表的特点三、代码实现结构体1.头插法打印链表完整代码 一、链表的特点 逻辑上相邻的两个元素在物理位置上不相邻。 二、链表的特点 两部分组成：数据域data和指针域next。最后一个为NULL。 三、代码实现 结构体 typedef int ElemType; // 定义结构体 typedef struct LNode { ElemType data; // 数据域 struct LNode* next; // 定义结构体指针，指向下一个结点。因为从上往下编译，所以不能
链表尾插法
qq_33661910的博客
01-28 1013
# include&lt;stdio.h&gt; # include&lt;stdlib.h&gt; using namespace std; typedef struct node { int data; struct node * next; }Node; //尾插法，需要引入第三方变量，保证头指针起到定海神针的作用，最后将头结点的指针返回给头指针 Node * creat_list...
单链表的基本操作(增删改查）
uiiiiii的博客
11-28 335
对于单链表的创建上篇文章我们已经写过了，但是在这还为大家展示一下尾插法创建链表： 首先定义一个头指针，接下来为新的节点开辟空间，并让头指针等于它： 接下来再创建新的节点并让前一个节点变为旧的结点，并让旧节点中的指针指向新节点： 然后就是不断重复上述第二步。 struct notes { int n; struct notes *next; }; int cnt;//定义一个整型变量用来计算结点的数量 struct notes*create() { struct ..
单链表的增删改查，就地逆置、倒数第k个节点算法实现
YangLong的博客
07-19 296
前言唠叨一下 最近有点时间，总结了一下单链表的各种操作，包括增删改查，就地逆置、求倒数第k个节点等。工作之余重新回顾一下，虽然工作中很少用到，Java也封装了比较完善的链表实现，但对于自己的算法理解多多少少也有所帮助。 效果图 链表类实现逻辑 package com.list; /** * 单链表-带头结点 */ public class SingleLinkedList<T> { private int size; private Node head; /** * 构
自己手动实现单链表的头插 、尾插、删除、逆置、倒数第K个节点、判断是否有环、求其入口点、合并有序单链表
weixin_44579258的博客
05-20 163
class Link<T extends Comparable<T>> { /** * 单链表的节点类型 * @param <T> */ static class Entry<T> { T data; // 链表节点的数据域 Entry<T> next; //...
Cracking coding interview(2.2)返回单向链表的倒数第n个节点
u011559205的专栏
07-26 479
2.2 Implement an algorithm to find the nth to last element of a singly linked list.
数据结构--单链表
WX_timi的博客
02-07 546
数据结构–单链表 InitList(LinkList &L) 参数：单链表L 功能：初始化 时间复杂度 O(1) ListLength(LinkList L) 参数：单链表L 功能：获得单链表长度 时间复杂度O(n) ListInsert(LinkList &L,int i,ElemType e) 参数：单链表L,位置i，元素e 功能：位置i后插 时间复杂度O(n)[加入了查找]...
1-5 LC25 K个一组翻转链表 LC61 旋转链表 LC24 两两交换链表中的节点 Java力扣刷题笔记
一碗菜粥的博客
04-24 256
LC25 K个一组翻转链表 LC61 旋转链表 LC24 两两交换链表中的节点
C语言实现链表之单向链表（九）在任意位置插入结点
君临天下的博客
11-08 4921
C语言实现链表之单向链表（九）在任意位置插入结点     上一篇文章给出了删除尾结点的函数，本篇文章将给出在任意位置插入结点的函数。 /*============================================================================== * 操作 ：在任意位置插入结点 * 操作前：pHeadNode为链表的头
逆置单链表以及求链表倒数第k个结点——题集（二）
就是爱编程-都有人重名的博客
07-14 536
逆置单链表及求链表倒数第k个结点——题集（二）        今天分享一下两道练习题，即逆置单链表以及求链表倒数第k个结点，要求时间复杂度为O(1)。        首先分享一下逆置单链表的代码和运行界面。单链表分为带头结点的单链表和不带头结点的单链表。        源代码如下： #include using namespace std; //逆置/反转单链表，要求只能遍历一次链表
链表基础内容
weixin_54025765的博客
09-05 247
#include <iostream> using namespace std; struct Linked { /********* Begin *********/ //结构体的成员变量 int number; float score; Linked *next; /********* End *********/ }; Linked* Create() { /********* Begin *********/ //创建并返回一个新链表 Linked *head .
单链表的增删查 逆置 倒数第k个节点等问题
weixin_34074740的博客
04-12 90
对于单链表而言，它没有双链表那么复杂，它只有头节点，尾节点，节点数据，后继指针。在下面本人实现了单链表的增删插查改。 #include<stdio.h> #include<assert.h> #include<malloc.h> #include<stdlib.h> typedefin...
单链表的逆置、获取倒数第k个单链表节点的值的方法实现
cx_cx__cx的博客
08-19 134
/** * 单链表的节点类型 * @param <T> */ static class Entry<T>{ T data; // 链表节点的数据域 Entry<T> next; // 下一个节点的引用 public Entry(T data, Entry<T> n...
逆置/反转单链表+查找单链表的倒数第k个节点
JavaScripe2013的博客
07-15 235
//链表定义 typedef struct Node{ Node(const int& value) : m_value(value) , m_pNext(NULL) {} int m_value; Node* m_pNext;}Node,pNode ResList(pNode pHead) { if (pHead == NULL) r
单链表的插入与删除算法
热门推荐
yychenxie21的专栏
10-11 1万+
的
单链表的基本操作（逆置、合并、查找倒数第K个元素、在指定节点插入元素、输出相交节点、判断是否有环）
ccuaman的博客
11-26 400
** 单链表的基本操作 ** 一、逆置单链表
用C语言创建单链表并实现插入、删除等简单操作
HXZ_CREATE的博客
06-08 5448
单链表比起顺序表来说存储更灵活，在需要进行频繁的插入或删除操作的情况下，使用单链表来操作更加简单。但是在需要查找元素，计算链表长度时又会显得比较麻烦。选择顺序表还是单链表是要依情况而定。 创建单链表（头插法）： 头插法：始终让每个新结点放在链表中第一个位置，这样导致的结果是：当我们对链表进行遍历时，先遍历的是最后加入链表的结点。（下面给出的代码先不给新结点的数据域赋值，尾插法也是） void CreateListHead( LinkList *L , int length ) { int i ;
用头插法创建一个单向链表，并对此单向链表实现插入，删除，查找等操作，用c语言
最新发布
05-09
下面是头插法创建单向链表，并实现插入、删除和查找操作的代码： ```c #include #include // 定义链表节点结构体 typedef struct node { int data; struct node* next; } Node; // 创建一个空链表 Node* ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值