编程实现合并两个有序单链表

本文介绍了一种在不使用额外内存的情况下合并两个降序链表的方法,并提供了两种实现方案:迭代和递归。通过示例代码展示了如何创建链表、合并链表以及显示合并后的链表。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

编程实现合并两个有序(假定为降序)单链表的函数,输入为两个有序链表的头结点,函数返回合并后新的链表的头节点,

要求:不能另外开辟新的内存存放合并的链表。

合并函数声明如下:node *merge_sorted_list( node * head1, node *head2);

//重要方法:

node merge_sorted_list(const node head1,const node head2)
{
	if((NULL == head1) && (NULL == head1))
	{
		return NULL;
	}
	else if(NULL == head1)
	{
		return head2;
	}
	else if(NULL == head2)
	{
		return head1;
	}
	else
	{	
		node head = NULL,p1 = NULL,p2 = NULL;


		if(head1->value >= head2->value)
		{
			head = head1;
			p1 = head1->next;
			
			p2 = head2;
		}
		else
		{		
			head = head2;
			p2 = head2->next;
			
			p1 = head1;
		}

		node p = head;

		while((NULL != p1) && (NULL != p2))
		{
			if(p1->value >= p2->value)
			{
			
				p->next = p1;


				p = p1;


				p1 = p1->next;
			}
			else
			{
				
				p->next = p2;


				p = p2;


				p2 = p2->next;
			}
		}
		
		p->next = p1 ? p1 : p2;
		//if(NULL != p1->next)
		//	p->next = p1;
		//else
		//	p->next = p2;
		return head;		
	}
}

采用递归的方法实现:

Node * MergeRecursive(Node *head1 , Node *head2)
{
	if ( head1 == NULL )
		return head2 ;

	if ( head2 == NULL)
		return head1 ;

	Node *head = NULL ;

	if ( head1->value > head2->value )
	{
		head = head1 ;
		head->next = MergeRecursive(head1->next,head2);
	}
	else
	{
		head = head2 ;
		head->next = MergeRecursive(head1,head2->next);
	}

	return head ;
}

//掌握好了 吗?

//不带头节点的链表
#include <stdio.h>


#include <malloc.h>


struct Node
{
	int value;
	struct Node *next;
};


typedef struct Node * node;


node CreateList(int iStart,int num)
{
	node head = NULL,p = NULL,q = NULL;
	
	for(int i = num;i > 0 ;i --)
	{
		p = (node)malloc(sizeof(struct Node));
		p->value = iStart + i;


		if(head == NULL)
		{
			head = p;
		}
		else
		{
			q->next = p;
		}
		q = p;		
	}


	p->next = NULL;


	return head;
}


node merge_sorted_list(node head1,node head2)
{
	if((NULL == head1) && (NULL == head2))
	{
		return NULL;
	}
	else if(NULL == head1)
	{
		return head2;
	}
	else if(NULL == head2)
	{
		return head1;
	}
	else
	{
		node p = NULL,p1 = NULL,p2 = NULL;


		if(head1->value >= head2->value)
		{
			p = head1;
			p1 = head1->next;
			
			p2 = head2;
		}
		else
		{		
			p = head2;
			p2 = head2->next;
			
			p1 = head1;
		}


		while((NULL != p1) && (NULL != p2))
		{
			if(p1->value >= p2->value)
			{
			
				p->next = p1;


				p = p1;


				p1 = p1->next;
			}
			else
			{
				
				p->next = p2;


				p = p2;


				p2 = p2->next;
			}
		}	
		p->next = p1 ? p1 : p2;


		return head1->value >= head2->value ? head1 : head2;
	}
}


void display(node head)
{
	node p = head;


	while(NULL != p)
	{
		printf("%3d",p->value);


		p = p->next;
	}
	printf("\n");
}


int main()
{
	node head1 = NULL ,head2 = NULL,head = NULL;


	head1 = CreateList(5,6);
	head2 = CreateList(5,6);


	display(head1);
	display(head2);


	head = merge_sorted_list(head1,head2);
	display(head);


	return 0;


}


### 单链表的基本操作及两个有序单链表的归并运算 #### 1. 单链表的定义 单链表是一种常见的线性数据结构,由一系列节点组成,每个节点包含两部分:存储的数据和指向下一个节点的指针。通常情况下,为了方便操作,会设置一个头节点。 --- #### 2. 单链表的基本操作实现 以下是基于 Python 的单链表基本操作实现: ```python class Node: def __init__(self, data=None): self.data = data self.next = None class SingleLinkedList: def __init__(self): self.head = Node() # 初始化头节点 # 插入元素到链表末尾 def append(self, data): new_node = Node(data) cur = self.head while cur.next is not None: cur = cur.next cur.next = new_node # 删除指定值的第一个节点 def delete(self, key): cur = self.head prev = None while cur and cur.data != key: prev = cur cur = cur.next if cur: if prev: prev.next = cur.next else: self.head = cur.next # 查找指定值是否存在 def search(self, key): cur = self.head.next while cur: if cur.data == key: return True cur = cur.next return False # 遍历链表 def traverse(self): elements = [] cur = self.head.next while cur: elements.append(cur.data) cur = cur.next return elements # 获取第 n 个元素 def get_element(self, index): cur_idx = 0 cur = self.head.next while cur: if cur_idx == index: return cur.data cur = cur.next cur_idx += 1 raise IndexError("Index out of range") # 判断链表是否为空 def is_empty(self): return self.head.next is None # 清空链表 def clear(self): self.head.next = None # 求链表长度 def length(self): count = 0 cur = self.head.next while cur: count += 1 cur = cur.next return count ``` 上述代码实现单链表的核心功能,包括插入、删除、查找、遍历、获取元素、判断是否为空、清空链表以及计算链表长度等功能[^2]。 --- #### 3. 两个有序单链表的归并运算 对于两个已排序的单链表,可以通过一次遍历来完成它们的归并操作。具体逻辑如下: ```python def merge_sorted_lists(list1, list2): dummy = Node() tail = dummy current1 = list1.head.next current2 = list2.head.next while current1 and current2: if current1.data < current2.data: tail.next = Node(current1.data) current1 = current1.next else: tail.next = Node(current2.data) current2 = current2.next tail = tail.next # 将剩余的部分接上 if current1: tail.next = current1 elif current2: tail.next = current2 merged_list = SingleLinkedList() merged_list.head.next = dummy.next return merged_list ``` 此函数通过比较两个链表中的当前最小值来逐步构建一个新的有序链表,最终返回合并后的结果[^1]。 --- #### 4. 测试代码 以下是一个完整的测试示例: ```python if __name__ == "__main__": sll1 = SingleLinkedList() sll2 = SingleLinkedList() # 向第一个链表添加元素 for i in [1, 3, 5]: sll1.append(i) # 向第二个链表添加元素 for j in [2, 4, 6]: sll2.append(j) print("List 1:", sll1.traverse()) # 输出 List 1: [1, 3, 5] print("List 2:", sll2.traverse()) # 输出 List 2: [2, 4, 6] # 归并两个有序链表 merged_sll = merge_sorted_lists(sll1, sll2) print("Merged List:", merged_sll.traverse()) # 输出 Merged List: [1, 2, 3, 4, 5, 6] ``` --- #### 5. 总结 以上代码展示了如何使用 Python 实现单链表的基本操作及其扩展功能——两个有序单链表的归并运算。这些方法可以作为学习数据结构的良好起点,并为进一步研究复杂算法奠定基础[^3]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值