快速排序-指针交换法

<?php

// 快速排序-指针交换法
function quickSort(&$arr, $startIndex, $endIndex)
{
    // 递归结束条件:$startIndex大于等于$endIndex的时候
    if ($startIndex >= $endIndex) {
        return;
    }
    // 得到基准元素位置
    $pivotIndex = partition($arr, $startIndex, $endIndex);
//    echo $pivotIndex . "\n";
//    print_r($arr);
//    exit;
    // 用分治法递归数列的两部分
    quickSort($arr, $startIndex, $pivotIndex - 1);
    quickSort($arr, $pivotIndex + 1, $endIndex);
}

// 分治法找出基准元素索引位置
function partition(&$arr, $startIndex, $endIndex)
{
    static $count = 0;
    $count++;
    // 取第一个位置的元素作为基准元素
    $pivot = $arr[$startIndex];
    $left = $startIndex;
    $right = $endIndex;
    // 大循环在左右指针重合时结束
    while ($left != $right) {
        //控制right指针比较并左移
        // 从right指针开始,把指针所指向的元素和基准元素做比较。如果大于等于pivot,则指针向左移动;如果小于pivot,则right指针停止移动,切换到left指针
        while
//        ($left < $right && $arr[$right] > $pivot) {
        ($left < $right && $arr[$right] >= $pivot) {
            $right--;
        }
        //控制left指针比较并右移
        // left指针所指向的元素和基准元素做比较。如果小于等于pivot,则指针向右移动;如果大于pivot,则left指针停止移动
        while
        ($left < $right && $arr[$left] <= $pivot) {
            $left++;
        }
        //交换left和right指向的元素
        // right指针和left指针都停下的时候,我们让left和right指向的元素进行交换
        if ($left < $right) {
            $temp = $arr[$left];
            $arr[$left] = $arr[$right];
            $arr[$right] = $temp;
        }
    }
    // 当left和right指针重合之时,我们让pivot元素和left与right重合点的元素进行交换
//    echo '$left:' . $left . ',$right:' . $right . ',$count:' . $count . "\n";
    $temp = $arr[$left];
    $arr[$left] = $arr[$startIndex];
//    $arr[$left] = $pivot;
    $arr[$startIndex] = $temp;
//    echo join(',', $arr) . "\n";
    return $left;
}


$arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48, 3, 50, 0, 0, -1, -3, 51, -2, -1, -8];
$arr = [1, 2, 3, 4, 5, 6, 7, 8];
$arr = [4, 7, 6, 5, 3, 2, 8, 1, 4];
/*$arr = [];
for ($i = 0; $i < 100; $i++) {
    $arr[$i] = mt_rand(0, 100);
}*/
$startTime = microtime(1);
quickSort($arr, 0, count($arr) - 1);
echo join(',', $arr);
echo "\n";
echo "use time: ", microtime(1) - $startTime, "s\n";

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
#include #include #define MAXSIZE 10 #define MAX_BIT 8 // 关键字最大位数 #define RADIX 10 // 关键字基数 ,此时是十进制整数的基数 #define MAX_SPACE 8 // 分配的存储空间的大小 typedef char KeyType;// define the keyType is the int typedef int InfoType; typedef struct { KeyType key; InfoType otherinfo;// 其他数据项 }RedType; typedef struct { RedType r[MAXSIZE+1];// r[0] is for the guard int length; }SqList; // Radix Sorting struct SLNode { KeyType key[MAX_BIT]; // the key InfoType otheritems; // 其他数据项 int next; //下一个节点的下标位置 }; // 静态链表中的节点类型 struct SList { struct SLNode r[MAX_SPACE]; // 静态链表中各节点,其中r[0]为头结点 int keybit; // 关键字的位数 int recnum; // 静态链表中记录的个数 }; // 静态链表的类型 // 函数声明 void Insert_Sort ( SqList &L);// the Straight Insertion Sort void BInsert_Sort(SqList &L);// the Binary Insertion Sort void Shell_Sort(SqList &L);// Shell Sort int Partition ( SqList &L,int low,int high ); void Quick_Sort(SqList &L,int low,int high);// Quick Sort void Bubble_Sort(SqList &L); void Select_Sort( SqList &L); void Heap_Sort(SqList &L); void Merge_Sort(SqList &L);// Merging Sort void display(SqList L);// 输出显示 void main() { SqList L; L.length=MAXSIZE; int i,msg; char ch; do { system("cls"); // 清屏 cout<<"please input the data:"<<endl; for (i=1;i>L.r[i].key; } cout<<"1、直接插入排序"<<"\t"; cout<<"2、折半插入排序"<<endl; cout<<"3、希尔排序"<<"\t"; cout<<"4、冒泡排序"<<endl; cout<<"5、快速排序"<<"\t"; cout<<"6、直接选择排序"<<endl; cout<<"7、堆排序"<<"\t"; cout<<"8、归并排序"<<endl; cout<>msg; switch (msg) { case 1: Insert_Sort(L); display(L); break; case 2: BInsert_Sort(L); display(L); break; case 3: Shell_Sort(L); display(L); break; case 4: Bubble_Sort(L); display(L); break; case 5: Quick_Sort(L,1,L.length); display(L); break; case 6: Select_Sort(L); display(L); break; case 7: Heap_Sort(L); display(L); break; case 8: Merge_Sort(L); display(L); break; default: cout<<"please input 1至 8"<>msg; } cout<>ch; } while(ch=='Y'||ch=='y'); } // 直接插入排序 void Insert_Sort(SqList &L) { int i,j; for (i=2; i<=L.length; i++) { if (L.r[i].key<L.r[i-1].key)// if '<' insert the sort order { L.r[0] = L.r[i]; // see as a guard L.r[i]=L.r[i-1]; for ( j=i-2; L.r[0].key<L.r[j].key; j--)// try to find the right position { L.r[j+1]=L.r[j];// back } L.r[j+1]=L.r[0]; } } } //折半插入排序 void BInsert_Sort(SqList &L) { int i,j,low,high; for (i=2;i<=L.length; ++i) { L.r[0] = L.r[i];// access the SqList for the time being low=1; high=i-1; while ( low<=high ) { int m=( low+high )/2; if (L.r[0].key =high+1; --j) { L.r[j+1]=L.r[j]; } L.r[high+1] = L.r[0]; // insert it } } // 希尔排序 void Shell_Sort(SqList &L)// the ascending order { int d = L.length,i; while ( d>=1 ) { d=d/2; for (i = 1+d; i<=L.length; i++) if (L.r[i].key 0&&L.r[0].key <L.r[j].key; j-=d) { L.r[j+d]=L.r[j];// 将r[j]之前所有大于它的元素都后移 } L.r[j+d]=L.r[0];// 将r[i] 插入到正确位置 } } } // quick sort 快速排序 void Quick_Sort(SqList &L,int low,int high) { int pivotloc; if (low<high) { pivotloc=Partition(L,low,high);// One order divides into two Quick_Sort(L,low,pivotloc-1); Quick_Sort(L,pivotloc+1,high); } } int Partition ( SqList &L,int low,int high ) { // 对L.r[low]——L.r[high] 子序列进行一趟快速排序,返回分界线位置,即枢轴 L.r[0]=L.r[low]; int pivotkey=L.r[0].key; while (low<high ) { while (low=pivotkey) { high--; } L.r[low]=L.r[high];// while(False) while (low<high && L.r[low].key<=pivotkey) { low++; } L.r[high]=L.r[low];// while (false ) } L.r[low] =L.r[0]; return low; } void Bubble_Sort(SqList &L)// it's coming up 冒泡排序(上浮) { int i,j; int flag=1; // to flag the record whethe needs to exchange ,1 is need. i=1; while ( i<=L.length && flag==1) { flag=0; for (j=1; jL.r[j+1].key) { L.r[0]=L.r[j+1]; L.r[j+1]=L.r[j]; L.r[j]=L.r[0]; flag=1; } } i++; } } void Select_Sort( SqList &L)// 直接选择排序 { int i,j,min; for (i=1; i<= L.length; i++) { min=i; for (j=i+1; jL.r[j].key) { min=j; } } if (min!=i) { L.r[0]=L.r[i]; L.r[i]=L.r[min]; L.r[min]=L.r[0]; } } } void Heap_Adjust(SqList &L,int s, int m)// 堆调整 { // 在L.r[s...m]中记录的关键字除L.r[s].key 之外均满足堆的定义,本函数调整L.r[s]的关键字,使L.r[s...m]成为一个大顶堆 int j; L.r[0]=L.r[s]; for ( j=2*s; j<=m; j*=2 ) { // 沿key较大的孩子节点向下筛选 if (j<m &&L.r[j].key=L.r[j].key) { break; } else// 将三者中的最大值放入到根节点的位置,并用s记录此位置 { L.r[s]=L.r[j]; s=j; } } L.r[s]=L.r[0]; } void Heap_Sort(SqList &L) // 堆排序 { int i; for (i=L.length/2; i>0; i--)// build the heap { Heap_Adjust(L,i,L.length); } for (i=L.length; i>1; i--) { L.r[0]=L.r[i];// 将 堆顶记录和当前未经排序子队列(1——i)中 的 最后一个记录 交换 L.r[i]=L.r[1]; L.r[1]=L.r[0]; Heap_Adjust(L,1,i-1);// 将(1——i-1)重新调整为一个大堆 } } void Merge( RedType S[], RedType T[], int i,int m,int n) { // 将有序的S前一部分和后一部分归并为有序的T int j,k; for (j=m+1,k=i;i<=m && j<=n; ++k)// 将S中记录由小到大并入到T中 { if (S[i].key<=S[j].key) { T[k]=S[i++]; } else T[k] = S[j++]; } while(i<=m)// 将剩余的S[i...m]复制到T中 T[k++]=S[i++]; while(j<=n)// 将剩余的S[j...n]复制到T T[k++]=S[j++]; } void MSort(RedType S[],RedType T1[],int s,int t ) { // 将S[s...t]归并为T[s...t]MAXSIZE+1 RedType T2[MAXSIZE+1]; int m; if ( s==t )// 只有一个记录 { T1[s] = S[s]; } else { m=(s+t)/2; // 将S 分为2份 MSort(S,T2,s,m);// 将S归并为有序的T2 MSort(S,T2,m+1,t); // 将S归并为有序的T2 Merge(T2, T1,s,m,t); // 将T1和T2归并到T1中 } } void Merge_Sort(SqList &L)// 归并排序 { // 对顺序表L作归并排序 MSort(L.r,L.r,1,L.length); } // for Radix Sorting // 基数排序中一趟分配的算法 void Distribute (SLNode *r,int i,int f[RADIX],int e[RADIX]) { // 静态链表中的r域中记录已按key[0]——key[i-1]有序 // 本算法按关键字的第i位建立RADIX个链队列,使在同一链队列中关键字的第i位的数值相等; // f、e均为长度为RADIX的指针数组,分别指向各链队列的第一条和最后一条记录 int j,p; for (j=0; j<RADIX; j++) { f[j]=e[j]=0;// 各链队列初始化为空 } for (p=r[0].next; p; p=r[p].next ) { // p总是指向静态链表中的当前节点 j=r[p].key[i]; if (!f[j]) { f[j]=p; } else r[e[j]].next=p; e[j]=p; // 根据r[p]的关键字的第i位的值,将其归入相应的链队列,并修改相应的f、e指针 } } // 基数排序中的一趟收集的算法 void collect ( SLNode *r,int i,int f[RADIX],int e[RADIX] ) { // 本算法按关键字的第i位自小到大地将指针f[0]——f[RADIX-1] 所指向的各 链队列依次 链接成一个静态链表 int j; for ( j=0; !f[j]; j++) { r[0].next=f[j];// r[0].next 指向第一个非空链队列中的第一个节点 } int temp=e[j]; while ( j<RADIX ) { for ( j++; j<RADIX-1 && !f[j]; j++) // 找下一个非空链队列 { if (f[j]) // 链接二个队列 { r[temp].next=f[j]; temp=e[j]; } } } r[temp].next=0; // 将最后一个节点的next域设置为空,完成一趟收集 } void Radix_Sort(SList &L)// 基数排序(链式) { // 定义静态链表L,对L进行基数排序(L.r[0] 为头结点) int i; int e[RADIX],f[RADIX]; for (i=0; i<L.recnum; i++) { L.r[i].next=i+1;// 定义各节点的next 域,使之成为一个前后相连的静态链表 } L.r[L.recnum].next=0;// 定义最后一个结点的next域,使整个静态链表有效终止 for (i=0; i<L.keybit; i++) { // 按最低位优先依次对各关键字进行分配和收集 Distribute( L.r, i, f, e);// 第i躺分配 collect(L.r, i, f, e); // 第i躺收集 } } void display(SqList L) { cout<<"after the sort:"<<endl; for (int i=1;i<=L.length; i++ ) { cout<<L.r[i].key<<"\t"; if (i%5==0 ) { cout<<"\n"; } } }

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值