二分查詢，ruby快排，歸併，ruby實現

都是採用遞迴方法，針對有序陣列。

以下**，前者針對含有重複的有序陣列，如【1,1,1,1,2,2,3,3,3,4,5,5,5,6】。查詢最後乙個值等於要查詢的值。後者是普通的二分查詢

# 二分查詢 # 查詢最後乙個值等於給定值的元素 返回結果是陣列的下標，不能直接返回值，因為重複值無法體現是否真正返回最後乙個。

def half_find(array,value)
if array.size <= 1
return nil if array[0] && array[0] == value
return nil
endn = array.size / 2
if value == array[n]
res = half_find(array[n,array.size],value)
return res if res
return n
endif value < array[n]
half_find(array[0,n],value)
else
half_find(array[n,array.size],value)
endenda=
(3..9).each do |i|
endp = half_find(a,11)
p pp a[p]
# 二分查詢 # 查詢第乙個值等於給定值的元素
def half_find(array,value)
if array.size <= 1
return 0 if array[0] && array[0] == value
return nil
endn = array.size / 2
return n if value == array[n]
if value < array[n]
half_find(array[0,n],value)
else
half_find(array[n,array.size],value)
endend

附上**：

# 歸併排序

def merge_sort(array)
length = array.size
return array if length <= 1
n = length / 2
left = merge_sort(array[0,n])
right = merge_sort(array[n,length])
merge(left,right)
end# 先從左邊找到最小單位，進行排序，再找左邊的右邊，再右邊的左邊，到右邊的右邊，最後左邊與右邊 （遞迴）
# 分治法典型
def merge(left,right)
l ,r = 0,0
result = 
while l < left.size and r < right.size
if left[l] < right[r]
l+=1
else
r+=1
endend
result += left[l,left.size] if left[l,left.size].length > 0
result += right[r,right.size] if right[r,right.size].length > 0
result
endaa = merge_sort([7,6,5,4,3,2,1])
p aa

# 穩定快排優化**--ruby --下標排序 適用於各場景排序

def index_quick_sort(array)
# 遞迴終點
return array if array.length <= 1
# 選取隨機下標,rand針對區間/某個數,sample針對陣列,因此這裡選前者更適合
random_num = rand(array.length)
# 準備陣列
less_array = 
greater_array = 
# 注意，這裡的@array是例項變數，array是區域性變數
# 因為每次都要生成乙個新陣列，所以區域性變數恰好適合
(0..array.length-1).each do |i|
next if i == random_num
if array[i] < array[random_num]
next
endif array[i] > array[random_num]
next
endif array[i] == array[random_num] && i < random_num #這裡處理不穩定性,加上該段**保證排序穩定
else
endend
quick_sort(less_array) + [array[random_num]] + quick_sort(greater_array)
end

# 不穩定快排優化**--ruby --值排序 對重複值的順序不在意的話可以考慮，在大量資料且多重複時，效能遠遠大於穩定快排

def value_quick_sort(array)
return array if array.size <= 1
# 選取隨機值,rand針對區間/某個數,sample針對陣列,因此這裡選前者更適合
random_value = array.sample
n = array.count(random_value)
value_quick_sort(array.select ) + [random_value]*n + value_quick_sort(array.select )
end

# 下標結合值 穩定快排,還有優化的地方,待完善，在大量資料且多重複時，效能遠遠大於穩定快排，資料重複越多，效能提公升越大！

def index_value_quick_sort(array)
# 遞迴終點
return array if array.length <= 1
# 選取隨機下標,rand針對區間/某個數,sample針對陣列,因此這裡選前者更適合
random_num = rand(array.length)
value = array[random_num]
n = array[0,random_num+1].count(value)
m = 0
p = 0
# (i == value && i.object_id > value_object_id) 記憶體位址可否排序？待考慮，重複select，待優化
index_value_quick_sort(array.select ) + array.select  + [value] + array.select  + index_value_quick_sort(array.select )
end

(x=a.pop) ? quick_sort(a.select ) + [x] + quick_sort(a.select ) :

end

s1=[1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 4, 5, 6, 7, 8, 25, 54, 54, 67, 96].size

s2=[1, 1, 2, 2, 3, 3, 3, 4, 5, 6, 7, 8, 25, 54, 54, 67, 96].size
[1, 1, 2, 2, 3, 3, 3, 4, 5, 6, 7, 8, 25, 54, 54, 67, 96]
a=[2,1,3,2,54,3,6,7,5,4,8,96,67,54,3,25,1,2,2,2,2]*299
p a.length
t= (time.now)
bb = index_value_quick_sort(a)
p bb
t1=(time.now)

p t1 - t

t=(time.now)

aa = index_quick_sort(a)

p aa
t1=(time.now)

p t1 - t

p aa.length
p bb.length
p a.size

scala實現快排，歸併，冒泡，二分查詢

快速排序使用分治的思想，選定乙個基準點，通過一趟排序將待排序的序列分為左右兩個部分，其中左邊的部分都比基準點要小，右邊的基準點都比基準點要大，之後在分別對左右兩邊的部分，按照相同的思想繼續切分，最終達到乙個有序佇列的目的 時間複雜度 o nlog n 空間複雜度 o log n def quicks...

模板題 快排 歸併 二分

include using namespace std const int n 1000010 int q n void quick sort int q,int l,int r quick sort q,l,j quick sort q,j 1,r intmain include using na...

快排和二分查詢

我只是課本的搬運工，做做筆記，當練打字也可以。這裡我把qsort放前面講是因為bsearch在使用之前需要對陣列進行排序，排完後才能進行查詢。老師說學了快排之後就不要用氣泡排序法和選擇排序法了，然而我選擇排序還不太會，找個時間整理整理吧。快速排序 qsort函式 標頭檔案 或 功能 對具有num個元...