【C语言】快速排序优质算法的动态显示和字符串的快排

快速排序的动态显示比较简单,不多说,直接上代码:

//快速排序动态显示
#include<stdio.h>
#include <stdlib.h>
#include <Windows.h>
void swap(int arry[],int num1, int num2)
{
             int temp = arry[num1];
            arry[num1] = arry[num2];
            arry[num2] = temp;
}

void show_arry(int arry[],int len)
{
             int i =0;
             for(i = 0;i < len;i++)
            {
                        printf( "%d ",arry[i]);
            }
            printf( "\n");
}

void my_sqort(int arry[],int left, int right,int len)
{
             int last;
             int i = 0;
             if(left >= right)
            {
                         return;
            }
            swap(arry,left,(left+right)/2);
            last = left;
             for(i = left+1;i <= right;i++)
            {
                         if(arry[i] < arry[left])
                        {
                                    swap(arry,i,++last);
                        }
            }
            show_arry(arry,len);
             //for(i = 0;i<1000000000;i++)
             //{
             //          ;
             //}
            Sleep(2000);
            system( "cls");
            swap(arry,left,last);
            my_sqort(arry,left,last-1,len);
            my_sqort(arry,last+1,right,len);

}

int main()
{
             int arry[] = {11,5,23,45,77,9,556,23,11};
            my_sqort(arry,0,( sizeof(arry)/sizeof (arry[0]))-1,sizeof(arry)/ sizeof(arry[0]));
            show_arry(arry, sizeof(arry)/sizeof (arry[0]));
             return 0;
}

下面是字符串的快速排序:

1.注意在函数中比较字符串的操作需要运用二级指针进行操作,否则无法对指针的地址进行变换。

2.原理跟快速排序一个意思。

比较简单,只要注意函数字符串的操作有效性就OK:

代码:

#include <stdio.h>
#include <string.h>
#include <Windows.h>
#include <stdlib.h>
int compare(char **arry,int left, int right)
{
             return strcmp(*(char **)(arry+left),*(char **)(arry+right));
}

void swap(char **arry,int left, int right)
{
             char *temp = *(arry+left);
            *(arry+left) = *(arry+right);
            *(arry+right) = temp;
}

void my_csqort(char **arry,int left, int right)
{
             int last = 0;
             int i = 0;
             if(left >=right)
            {
                         return;
            }
            swap(arry,left,(left+right)/2);
            last = left;
             for(i = left+1;i <= right;i++)
            {
                         if(compare(arry,left,i) > 0)
                        {
                                    swap(arry,i,++last);
                        }
            }
            swap(arry,last,left);
             for(i = 0;i<5;i++)
            {
                        printf( "%s\n",arry[i]);
            }
            Sleep(2000);
            system( "cls");
            my_csqort(arry,left,last-1);
            my_csqort(arry,last+1,right);
}
int main()
{
             int i = 0;
             char *arry[] = {"bbbbb" ,"aaaaa", "ccccc","xxxxx" ,"ddddd"};
            my_csqort(arry,0, sizeof(arry)/sizeof (arry[0])-1);
             for(i = 0;i<5;i++)
            {
                        printf( "%s\n",arry[i]);
            }
            printf( "%d",strcmp("xxxxx" ,"qqqqq"));
             return 0;
}
时间: 2024-08-07 22:04:06

【C语言】快速排序优质算法的动态显示和字符串的快排的相关文章

代码与算法集锦-归并排序+树状数组+快排+深度优先搜索+01背包(动态规划)

归并排序 求逆序数 归并排序是建立在归并操作上的一种有效的排序算法.该算法是采用分治法(Divide and Conquer)的一个非常典型的应用. 首先考虑下如何将将二个有序数列合并.这个非常简单,只要从比较二个数列的第一个数,谁小就先取谁,取了后就在对应数列中删除这个数.然后再进行比较,如果有数列为空,那直接将另一个数列的数据依次取出即可. //将有序数组a[]和b[]合并到c[]中 void MemeryArray(int a[], int n, int b[], int m, int c

排序算法之冒泡、插入、快排和选择排序

排序算法大全 package cn.baidu; import java.util.Arrays; public class SortTest { public static void main(String[] args) { int[] arr = { 2, 5, 3, 1, 4 }; System.out.println("排序前:" + Arrays.toString(arr)); // InsertSort.sort(arr); // BubbleSort.sort(arr)

C/C++实现各类排序算法(目前实现冒泡、快排)

快速排序: void quick_sort(int a[],int low,int high) { int i=low,j=high,tmp=a[low]; //tmp存储基准元素,相当于空出一个用于调动的动态位置 if(low<high) { while(i!=j) { while(j>i&&a[j]>=tmp) j--; a[i]=a[j]; //此时a[j]空出 while(j>i&&a[i]<=tmp) i++; a[j]=a[i];

Java 常用的排序算法【选择、冒泡、快排】

选择排序: 简述:从数组的第一个元素开始,依次与其他所有的元素对比,如果比自身大或小(取决于升序或降序)交换位置. ChiceSort Code 冒泡排序: 简述:比较数组中两个相邻的元素,如果前者比较大则交换位置.像啤酒杯中的气泡一样,先漂上来最大的气泡,再漂上来第二大的气泡......... BubbleSort Code 快速排序: 简述:寻找一个基准(数组中的第一个或最后一个),表的两端同时向中间扫描,小在左,大在右.然后分别从基准两边进行递归排序. QuickSortCode 原文地址

C语言实现单向链表及其各种排序(含快排,选择,插入,冒泡)

#include<stdio.h> #include<malloc.h> #define LEN sizeof(struct Student) struct Student //结构体声明 { long num; int score; struct Student* next; }; int n; struct Student* creat() //创建单向链表 { struct Student *head=NULL, *p_before, *p_later; p_before =

C语言快速排序算法代码分析

最近在很多场合都看见设计模式的影子,一直以来,都投入主要时间在搞算法与数据结构,很来发现设计模式真的很重要.有的时候代码的可维护.可重用.可扩展确实胜过单纯的算法效率高.所以拾起大牛书籍<大话设计模式>同时参考网上诸大牛的博客,开始我的设计模式之旅.由于平时编程时用C/C++,现在是Java,也练练Java语法. 今天先介绍一下命令模式. 概念: 命令模式(Command):将一个请求封装成一个对象,从而使你可用不同的请求对象对客户进行参数化,对请求排队或记录请求日志,以及支持可撤销的操作.

快速排序的算法

自学java到数组时,学习到了两种排序方法:选择排序和冒泡排序,冒泡排序是选择排序的进阶阶段,精简了运算的过程.了解到,java语言已经提供了排序的方法:通过util.Arrays.sort可以对数组进行自动排序,而排序方法用的是快速排序的一种. 快速排序是冒泡排序的进阶阶段,那么快速排序的基本原理又是什么呢.通过查阅资料,了解了算法,自己也尝试了写了一些快速排序的算法原理. 1 package array; 2 //快速排序原理 3 import java.util.Arrays; 4 pub

快速排序的算法导论划分形式和hoare划分

1. hoare划分 1 int hoare_partition(int a[], int begin, int end) 2 { 3 int pivot = a[begin]; 4 int ini = begin; 5 int ter = end; 6 while (ini < ter) 7 { 8 while (a[ini] <= pivot && ini <end) 9 ++ini; 10 while (a[ter] >= pivot && t

快速排序之算法导论实现

#include <iostream> using namespace std; int partition(int *a,int p,int r) { int x=a[r]; int i=p-1;//note i important which is used for //storage the number smaller than flag x=a[r] for (int j=p;j<r;j++) { if (a[j]<x)// if a[j] smaller than x=