快速排序(内排序)

 1 /**
 2  *
 3  */
 4 package com.trfizeng.changesort;
 5
 6 /**
 7  * @author trfizeng 内部排序 交换排序—快速排序(Quick Sort)
 8  */
 9 public class QuickSort {
10
11     // 寻找关键字的位置
12     public static int wordKey(int[] array, int low, int high) {
13         int word = array[low];
14         while (low < high) {
15             while (low < high && array[high] >= word) {
16                 // 向前扫描比关键字大的就继续往前走
17                 high--;
18             }
19             // 反之把高位给低位
20             array[low] = array[high];
21
22             while (low < high && array[low] <= word) {
23                 // 向后扫描,比关键字小的就继续向后扫描
24                 low++;
25             }
26             // 反之,放在高位去
27             array[high] = array[low];
28         }
29         // 把关键字插入到正确的位置
30         array[low] = word;
31         return low;
32     }
33
34     public static int[] qSort(int[] array, int low, int high) {
35         if (low < high) {
36             // 寻找关键字的位置,因为下一次要根据这个关键字的位置来确定子记录的low和high
37             int wordKey = QuickSort.wordKey(array, low, high);
38             // 对低序列递归
39             QuickSort.qSort(array, low, wordKey - 1);
40             // 对高序列递归
41             QuickSort.qSort(array, wordKey + 1, high);
42         }
43         // 完成排序
44         return array;
45     }
46
47     public static int[] quickSort(int[] array) {
48         if (array != null && array.length != 0) {
49             int low = 0;
50             int high = array.length - 1;
51             QuickSort.qSort(array, low, high);
52         }
53         return array;
54     }
55 }

 1 package com.trfizeng.test;
 2
 3 import com.trfizeng.changesort.BubbleSort;
 4 import com.trfizeng.changesort.QuickSort;
 5 import com.trfizeng.insertionsort.StraightInsertionSort;
 6 import com.trfizeng.selectionsort.SimpleSelectionSort;
 7
 8 /**
 9  * 测试类
10  *
11  * @author trfizeng
12  *
13  */
14 public class SortTest {
15     // 待排序数组
16     static int[] array = new int[] { 6, 1, 4, 10, 11, 8, 7, 1, 0 };
17
18     /**
19      * 直接插入排序法测试
20      */
21     public static void straightInsertionSortTest() {
22         System.out.print("待排序数组:[ ");
23         for (int i = 0; i < array.length; i++) {
24             System.out.print(array[i] + " ");
25         }
26         System.out.print("]   ");
27
28         array = StraightInsertionSort.straightInsertionSort(array);
29         System.out.print("排好序的数组:[ ");
30         for (int i = 0; i < array.length; i++) {
31             System.out.print(array[i] + " ");
32         }
33         System.out.print("]");
34     }
35
36     /**
37      * 选择排序
38      */
39     public static void simpleSelectionSort() {
40         System.out.print("待排序数组:[ ");
41         for (int i = 0; i < array.length; i++) {
42             System.out.print(array[i] + " ");
43         }
44         System.out.print("]   ");
45
46         array = SimpleSelectionSort.simpleSelectionSort(array);
47         System.out.print("排好序的数组:[ ");
48         for (int i = 0; i < array.length; i++) {
49             System.out.print(array[i] + " ");
50         }
51         System.out.print("]");
52     }
53
54     /**
55      * 冒泡排序
56      */
57     public static void bubbleSort() {
58         System.out.print("待排序数组:[ ");
59         for (int i = 0; i < array.length; i++) {
60             System.out.print(array[i] + " ");
61         }
62         System.out.print("]   ");
63
64         array = BubbleSort.bubbleSort(array);
65         System.out.print("排好序的数组:[ ");
66         for (int i = 0; i < array.length; i++) {
67             System.out.print(array[i] + " ");
68         }
69         System.out.print("]");
70     }
71
72     /**
73      * 快速排序
74      */
75     public static void quickSort() {
76         System.out.print("待排序数组:[ ");
77         for (int i = 0; i < array.length; i++) {
78             System.out.print(array[i] + " ");
79         }
80         System.out.print("]   ");
81
82         array = QuickSort.quickSort(array);
83         System.out.print("排好序的数组:[ ");
84         for (int i = 0; i < array.length; i++) {
85             System.out.print(array[i] + " ");
86         }
87         System.out.print("]");
88     }
89
90     public static void main(String[] args) {
91         // SortTest.straightInsertionSortTest();
92
93         // SortTest.simpleSelectionSort();
94
95         // SortTest.bubbleSort();
96
97         SortTest.quickSort();
98     }
99 }

时间: 2024-12-24 21:58:23

快速排序(内排序)的相关文章

内排序-快速排序

算法思想:通过一趟排序将待排序列分割成独立的两部分,其中一部分均比另外一部分小,则可对这两部分继续继续排序,重复之前步骤,以达到整个序列有序的目的.它是由图灵获得者 Tony Hoare设计出来的,该算法被列为20世纪十大算法之一. //寻找关键值的位置,最后一次性移过去 class QuickSort_1 { static void Main(string[] args) { int[] a = new int[] { 20, 30, 90, 40, 70, 110, 60, 10, 100,

内排序—数组实现(c++)

1 参考资料:数据结构与算法分析(第三版)(c++) 2 http://blog.csdn.net/theprinceofelf/article/details/6672677 3 4 5 6 7 内排序,均采用数组实现,数组有较多的局限性,这些实现是为了去了解排序算法 8 的操作流程 9 10 #include<iostream> 11 using namespace std; 12 13 void Swap(int &a,int &b); 14 void Print(int

Lua中table内建排序与C/C++/Java/php/等内排序算法的排序效率比较

Lua这类脚本语言在处理业务逻辑作为配置文件的时候方便省事 但是在大量需要 运算的地方就显得略微不足   按照 Lua内建排序算法 对比C/C++ PHP Java等的快速排序算法进行一下比较. 快速排序算法是基于冒泡排序,优化而来,时间复杂度T(n)=O(nLog2n)  ,可见内部采用了二分策略 . 发现在LuaIDE LDT下直接运行效率要比 通过C++加载运行Lua脚本效率高的多  拿500W个数据排序 来说  ,脚本如下 同样的排序脚本Lua解释器的内置排序算法在LDT下,运行速度比通

常见排序集合(冒泡排序,选择排序,直接插入排序,二分插入排序,快速排序,希尔排序,归并排序)

一下是一些常见的排序算法: 交换元素(后面算法都有用到): // 交换元素 private static void swap(int[] a, int i, int j) { int temp; temp = a[i]; a[i] = a[j]; a[j] = temp; } 冒泡排序(有优化): // 冒泡排序(优化①,②,③,④) private static void bubbleSort(int[] a) { boolean flag = false;// ①表示整个序列是无序的 for

数据结构之快速排序

快速排序是冒泡排序的改进版,也是最好的一种内排序,在很多面试题中都会出现,也是作为程序员必须掌握的一种排序方法. 思想:1.在待排序的元素任取一个元素作为基准(通常选第一个元素,但最的选择方法是从待排序元素中随机选取一个作为基准),称为基准元素: 2.将待排序的元素进行分区,比基准元素大的元素放在它的右边,比其小的放在它的左边: 3.对左右两个分区重复以上步骤直到所有元素都是有序的. 所以我是把快速排序联想成东拆西补或西拆东补,一边拆一边补,直到所有元素达到有序状态. 下面再看看示图理解下吧:

ACM——快速排序法

快速排序 时间限制(普通/Java):1000MS/3000MS          运行内存限制:65536KByte总提交:653            测试通过:297 描述 给定输入排序元素数目n和相应的n个元素,写出程序,利用内排序算法中快速排序算法进行排序,并输出排序最后结果的相应序列. 输入 共两行,第一行给出排序元素数目n,第二行给出n个元素,1≤n≤100000,每个元素值范围为 [0,100000) 输出 一行,输出排序结果. 样例输入 748 36 68 72 12 48 2

20140528 归并排序 内排序 外排序

1.归并排序 2.内排序和外排序 外排序的一个例子是外归并排序(External merge sort),它读入一些能放在内存内的数据量,在内存中排序后输出为一个顺串(即是内部数据有序的临时文件),处理完所有的数据后再进行归并.比如,要对 900 MB 的数据进行排序,但机器上只有 100 MB 的可用内存时,外归并排序按如下方法操作: 读入 100 MB 的数据至内存中,用某种常规方式(如快速排序.堆排序.归并排序等方法)在内存中完成排序. 将排序完成的数据写入磁盘. 重复步骤 1 和 2 直

第七章 快速排序

快速排序最坏情况下时间复杂度是O(n*n),但是它平均时间复杂度是O(N*logn),并且常数因子很小,可实现就地排序,所以被作为内排序的常用排序方法. #include <iostream> using namespace std; void swap(int &i,int &j) { int temp=i; i=j; j=temp; } int partition(int *vector, int low, int high) { int pivotpos=low; int

常用排序算法实现[交换排序之冒泡排序、快速排序]

相关知识 1. 稳定排序和非稳定排序: 稳定排序算法会依照相等的关键(换言之就是值)维持纪录的相对次序. 如果排序算法是稳定的,就是当有两个有相等关键的纪录R和S,且在原本的列表中R出现在S之前,在排序过的列表中R也将会是在S之前. 2. 内排序和外排序 在排序过程中,所有需要排序的数都在内存,并在内存中调整它们的存储顺序,称为内排序: 在排序过程中,只有部分数被调入内存,并借助内存调整数在外存中的存放顺序排序方法称为外排序. 3.算法分类 排序算法从理论上分为如下几类: (1) 交换排序法: