单链表的插入删除以及逆转

一、背景说明

参加了某团购网站2014年的校招笔试，里面考到了一道单链表反转的题目。要求每隔k个元素反转一次。

如k=1时，链表1，2，3，4，5，6，7，8反转后为1，2，3，4，5，6，7，8

    k=3时，链表1，2，3，4，5，6，7，8反转后为3，2，1，6，5，4，8，7

当时不会做，于是回来重新复习了下链表并实现了以下操作：

1）创建头结点

     注意这里要把头结点L返回，因为传入的形参是头结点指针，给头结点分配空间后指针地址变化了。所以需要返回指针L才行。

     （这里改变的不是指针指向的内容，而是指针的地址）

2）在位置i插入元素

     找到要插入的位置i的前一个元素p。

     创建一个新的结点s，s的后缀指针指向p的下一个。

     p的后缀指针指向s。

3）删除位置i的元素

 

      找到要删除的位置i的前一个元素p。

     r为p的下一个元素，即要删除的元素。

     p的后缀指针指向r的下一个元素。

     释放r。

4）单链表反转

    提示：假设有三个元素pPrev，pNode，pNext。要想反转pNode，pPrev，则把pNode的下一个指向pPrev就可以了。

                但是此时链表就断开了，所以还需要记录下pNext的位置。不断循环直到链表尾（pNode为空）即可。

5）单链表每隔K个反转

    提示：计算链表长度，除以反转间隔k得出要反转的趟数。参照4的方法反转即可。

二、代码实现

 

#include <stdio.h>

#include <stdlib.h>



/*

定义一个结构体

*/

typedef struct Node{

	int data;

	struct Node *next;

}Node,*ListNode;



/*

创建一个头结点

*/

Node* initial(Node *L){

	L=(Node *)malloc(sizeof(Node));

	L->next=NULL;

 	return L;

}





/*

在位置i插入一个元素x

初始化列表是i可置1,即采用头插法添加元素。

*/

int Insert(Node* head,int x,int i){

	ListNode p;

	p=head;

	int j=1;

	while(p->next&&j<i){//找第i-1个元素p

		p=p->next;

		j++;

	}

	if(p==NULL || j>i){

		printf("insert error");

		return -1;

	}

	Node* s=(Node *)malloc(sizeof(Node));

	s->data = x;

	s->next = p->next;

	p->next = s;

	return 0;

}



/*

删除第i个元素

*/

int Delete(ListNode head,int i){

	Node *p,*r;

	p=head;

	int j=1;

	

	while(p->next&&j<i){//找第i-1个元素p

		p=p->next;

		++j;

	}

	if(p==NULL || p->next==NULL || j>i){

		printf("delete error");

		return -1;

	}

	r=p->next;

	p->next = r->next;

	free(r);

	return 0;

}



/*

单链表反转

*/

int Reverse(Node *head){

	Node* revHead = NULL;

	Node* pNode = head->next;//初始为第一个元素

	Node* pPrev = NULL;//当前元素的前缀元素指针

	Node* pNext = NULL;//当前元素的后缀元素指针

	while(pNode!=NULL){

		pNext = pNode->next;//保存当前元素的后缀元素

		if(pNext==NULL)

			revHead=pNode;

		pNode->next=pPrev;//当前元素的下一个指向前缀元素

		pPrev=pNode;//前缀元素指向当前元素

		pNode=pNext;//当前元素指向下一个要逆转的元素，即后缀元素

	}

	head->next = revHead;

	return 0;

}

	 

/*

单链表每隔K个元素反转

如k=3时1，2，3，4，5，6，7，8则反转为3，2，1，6，5，4，8，7

*/



int NumReverse(Node *head,int k){

	Node* lastTail = head; //上一组列表的表尾

	Node* pNode = head->next; //当前元素

	Node* groupTail = NULL; //当前组的表尾

	Node* pPrev = NULL;//当前元素的前缀元素

	Node* pNext = NULL;//当前元素的后缀元素

	int count =0; //已反转的趟数

	int length =0;//要反转的趟数



	while(pNode!=NULL){//计算链表长度

		length++;

		pNode = pNode->next;

	}

	

 	pNode = head->next;

	length=length/k;//要逆转的趟数

	

	while(pNode!=NULL && count<=length){//逆转length躺

		pPrev = NULL;

		pNext = NULL;

		groupTail = pNode;

		 

		int i=0;



		while(pNode!=NULL && i<k){//如果下一个元素还有且当前趟已逆转个数i<k则继续反转

			pNext = pNode->next;

			pNode->next=pPrev;

			pPrev=pNode;

			pNode=pNext;

			i++;

		}



		lastTail->next = pPrev; //上一组的链表表尾指向当前趟的第一个元素

		lastTail = groupTail;  //修改上一组的链表表尾为当前组的链表表尾

		groupTail->next = pNode; //当前组的链表表尾元素的后缀指针指向下一组的开始元素

		count++;

		

	}

	

	

	return 0;

}



/*

打印链表

*/

void Print(Node* head){

	Node* p;

	p=head;

	while(p->next){

		p=p->next;

		printf("%d ",p->data);

	}

	printf("\n");

}



int main(){

	Node* head;

	head=initial(head);



	printf("初始化的链表：\n");

	for(int i=1;i<=20;i++){

		Insert(head,i,1);

	}

	Print(head);



	printf("反转后的链表：\n");

	Reverse(head);

	Print(head);



	printf("按间隔k=4反转后的链表：\n");

	NumReverse(head,4);

	Print(head);



	printf("删除第2-11的元素后的链表：\n");

	for(int i=1;i<=10;i++){

		Delete(head,2);

	};

	Print(head);

	return 0;

}

 

 

三、运行结果

注：代码在Ubuntu下用GCC/G++编译运行均通过