链表的基本操作

最新推荐文章于 2022-05-09 13:13:46 发布
最新推荐文章于 2022-05-09 13:13:46 发布
阅读量597 收藏 1
点赞数
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chencheng126/article/details/39138605
版权 
</pre><p>head代表第一个指针，前面加了一个dummy节点，方面用来处理头指针。</p><p><pre name="code" class="cpp">#include <iostream>
using namespace std;

struct LinkNode{
	int data;
	LinkNode *next;
	LinkNode(int x):data(x),next(NULL){}
};

//创建只有空链表，返回一个dummy节点
LinkNode * createLink()
{
	LinkNode *dummy = new LinkNode(-1);
	return dummy;
}

LinkNode * initLink(LinkNode *dummy)
{
	//用一个数组初始化链表
	int array[] = {1,2,3,4,5,6};

	LinkNode *tmp,*head;
	tmp = dummy;
	//使用的是尾插入法
	for(int i=0;i<sizeof(array)/sizeof(int);i++)
	{
		LinkNode *p = new LinkNode(array[i]);
		tmp->next=p;
		tmp = tmp->next;
	}
	head = dummy->next;
	delete dummy;
	return head;	
}

//显示链表
void showList(LinkNode *head)
{
	while(head)
	{
		printf("%d ",head->data);
		head = head->next;
	}
	printf("\n");
	return;
}

//找值为x的前驱
LinkNode * findPrevious(LinkNode *head,int x)
{
	if(head->data == x)
		return NULL;
	LinkNode *p = head;
	while(p->next != NULL && p->next->data != x)
		p = p->next;

	if(p->next == NULL)
		return NULL;
	else
		return p;
}

//在某个节点后，增加一个新的节点
void addNewNodeAfter(LinkNode *insertPos,int x)
{
	LinkNode *p = new LinkNode(x);
	p->next = insertPos->next;
	insertPos->next = p;
	return;
}

//在某个节点insertPos前插入一个新的节点
LinkNode* addNewNodeBefore(LinkNode *head,int insertPos,int x)
{
	LinkNode *dummy = new LinkNode(-1);
	dummy->next = head;
	LinkNode *pre = dummy;
	while(pre->next!=NULL && pre->next->data!=insertPos)
		pre = pre->next;
	if(pre->next == NULL)//找不到insertPos对应的节点
		return head;
	LinkNode *p = new LinkNode(x);
	p->next = pre->next;
	pre->next = p;
	head = dummy->next;
	delete dummy;
	return head;
}

//在第K个元素之前，增加一个新的节点
LinkNode * insertKthNode(LinkNode *head,int k,int x)
{
	LinkNode *dummy = new LinkNode(-1);
	dummy->next = head;
	LinkNode *pre = dummy;

	//找到前驱元素.需要移动k-1次
	for(int i=1;pre->next !=NULL && i<k;i++)
		pre = pre->next;

	if(pre->next == NULL)//k超过了链表的长度
		return head;
	
	LinkNode *p = new LinkNode(x);
	p->next = pre->next;
	pre->next = p;
	head = dummy->next;
	delete dummy;
	return head;
}

//删除值为x的节点，用dummy节点
LinkNode * deleteNode(LinkNode *head,int x)
{
	LinkNode *dummy = new LinkNode(-1);
	dummy->next = head;
	LinkNode *pre = dummy;

	//找到被删除节点的前驱
	while(pre->next != NULL && pre->next->data != x)
		pre = pre->next;
	if(pre->next == NULL) //找不到x对应的节点
		return head;
	LinkNode *cur = pre->next;
	pre->next = cur->next;
	delete cur;
	head = dummy->next;
	delete dummy;
	return head;
}

//删除值为x的节点，不用dummy节点
LinkNode* deleteNode2(LinkNode *head,int x)
{
	if(head->data == x)
	{
		//如果是头结点，新增一个dummy节点
		LinkNode *dummy = new LinkNode(-1);
		dummy->next = head;
		LinkNode *newHead = head->next;
		dummy->next = newHead;
		delete head;
		return newHead;
	}

	//找到x的前驱
	LinkNode *pre = findPrevious(head,x);
	if(NULL == pre) return head;
	LinkNode *p = pre->next;
	pre->next = p->next;
	delete p;
	return head;
}

//reverse 一个链表
LinkNode *reverse(LinkNode *head)
{
	LinkNode *pre = NULL;
	while(head)
	{
		LinkNode *tmp = head->next;
		head->next = pre;
		pre = head;
		head = tmp;			
	}
	return pre;
}

//摧毁链表
void desroyList(LinkNode *head)
{
	while(head)
	{
		LinkNode *tmp = head->next;
		delete head;
		head = tmp;		
	}
	return;
}

void main()
{
	//创建一个空链表
	LinkNode *dummy = createLink();
	//对链表初始化，返回head
	LinkNode *head = initLink(dummy);
	//显示链表
	showList(head);
	//找前驱
	LinkNode *p = findPrevious(head,3);
	printf("%d\n",p->data);
	//在某个节点insertPos前插入一个新的节点
	addNewNodeBefore(head,3,100);
	showList(head);
	//在第K个元素前加入一个新的节点
	head = insertKthNode(head,1,101);
	showList(head);
	//删除值为x节点
	head = deleteNode(head,1);
	showList(head);
	//reverse 链表
	LinkNode *head_reverse = reverse(head);
	showList(head_reverse);
	//销毁链表
	desroyList(head_reverse);
}






 

修改前的。
 

</pre><pre code_snippet_id="601534" snippet_file_name="blog_20150210_1_3771789" name="code" class="cpp">
 

#include <iostream>
using namespace std;
struct Node
{
	int data;
	struct Node *Next;
};


//创建只有头结点的空链表
struct Node * createList()
{
	struct Node * head = NULL;
	head = (struct Node*)malloc(sizeof(struct Node));
	if(NULL == head)
	{
		printf("Create fail!\n");
		return NULL;
	}
	head->Next = NULL;
	head->data = -1;
	return head;
}

//头插法建立链表
bool insertFromHead(struct Node * head,int x)
{
	struct Node * p = NULL;
	p = (struct Node *)malloc(sizeof(struct Node));
	if (NULL == p)
	{
		printf("Malloc fail!\n");
		return false;
	}
	p->data = x;
	p->Next = head->Next;
	head->Next = p;
	return true;
}

//尾插法建立链表
bool insertFromTail(struct Node * head,int x)
{
	struct Node * tmp = head;
	struct Node * p = NULL;
	p = (struct Node *)malloc(sizeof(struct Node));
	if(NULL == p)
	{
		printf("malloc fail!\n");
		return false;
	}

	//找到目前的最后一个结点，将新元素插到后面
	while(tmp->Next)
		tmp = tmp->Next;
	p->data = x;
	p->Next = NULL;
	tmp->Next = p;
	return true;
}

//增加一个结点,在insertPos后面添加一个结点
bool addNewNodeAfter(struct Node * head,struct Node * insertPos,int x)
{
	struct Node * p = (struct Node *)malloc(sizeof(struct Node));
	if(NULL == p)
	{
		printf("malloc fail\n");
		return false;
	}
	p->Next = insertPos->Next;
	p->data = x;
	insertPos->Next = p;
	return true;
}

//查找含有值为x的前驱p.如果存在多个x的值，我们返回第一个。
struct Node * findPrevious(struct Node * head,int x)
{
	struct Node * p = head;
	while(p->Next!=NULL && p->Next->data!= x)
		p = p->Next;

	if(NULL == p->Next)
	{
		printf("The value %d is not exist in this list!\n",x);
		return NULL;
	}
	else
	        return p;
}

//在对应元素insertPos的前面，增加一个结点
bool insertNewNodeBefore(struct Node * head,int insertPos,int x)
{
	struct Node * pre = findPrevious(head,insertPos);
	if (NULL == pre)
	{
		printf("No record find!");
		return false;
	}

	struct Node *p = (struct Node *)malloc(sizeof(struct Node));
	if (NULL == p)
	{
		printf("malloc failed!");
		return false;
	}

	p->Next = pre->Next;
	p->data = x;
	pre->Next = p;
	return true;
}

//在第k个元素之前，增加一个结点
void insertNodeKth(struct Node * head,int k,int x)
{
	struct Node *pre = head;
	for(int i = 1;pre->Next!=NULL && i < k;i++)
		pre = pre->Next;//找到前驱结点

	struct Node *p = (struct Node *)malloc(sizeof(struct Node));
	if(NULL==p)
	{
		printf("malloc failed");
		return;
	}

	p->Next = pre->Next;
	p->data = x;
	pre->Next = p;
	return;
}

//在第K个元素后面，插入一个值
void insertKthAfter(struct Node *head,int k,int x)
{
	struct Node *cur = head->Next;
	for(int i = 1;cur->Next!=NULL && i < k;i++)
		cur=cur->Next;

	struct Node *p = (struct Node *)malloc(sizeof(struct Node));
	if(NULL==p)
	{
		printf("malloc failed");
		return;
	}

	p->Next = cur->Next;
	p->data = x;
	cur->Next = p;
}

//删除值为x的结点
void deleteNode(struct Node * head,int x)
{
	struct Node *pre = findPrevious(head,x);
	if (NULL == pre)
	     return;

	struct Node *p = pre->Next;
	pre->Next = p->Next;
	free(p);
	return;
}

//reversse.遍历原来的链表节点，用头插法重新生成一个新的链表
struct Node * generateRerverse(struct Node *head)
{
	struct Node *head_reverse,*tmp,*p;
	head_reverse = (struct Node *)malloc((sizeof(struct Node)));
	if(NULL == head_reverse)
	{
		printf("Malloc fail\n");
		return NULL;
	}
	head_reverse->Next = NULL;
	head_reverse->data = 0;

	tmp = head->Next;
	while(tmp!=NULL)
	{
		p = (struct Node *)malloc(sizeof(struct Node));
		if(NULL == p)
		{
			printf("Malooc fail\n");
			return NULL;
		}
		p->data = tmp->data;
		p->Next = head_reverse->Next;
		head_reverse->Next = p;		
		tmp = tmp->Next;
	}
	return head_reverse;
}

//将这个链表翻转，不产生新的链表
struct Node * reverseCurLinkList(struct Node *head)
{
	struct Node *first,*last,*cur,*post,*tmp;
	cur = head->Next;
	post = cur->Next;
	first = cur;
	while(post!=NULL)
	{
		tmp = post->Next;
		post->Next = cur;//将cur和post的指向翻转
		cur = post;//cur和post分别向后移动一个
		post = tmp;
	}
	last = cur;
	first->Next = NULL;//原来第一个节点，现在在末尾
	head->Next = last;//原来最后一个节点，现在位于第一个
	return head;
}

//显示链表
bool showList(struct Node * head)
{
	struct Node * tmp = head->Next;
	if(NULL == tmp)
		printf("The list is NULL");
	while(tmp)
	{
		printf("%d ",tmp->data);
		tmp = tmp->Next;
	}
	printf("\n");
	return true;
}

//摧毁链表
void deleteList(struct Node * head)
{
	struct Node *p,*tmp;
	p = head->Next;
	head->Next = NULL;
	while(p)
	{
		tmp = p->Next;
		free(p);
		p=tmp;
	}
}


void main()
{
	struct Node * pre = NULL;
	struct Node * head = createList();
	if(NULL == head)
	{
		printf("create list fail!\n");
		return;
	}
	//insertFromHead(head,1);
	//insertFromHead(head,2);
	//insertFromHead(head,3);

	insertFromTail(head,1);
	insertFromTail(head,2);
	insertFromTail(head,3);
	insertFromTail(head,4);
	insertFromTail(head,5);
	showList(head);

	//查找前驱
	//pre = findPrevious(head,3);
	//if (pre!=NULL)
		//printf("The pre value is: %d\n",pre->data);

	//在元素i前面，增加一个元素
	//insertNewNodeBefore(head,5,10);
	//showList(head);

	//在第k个元素前，增加一个元素
	//insertNodeKth(head,1,100);
	//showList(head);

	//在第K个元素后面，增加一个元素
	//insertKthAfter(head,1,99);
	//showList(head);

	//产生一个全新的翻转链表
	//struct Node *head_reverse = generateRerverse(head);
	//showList(head_reverse);

	//将当前的链表翻转，不产生新的链表
	head = reverseCurLinkList(head);
	showList(head);

	//删除值为x的结点
	//deleteNode(head,100);
	//showList(head);

	//销毁List
	//deleteList(head);
	//showList(head);
	return;
}
 

 

 


                

        

        

    

  


    

      

        

            

              
                
                  如沐春风心旷神怡
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
链表的基本操作(单链表、双向链表、循环链表)

				
			

			

				

					FallingU的博客
				

				

					08-02
					
					1467
					
				

			

		

		

			
				
本周第一次讲座，学长给我们简单的概述了数据结构和算法，然后对链表的一些操作进行了讲解，下来之后，我把原来书上的一些


链表的基本操作与链表的逆置，排序等操作结合起来，整理出来



链表是由结点构成的，关键是定义结点C语言程序设计上两大特例：①链表节点的定义②递归函数的定义。这两个违反了先定义再使用。

一、链表的分类     


        3.静态链表：各结点在

			
		

	



                

              
                



	

		

			

				
					
链表基础操作

				
			

			

				

					weixin_73494910的博客
				

				

					09-06
					
					215
					
				

			

		

		

			
				
链表基本操作

			
		

	



                


  
              

                


	

		

			

				
					
【链表的基本操作】

				
			

			

				

					m0_67691566的博客
				

				

					04-29
					
					744
					
				

			

		

		

			
				
链表的基本操作
链表是数据存储的一种链式结构，使用链表存储的数据元素，其物理存储位置是随机的。数据元素随机存储，并通过指针表示数据之间逻辑关系的存储结构就是链式存储结构。

链表的节点
链表中每个数据的存储都由以下两部分组成：
数据元素本身，其所在的区域称为数据域；
指向直接后继元素的指针，所在的区域称为指针域

一个存储 {1,2,3} 的完整链表结构如图 
定义链表结构体：
typedef struct LinkNode {
    char data;
    struct LinkNode *nex

			
		

	





	

		

			

				
					
链表--基本操作

				
			

			

				

					weixin_61196797的博客
				

				

					05-09
					
					883
					
				

			

		

		

			
				
文章目录前言一、链表的创建二、反转链表1.三指针法2.使用头插法建立新链表来反转三、删除链表的倒数第K个结点1.遍历链表，求出倒数第K个结点2.快慢指针法进行删除四、合并两个有序链表总结

前言
关于五月考核前三题
1.反转链表
2.删除链表的倒数第n个结点
3.合并两个有序链表

先进行链表的动态创建
一、链表的创建
注意包含头文件<stdlib.h>
//先创建一个结构体
struct Node {
	int data;
	struct Node* next;
};
//创建表头
struc

			
		

	



		

			
		



	

		

			

				
					
链表基本操作

				
			

			

				

					Blackvisitor的博客
				

				

					12-23
					
					146
					
				

			

		

		

			
				
#include<stdio.h>
#include<stdlib.h>
struct node
{
 int value;
 struct node* next;
};
void menu(void)
{
 printf("选项菜单:\n");
 printf("1.初始化链表\n");
 printf("2.插入新节点\n");
 printf("3.删除节点\n");
 printf("4.搜索值\n");
 printf("5....

			
		

	





	

		

			

				
					
实验二 链表基本操作的实现

				
			

			

				

					12-18
				

			

		

		

			
				
在这个实验“链表基本操作的实现”中，我们将深入理解链表的概念，学习如何创建、插入、删除节点，以及进行其他基本操作。  链表不同于数组，它不连续存储元素，而是通过节点间的指针链接。每个节点包含两部分：数据...

			
		

	





	

		

			

				
					
链表基本操作源码

				
			

			

				

					12-28
				

			

		

		

			
				
以下是对链表基本操作的详细讲解：  1. **链表的定义**  链表由一系列节点组成，每个节点包含数据和指向下一个节点的指针。对于双向链表，每个节点还包含一个指向前一个节点的指针。在C语言中，链表节点（或称为结点...

			
		

	





	

		

			

				
					
lianbiao.rar_链表基本操作_链表操作

				
			

			

				

					09-24
				

			

		

		

			
				
接下来，我们将深入探讨链表的基本操作，包括链表的创建、删除以及统计链表长度。  1. **链表的创建**  创建链表首先要定义节点结构，一般包括数据域（存储数据）和指针域（指向下一个节点）。例如，我们可以定义一...

			
		

	





	

		

			

				
					
C语言链表基本操作.pdf

					
最新发布

				
			

			

				

					10-17
				

			

		

		

			
				
C语言链表基本操作  C语言链表基本操作是一个基础的数据结构操作，包括链表的创建、插入、删除、反转、查找和打印等操作。在这篇文章中，我们将详细介绍这些操作的实现方法和代码。  一、链表的创建  链表的创建是指...

			
		

	





	

		

			

				
					
链表的基本操作源代码

				
			

			

				

					weixin_30768661的博客
				

				

					05-16
					
					244
					
				

			

		

		

			
				
//链表的基本操含有对链表的建立，插入，删除，查询，输出等基本操作
/在此特别提醒链表的基础尤为重要，在这里重写此代码能够更加深刻的理解了链表的空间的申请，
/头节点的建立以及头指针的重要和尾节点存在的必要性
/这个源代码以链表的创建为核心，为了怕麻烦就没有进行优化，但是创建和输出是这个代码的核心。
/希望这个能帮助到初学者，在这有不懂得地方可以看我的随笔，链表的整表的创建，那里有更加详细...

			
		

	





	

		

			

				
					
双向循环链表基本操作

				
			

			

				

					09-12
				

			

		

		

			
				
双向循环链表是一种链表结构，每个节点都有指向前一个节点和后一个节点的指针，同时头节点的前驱指针指向尾节点，尾节点的后继指针指向头节点。基本操作包括以下几种：

1. 创建链表：可以创建一个空链表或者带有初始元素的链表。创建空链表时，将头节点和尾节点指向自身，同时前驱和后继指针为空。

2. 插入节点：可以在链表的任意位置插入新的节点。需要注意的是，在插入节点之前需要先找到要插入位置的前一个节点，然后修改前一个节点的后继指针和后一个节点的前驱指针，以及新节点的前驱和后继指针。

3. 删除节点：可以删除链表中的任意节点。同样需要先找到要删除的节点，然后修改前一个节点的后继指针和后一个节点的前驱指针，将要删除的节点从链表中断开。

4. 查找节点：可以根据给定的值或者位置查找链表中的节点。从头节点开始遍历链表，直到找到目标节点或者遍历完整个链表。

5. 遍历链表：可以按照顺序遍历整个链表，输出每个节点的值。

这些是双向循环链表的基本操作，可以根据实际需求进行扩展和优化。希望对你有所帮助！

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值