1. 程式人生 > >快速排序非遞迴實現--python

快速排序非遞迴實現--python

主要思想是:每次把待排序陣列分為兩部分,左邊小於軸右邊大於軸,把分開的陣列的收尾陣列的索引存到輔助棧空間裡,替換遞迴。兩種思路:

思路一:嚴老師資料結構裡面的思路

def partition(nums,low,high):
        high_flag = True
        low_flag = False
        pivot = nums[low]
        while low < high and low < len(nums) and high < len(nums):
            if high_flag:
                if nums[high] < pivot:
                    nums[low] = nums[high]
                    high_flag = False
                    low_flag = True
                else:
                    high -= 1
            if low_flag:
                if nums[low] > pivot:
                    nums[high] = nums[low]
                    high_flag = True
                    low_flag = False
                else:
                    low += 1
        nums[low] = pivot
        print(low)
        return low
def quickSort(nums):
    arr = []
    low = 0
    high = len(nums) -1
    if low < high:
        mid = partition(nums,low,high)
        if low < mid - 1:
            arr.append(low)
            arr.append(mid-1)
        if mid+1 < high:
            arr.append(mid+1)
            arr.append(high)
        while arr:
            r = arr.pop()
            l = arr.pop()
            mid = partition(nums,l,r)
            if l < mid -1:
                arr.append(l)
                arr.append(mid-1)
            if mid + 1 < r:
                arr.append(mid + 1)
                arr.append(r)
    print(nums)

思路二:演算法導論裡面的

def quick_sort_other(array, l, r):
    '''
    演算法導論裡的思想
    i表示[l,i]都比pivot小
    j依次遍歷元素

    '''
    if l >= r:
        return
    stack = [l,r]
    while stack:
        low = stack.pop(0)
        high = stack.pop(0)
        if high <= low:
            continue
        pivot = array[high]
        i = low - 1 ###初始值是-1
        for j in range(low,high+1):
            ###如果小於pivot, 則交換,交換的目的是保證[l,i]都比pivot小
            if array[j] <= pivot:
                i += 1
                t = array[i]
                array[i] = array[j]
                array[j] = t
        stack.extend([low, i-1, i + 1, high])
    return arrays

相關推薦

快速排序實現--python

主要思想是:每次把待排序陣列分為兩部分,左邊小於軸右邊大於軸,把分開的陣列的收尾陣列的索引存到輔助棧空間裡,替換遞迴。兩種思路: 思路一:嚴老師資料結構裡面的思路 def partition(num

[演算法入門]快速排序方法(Java實現),大家一起來找茬啊~

基礎 總結一下,快速排序的步驟: 1、找到一個key值(就是陣列第一個值),先從右到左找,找到一個比它小的值,記錄下標。 2、然後從左往右找,找到一個比它大的值,記錄下標。 3、交換找到的兩個數

快速排序實現

/*把陣列arr按照一個支點分成左右兩個部分 左邊比支點小,右邊比支點大,再返回支點pivot*/ int partition(int *arr,int low, int high){ int pivot = arr[low]; //low為陣列的第一個元素的位置,high為陣列

歸併排序實現Java

遞迴實現的歸併排序,需要O(lgN)的棧空間,而非遞迴實現的歸併排序則不需要 原文地址:http://www.jianshu.com/p/39dd1d9b491d public class Sort { public static void MergeSort

斐波那契數列的實現 —— python

# -*- coding:utf-8 -*- #遞迴實現 def Fibonacci(n): if n <= 1: return n return (Fibonac

快速排序實現演算法。

輸入:先輸入進行排序元素的個數,然後依次隨機輸入(或隨機生成)每個數字。 輸出:元素排序後的結果。 示例:輸入:8 9 1 2 4 8 6 15 8,輸出:1 2 4 6 8

Fibonacci(斐波那契)數列的實現 python

Fibonacci數列為:0、1、1、2、3、5、8、13、21...... 數列第一項為0,第二項為1,從第三項開始,每一項為相鄰前兩項之和。 用遞迴的方法來定義: F(0) = 0 F(1) = 1F(n) = F(n-1) + F(n-2) , n>=2用

快速排序和歸併排序實現

1.快速排序 # 快速排序 def partition(li, left, right): i = left j = right r = random.randint(i, j) li[i], li[r] = li[r], li[i] tmp = li[i]

快速排序實現-----c語言

  前面我們講解了快速排序的遞迴實現,但若是待排序的數量非常大且雜亂無章,每層迴圈都使用遞迴呼叫,會很容易造成棧溢位,所以我們可以將快速排序設計為非遞迴實現。 遞迴實現快速排序演算法詳解   快速排序是從序列中選擇一個基準值,按照某種方式將該區間分成兩部分,基準

排序演算法之快速排序實現

在之前的部落格中提到過快速排序的三種實現方式,不過都是通過遞迴來實現,今天我們將會利用棧來實現快速排序。 -----------------------------------Stack.h----------------------------------------

【轉載】快速排序(三種演算法實現實現)

原文地址 python實現: import random a = [4,1,7,6,9,2,2,3,5,7,8,9,3,1,2,3,4,5,8,0,3,5] b = [4,1,7,6,9,2,8,0,3,5] def twoPointerSort(nums,le

快速排序(三種演算法實現實現)

快速排序(Quick Sort)是對氣泡排序的一種改進,基本思想是選取一個記錄作為樞軸,經過一趟排序,將整段序列分為兩個部分,其中一部分的值都小於樞軸,另一部分都大於樞軸。然後繼續對這兩部分繼續進行排序,從而使整個序列達到有序。 遞迴實現: void Q

排序快速排序及其實現,歸併排序詳解

快速排序   快速排序(Quicksort)是對氣泡排序的一種改進。   我們知道快速排序用的是分治的基本思想:將原問題分解為若干個規模更小但結構與原問題相似的子問題。遞迴的解決這些子問題,然後將這些子問題的解組合為原問題的解。   快速排序的基本思想是:

Java 實現快速排序

快速排序演算法 工作之前一直不懂快速排序演算法,今天看了下快速排序演算法,跟大家分享下,如果有不妥之處還請建議。 快速排序是對氣泡排序的一種改進,由C.R.A.Hoare於1962年提出,它採用了一種分治的策略,通常稱其為分治法(Divide-and-

快速排序的兩種實現思路和實現--C++實現

思路一:        第一種是根據演算法導論上的思想:取陣列的最後一個元素為主元,i初始化為最低位元素的前一個位置,j指向遍歷陣列中待排序的元素,當j所指元素比主元小的時候i= i + 1,然後交換i和j所指的元素,j不斷遍歷,遇到小於主元的就進行交換,這樣

【Java】 歸併排序實現 資料結構與演算法合集 資料結構與演算法合集

  歸併排序可以採用遞迴方法(見:歸併排序),但遞迴方法會消耗深度位O(longn)的棧空間,使用歸併排序時,應該儘量使用非遞迴方法。本文實現了java版的非遞迴歸併排序。 更多:資料結構與演算法合集 思路分析   遞迴排序的核心是merge(int[] arr, int start, int mid,

【資料結構】八大排序快速排序方法)

上一博文我們講了氣泡排序,但是由於他的時間複雜度過高為O(n*n),於是在氣泡排序的基礎上今天要說的是快速排序。 本文講述兩個內容: 1.快速排序的三種方法。 2.快速排序的優化 一.什麼是快速排序???      通過一趟排序將要排序的資料分割成獨立的兩部

C語言實現快速排序

#include<stdio.h> void Split(int left,int a[],int right); int Quicksort(int left,int a[],int right); int main() { int N; scanf("

排序演算法6——圖解歸併排序及其實現

排序演算法1——圖解氣泡排序及其實現(三種方法,基於模板及函式指標) 排序演算法2——圖解簡單選擇排序及其實現 排序演算法3——圖解直接插入排序以及折半(二分)插入排序及其實現 排序演算法4——圖解希爾排序及其實現 排序演算法5——圖解堆排序及其實現 排序演算法6——圖解歸併排序及其遞迴與非

合併排序實現(自底向上設計)

上一篇博文,討論了合併排序的遞迴實現。這篇文章,說說合並排序的非遞迴實現。 思路描述 假設一個數組,共有11個(0到10)元素。 首先,進行“1+1”合併:即第0個和第1個合併,第2個和第3個合併,……,第8個和第9個合併,第10個不用合併; 然後,進行