排序—快速排序

快速排序由C.A.R.Hoare(1962) 开发的,该算法在数组中选择一个称为主元(pivot)的元素,将数组分为两部分,是的第一部分中的所有元素都小于或等于主元,而第二部分的所有元素都大于主元。对第一部分递归地应用快速排序算法,然后对第二部分递归地应用快速排序算法。

package ss.sort;
/**
 * 快速排序
 * @author zhangss 2016-5-3 11:42:32
 * */
public class QuickSort {

	public static void quickSort(int[] list){
		quickSort(list, 0, list.length - 1);
	}

	private static void quickSort(int[] list, int first, int last){
		if(last > first){
			int pivotIndex = partition(list, first, last);
			quickSort(list, first, pivotIndex - 1);
			quickSort(list, pivotIndex + 1, last);
		}
	}

	private static int partition(int[] list, int first, int last){
		int pivot = list[first];  // Choose the first element as the pivot
		int low = first + 1;      // Index for forward search
		int high = last;          // Index for backward search

		while(high > low){
			// Search forward from left
			while(low <= high && list[low] <= pivot)
				low++;

			// Search forward from right
			while(low <= high && list[high] > pivot)
				high--;

			// Swap two elements in the list
			if(high > low){
				int temp = list[high];
				list[high] = list[low];
				list[low] = temp;
			}
		}

		while(high > first && list[high] >= pivot)
			high--;

		// Swap pivot with list[high]
		if(pivot > list[high]){
			list[first] = list[high];
			list[high] = pivot;
			return high;
		}else{
			return first;
		}
	}
	/**
	 * A test method
	 */
	public static void main(String[] args) {
		int[] list = {2, 3, 2, 5, 6, 1, -2, 3, 14, 12};
		quickSort(list);
		for(int i = 0; i < list.length; i++)
			System.out.print(list[i] + " ");
	}

}

  

时间: 2024-11-14 16:54:46

排序—快速排序的相关文章

基础算法之排序--快速排序

1 /************************************************************************************** 2 * Function : 快速排序 3 * Create Date : 2014/04/21 4 * Author : NTSK13 5 * Email : [email protected] 6 * Copyright : 欢迎大家和我一起交流学习,转载请保持源文件的完整性. 7 * 任何单位和个人不经本人允许不

排序 快速排序

*/--> pre.src {background-color: Black; color: White;} pre.src {background-color: Black; color: White;} pre.src {background-color: Black; color: White;} pre.src {background-color: Black; color: White;} pre.src {background-color: Black; color: White;}

单链表的排序 快速排序 归并排序 quicksort mergesort

原理都很简单,关键是某些边界能否正确写对: #include<iostream> #include<stdio.h> using namespace std; class Node { public: int val; Node* next; Node(int val = 0):val(val),next(NULL){ } }; Node* quicksort(Node* head, Node* tail) { Node *res1 = NULL, *res2 = NULL; No

排序——快速排序法

快速排序法基本思想: 快速排序(Quicksort)是对冒泡排序的一种改进.由C. A. R. Hoare在1962年提出.它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列. 程序代码: #include <stdio.h> void print(int a[], int n) { int j; for(j=0; j < n

C# 插入排序 冒泡排序 选择排序 快速排序 堆排序 归并排序 基数排序 希尔排序

下面列出了数据结构与算法的八种基本排序:插入排序 冒泡排序 选择排序 快速排序 堆排序 归并排序 基数排序 希尔排序,然后是测试的例子.代码位置:http://download.csdn.net/detail/luozuolincool/8040027 排序类: public class Sortings { //插入排序 public void insertSort(int[] array) { int temp = 0; int index = 0; for (int i = 0; i <

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

利用快速排序,同向一前一后两个指针 #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 =

数据结构学习笔记06排序 (快速排序、表排序)

1.快速排序 不稳定 分而治之 找主元pivot,小于主元划分为一个子集,大于主元的划分为一个子集 然后进行递归 最好情况:每次主元正好中分,T(N) = O( NlogN ) 选主元 的方法有很多,这里用 取头.中.尾的中位数. 直接选A[0]为pivot,时间复杂度T ( N ) = O( N ) + T ( N–1 ) = O( N ) + O ( N–1 ) + T( N–2 ) = = O( N ) + O ( N–1 ) + …+ O( 1 ) = O( N^2 ) 随机取pivot

排序--快速排序学习

快速排序由于排序效率在同为O(N*logN)的几种排序方法中效率较高,因此经常被采用,再加上快速排序思想----分治法也确实实用,因此很多软件公司的笔试面试,包括像腾讯,微软等知名IT公司都喜欢考这个,还有大大小的程序方面的考试如软考,考研中也常常出现快速排序的身影. 总的说来,要直接默写出快速排序还是有一定难度的,因为本人就自己的理解对快速排序作了下白话解释,希望对大家理解有帮助,达到快速排序,快速搞定. 快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序.它采用了一种分治的策

经典排序——快速排序

快速排序:快速排序是经典的排序算法之一,它是冒泡排序的升级版. 快速排序由C. A. R. Hoare在1962年提出.它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列. ——百度百科(快速排序算法) 首先观察每一趟排序的效果: 原始序列:[84, 17, 26, 30, 62, 83, 5, 79, 45, 85] [45, 17

C语言排序---快速排序

/* 快速排序由C. A. R.Hoare在1962年提出,是对冒泡排序的一种改进. * 它的基本思想是: * 通过一趟排序将要排序的数据分割成独立的两部分 * ,其中一部分的所有数据都比另外一部分的所有数据都要小 * ,然后再按此方法对这两部分数据分别进*/ #include<stdio.h>#define N 30int QSort(int a[N],int l,int r){ int m,i,j,p; if(l>=r)return 0; /*递归出口,当序列长度小于等于0时,视为排