快速排序(C实现)

  1 //
  2 //  main.c
  3 //  QSort
  4 //
  5 //  Created by 何进明 on 16/3/22.
  6 //  Copyright © 2016年 bbcai. All rights reserved.
  7 //
  8
  9 #include<stdio.h>
 10 #include<stdlib.h>
 11 typedef struct Node{
 12     int x;
 13     struct Node *next;
 14 }Node,*List;
 15 void CreateList(int num,List *list){
 16     int i = 0;
 17     List headNode = *list;
 18     List p,r;
 19     r = headNode; // r指向链表的结尾
 20     for(i = 0;i<num;i++)
 21     {
 22         p = (Node *)malloc(sizeof(Node));
 23         scanf("%d",&(p->x));
 24 //        printf("you has been input the %d number:%d\n",i + 1,p->x);
 25         r->next = p;
 26         r = p; //r总是指向当前尾结点
 27     }
 28     r->next = NULL;
 29     *list = (*list)->next;
 30 //    headNode = headNode->next;  /*headNode同样是一个指向头节点指针的局部指针,不能操纵头节点的指针,但是可以操纵头节点指针指向的结构体*/
 31 }
 32
 33 int NumberInList(List list,int n){
 34     int i = 1;
 35     if(n == 1)
 36     {
 37         return list->x;
 38     }
 39     while(i < n && list !=NULL){
 40         list = list->next;
 41         i ++;
 42     }
 43     return list->x;
 44
 45 }
 46 void Swap(List *list,int a,int b)
 47 {
 48     printf("开始交换数据\n");
 49     List L = *list;
 50     int tmp1 = 0;
 51     int tmp2 = 0;
 52     int i = 1;
 53     tmp2 = NumberInList(L,b);
 54     while( i < a){  //定位a的结点
 55         i++;
 56         L = L->next;
 57     }
 58     tmp1 = L->x;
 59     L->x = tmp2;
 60     while( i < b)
 61     {
 62         i++;
 63         L = L->next;
 64     }
 65     L->x = tmp1;
 66 }
 67 int Partition(List *list,int low, int high)
 68 {
 69     printf("开始分区\n");
 70     List L = *list;
 71     int mark = low; //假设以第一个为标记
 72     // int mark = L->x; /*这个不行*/
 73     int Markx = NumberInList(L,mark);
 74     while(low < high) /*从表的两端交替向中间扫描*/
 75     {
 76         while(low < high && NumberInList(L,high) >= Markx) /*缺等号会一直不停交换数据,下面一样*/
 77             high --;
 78         Swap(list,low,high);
 79         while(low < high && NumberInList(L,low) <= Markx)
 80             low++;
 81         Swap(list,low,high);
 82     }
 83     return low;
 84 }
 85 void QSort(List *list,int low,int high)
 86 {
 87     printf("开始快排\n");
 88     int mark ;
 89     if(low < high)
 90     {
 91         mark = Partition(list,low,high);
 92         QSort(list,low,mark-1);
 93         QSort(list,mark+1,high);
 94     }
 95 }
 96 int main(int argc, const char * argv[])
 97 {
 98     int num;
 99     List list;
100     list =(Node *)malloc(sizeof(Node));
101     num = 0;
102     scanf("%d",&num);
103     printf("you has been input the total number\n");
104     CreateList(num,&list);
105     QSort(&list,1,num);
106     while (list!=NULL) {
107         printf("%d ",list->x);
108         list = list -> next;
109     }
110     printf("\n that‘s all,thx ");
111     return 0;
112 }

时间: 2024-09-28 23:02:49

快速排序(C实现)的相关文章

快速排序

快速排序的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列. 快速排序是一种不稳定的排序算法,也就是说,多个相同的值的相对位置也许会在算法结束时产生变动 快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序.它采用了一种分治的策略,通常称其为分治法(Divide-and-ConquerMethod). 该方法的基本思想是:

快速排序——Python

快速排序: 在一组数据中选择一个基准值,让后将数据分为两个部分,一部分大于基准,一部分小于基准,然后按此方法将两个部分分组,直到不能再分为止. 需要明白一个概念递归和分而治之的概念. Python实现: 1 # 快速排序 2 3 import random 4 5 def quick_sort(arr): 6 # 边界条件 7 if len(arr) < 2: 8 return arr 9 key = random.choice(arr) # 选择基准 10 left = [i for i in

快速排序的实现(不保证效率

众所周知,快速排序的核心是分治的思想,选一个基准出来,然后通过划分操作,使得,该元素最终处于的位置的左边的元素都小于等于它,右边的元素都大于等于它 划分操作就是两次递归嘛,没什么的,关键在于不借助外部空间我们如何实现划分操作 首先我们不知道该元素放在哪里,显然这是最后才能确定的, 我了解到一种填坑法的实现... 那就是首先保存第一个位置的值,然后从后向前扫描第一个小于x的值,我们就可以直接覆盖第一个位置的值,然后我们再从前向后找大于x的值, 把后面的坑填上 下面枚举几种情况 基准前后有相同数量的

快速排序的总结

快速排序的思想是分而治之,利用递归达到快速排序的效果 首先要选定一个基准数,一般选择最左边的数为基准数,排序的目标就是让这个基准数的左边全小于这个基准数,右边全大于这个基准数.然后以这个基准数为分隔线,在左右两侧再次调用这个排序的函数,直到全部有序.简述过程: 以  8 9 4 7 2 6 首选 1. 选择两个哨兵 i,j 分别指向8,6,基准数为8 2.从j哨兵开始,因为j指向的6小于基准数8,不符合j指向的数都要大于8的要求,所以将j指向的数覆盖i指向的数,同时i指向的数变成9 6 9 4

[数据结构] 快速排序

基本思想 快速排序(Quicksort)是对冒泡排序的一种改进,又称划分交换排序(partition-exchange sort. 快速排序使用分治法(Divide and conquer)策略来把一个序列(list)分为两个子序列(sub-lists). 步骤为: ①.从数列中挑出一个元素,称为"基准"(pivot) ②.重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边).在这个分区结束之后,该基准就处于数列的中间位置.这个称

使用JAVA直观感受快速排序与冒泡排序的性能差异

初学算法,肯定会编写排序算法 其中两个最为有名的就是冒泡排序和快速排序 理论上冒泡排序的时间复杂度为O(N^2),快速排序的时间复杂度为O(NlogN) 下面本门使用JAVA,分别编写三段排序程序 对十万个0-9999的整数进行一次冒泡排序 对十万个0-9999的整数进行1000次快速排序,使用递归完成 对十万个0-9999的整数进行1000次快速排序,使用堆栈完成 对十万个0-9999的整数进行一次冒泡排序: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

Swift实现的快速排序及sorted方法的对比

Swift语言有着优秀的函数式编程能力,面试的时候面试官都喜欢问我们快速排序,那么用Swift如何实现一个快速排序呢?首先扩展Array类: extension Array { var decompose : (head: T, tail: [T])? { return (count > 0) ? (self[0], Array(self[1..<count])) : nil } } 属性decompose的作用是返回数组中的第一个元素和剩下的元素,注意这个属性是可选型的,当count为0的时

Java实现排序算法之快速排序

一.综述 快速排序是交换排序中的一种,平均算法复杂度是O(nlogn),最坏O(n*n).下面用Java实现一个快速排序,并用注释的方式解释了思想和原理. 二.Java实现堆排序 三.结果检验 版权声明:本文为博主原创文章,未经博主允许不得转载.

单链表排序——快速排序实现

利用快速排序,同向一前一后两个指针 #ifndef LIST_H_ #define LIST_H_ #include <iostream> #include <utility> class List { private: struct ListNode { int _value; ListNode* _next; }; public: List(): _head(nullptr) {} ~List() { while (nullptr != _head) { auto tmp =

排序之快速排序

package com.xsz.demo; /**     * @author cwqi    * @date 2015-1-6    */ //排序之快速排序,基本思路為分治+挖坑,方法有兩種:一是雙邊掃面:二是單邊掃描. public class QuickSort { public static void main (String[] args){ int a[] ={2,3,30,1,4,56,2,7,3,8}; //int a[] ={4,5,6,2,7,3,8}; //int a[]