快排的C语言实现

数据结构篇:快排的C语言实现与个人解析

快排是很经典的算法,时间复杂度为O(n*log2n),空间复杂度最好O(log2n),最坏O(n),快排是一种不稳定排序。

#include<stdio.h>
#include<stdlib.h>
#define Maxsize 7
typedef struct {
	int r[Maxsize];
	int length;
}SqList;
int partition(SqList &l,int low,int high){  //进行一趟排序算法,返回枢纽位置 ;自己写的时候可以理解用一个尺子(枢纽),将序列分成两组 
	int keep=l.r[low];            //保存下枢纽的值,这一步要小心,否则可能丢掉枢纽的值  
	int pivotkey=l.r[low];       //子表第一个记录作为枢纽
	while(low<high){
		while(low<high&&l.r[high]>=pivotkey) high--;
		l.r[low]=l.r[high];
		while(low<high&&l.r[low]<=pivotkey) low++;
		l.r[high]=l.r[low];
	} 
	l.r[low]=keep;
	return low;                                  //返回枢纽位置    
} 
void QSort(SqList &l,int low,int high){
	if(low<high){
		int pivot=partition(l,low,high);
		QSort(l,low,pivot-1);                 //对枢纽左边的表进行递归 
		QSort(l,pivot+1,high);                //对枢纽右边的表进行递归  
	}
} 
int main(){
	SqList l;
	l.length=6;
	int i;
	l.r[0]=15;l.r[1]=8;l.r[2]=16;            //一组测试用例 
	l.r[3]=86;l.r[4]=66;l.r[5]=20;
	printf("........快排前......\n");
	for (i=0;i<6; i++){
		printf("%d ",l.r[i]);
	}		
	printf("\n........快排后....。.\n");
	QSort(l,0,5);
	for (i=0; i<6;i++){
		printf("%d ",l.r[i]);
	}
	return 0;
} 

个人解析

快排还是基于的分治思想,当问题规模比较复杂时,但能将问题分解成相同情况的子问题并不断分下去就可以用分治的思想。递归可以很好实现,在逻辑上比较清晰简单。

今天听《一生所爱》听的不想敲了,咕咕咕,明天继续。

### 链表快速排序实现 链表是一种常见的动态数据结构,在实际开发中具有广泛的应用。对于链表的快速排序,其实现逻辑与数组的快速排序相似,但由于链表的特点(不支持随机访问),需要调整部分细节。 以下是基于C语言实现链表快速排序的核心思路和代码示例: #### 核心思路 1. **选取基准节点**:通常选择头节点作为基准节点。 2. **分区操作**:将小于基准值的节点放入左子链表,大于等于基准值的节点放入右子链表。 3. **递归调用**:分别对左子链表和右子链表进行快速排序。 4. **合并结果**:将左子链表、基准节点和右子链表连接起来形成最终有序链表[^2]。 #### 代码实现 以下是一个完整的C语言代码示例,用于对单向链表执行快速排序: ```c #include <stdio.h> #include <stdlib.h> // 定义链表节点结构 typedef struct Node { int data; struct Node* next; } Node; // 创建新节点 Node* createNode(int value) { Node* newNode = (Node*)malloc(sizeof(Node)); newNode->data = value; newNode->next = NULL; return newNode; } // 插入节点到链表尾部 void append(Node** headRef, int newData) { Node* newNode = createNode(newData); if (*headRef == NULL) { *headRef = newNode; return; } Node* temp = *headRef; while (temp->next != NULL) { temp = temp->next; } temp->next = newNode; } // 打印链表 void printList(Node* node) { while (node != NULL) { printf("%d ", node->data); node = node->next; } printf("\n"); } // 获取链表长度 int getLength(Node* head) { int count = 0; while (head != NULL) { count++; head = head->next; } return count; } // 切分函数 Node* partition(Node* low, Node* high) { int pivot = high->data; // 基准值设为最后一个节点的数据 Node* i = low->next; Node* j = low->next; while (j != high) { if (j->data <= pivot) { // 小于等于pivot的放在左边 int temp = i->data; i->data = j->data; j->data = temp; i = i->next; } j = j->next; } // 最后交换i前一个位置和high的位置 int temp = i->data; i->data = high->data; high->data = temp; return i; } // 快速排序递归函数 void quickSortRec(Node* low, Node* high) { if (!low || !high || low == high || low == high->next) { return; } Node* pi = partition(low, high); // 调用切分函数 quickSortRec(low, pi->prev); // 对左侧子链表排序 quickSortRec(pi->next, high); // 对右侧子链表排序 } // 主快速排序入口 void quickSort(Node** headRef) { if (*headRef == NULL || (*headRef)->next == NULL) { return; } Node* current = *headRef; while (current->next != NULL) { current = current->next; } quickSortRec(*headRef, current); } // 测试程序 int main() { Node* head = NULL; append(&head, 5); append(&head, 3); append(&head, 8); append(&head, 6); append(&head, 7); printf("Original List:\n"); printList(head); quickSort(&head); printf("Sorted List:\n"); printList(head); return 0; } ``` 上述代码实现了单向链表的快速排序功能。它通过`partition`函数完成分割操作,并利用递归来处理左右两个子链表。 --- #### 注意事项 - 上述代码假设输入的是单向链表。如果使用双向链表,则需额外考虑前后指针的操作[^4]。 - 如果链表为空或仅含单一节点,则无需进一步排序。 - 时间复杂度为O(n log n),空间复杂度为O(log n)。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值