C语言源码实现
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#define ELE_NUM 8
static void swap(int* a, int* b)
{
int t = 0;
t = *a;
*a = *b;
*b = t;
}
static void BubbleSort(int* array)
{
int i;
int j;
for(i = 0; i < ELE_NUM - 1; i++) {
for (j = ELE_NUM - 1; j > i; j--) {
if (array[j - 1] > array[j]) {
swap(&array[j - 1], &array[j]);
}
}
}
}
static void SelectSort(int* array)
{
int i;
int j;
int min_index = 0;
for (i = 0; i < ELE_NUM - 1; i++) {
min_index = i;
for(j = i + 1; j < ELE_NUM; j++) {
if (array[j] < array[min_index]) {
min_index = j;
}
}
if (min_index != i) {
swap(&array[i], &array[min_index]);
}
}
}
static void InsertSort(int* array)
{
int tmp = 0;
int i;
int j;
for (i = 1; i < ELE_NUM; i++) {
if (array[i] < array[i - 1]) {
tmp = array[i];
}
j = i - 1;
while (j >= 0 && array[j] > tmp) {
array[j + 1] = array[j];
j--;
}
array[j + 1] = tmp;
}
}
static int FindPartition(int* array, int low, int high)
{
int values = array[low];
while (low < high && array[high] >= values) {
high--;
}
swap(&array[low], &array[high]);
while (low < high && array[low] <= values) {
low++;
}
swap(&array[low], &array[high]);
return low;
}
static void QuickSort(int* array, int low, int high)
{
if (low < high) {
int point = FindPartition(array, low, high);
QuickSort(array, low, point - 1);
QuickSort(array, point + 1, high);
}
}
int main()
{
int a[ELE_NUM] = {7, 4, 1, 2, 5, 6, 8, 3};
BubbleSort(a);
for (int i = 0; i < ELE_NUM; i++) {
printf("Bubble, thr sorted array a[%d] is %d\n", i, a[i]);
}
int aa[ELE_NUM] = {9, 4, 1, 2, 5, 6, 8, 3};
SelectSort(aa);
for (int i = 0; i < ELE_NUM; i++) {
printf("Select, thr sorted array aa[%d] is %d\n", i, aa[i]);
}
int aaa[ELE_NUM] = {10, 4, 1, 2, 5, 6, 8, 3};
SelectSort(aaa);
for (int i = 0; i < ELE_NUM; i++) {
printf("Insert, thr sorted array aaa[%d] is %d\n", i, aaa[i]);
}
int low = 0;
int high = ELE_NUM - 1;
int aaaa[ELE_NUM] = {11, 4, 1, 2, 5, 6, 8, 3};
SelectSort(aaaa);
for (int i = 0; i < ELE_NUM; i++) {
printf("Insert, thr sorted array aaaa[%d] is %d\n", i, aaaa[i]);
}
return 0;
}1：冒泡排序：冒泡顾名思义从下往上。两两相邻元素比较进行排序。
时间复杂度：O(n^2),空间复杂度O(1)。稳定
def BubbleSort(s,n):
#两层循环
for i in range(n-1): #注意循环起始边界
for j in range(i+1,n)[::-1]:#注意循环起始边界 j从i+1开始循环,[::-1]表示倒取(从下而上)
if s[j-1]>s[j]:
s[j-1],s[j],=s[j],s[j-1] #交换
return s
if __name__=='__main__': #测试函数
s=[7,4,1,2,5,6,8,3]
n=len(s)
print(BUbble(s,n))
2：选择排序：选择出最小的进行交换。相较于冒泡排序效率要高一些
时间复杂度：O(n^2),空间复杂度O(1)。不稳定
def SelectSort(s,n):
#两层循环
for i in range(n-1): #注意循环起始边界
min_label=i
for j in range(i+1,n):#注意循环起始边界 j从i+1开始循环
if s[j]<s[min_label]: #遍历选择出最小的min_label,更新min_label
min_label=j
if min_label!=i: #交换
s[i],smin_label]=s[min_label],s[i]
return s
if __name__=='__main__': #测试函数
s=[7,4,1,2,5,6,8,3]
n=len(s)
print(SelectSort(s,n))3：直接插入排序：找出当前不满足升序的值，放入缓冲区。指针后移找到其满足升序的位置。相当于找出待排序的数据，插在合适的位置。
时间复杂度：O(n^2),空间复杂度O(1)。稳定
def InsertSort(s,n):
temp=0
for i in range(1,n):
if s[i]<s[i-1]:
temp=s[i] #不满足要求顺序的放入缓冲区，是待插入数据
#找位置，插在当前元素之前
j=i-1
while j>=0 and s[j]>=temp:
s[j+1]=s[j] #元素向前添加
j-=1 #位置递减 后移
s[j+1]=temp #找到位置j,j是比temp小的，所以j+1为插入位置
return s
if __name__=='__main__':
s=[7,2,4,1,5,0,6,8,3,9]
n=len(s)
print(InsertSort(s,n))
4：快速排序：每一趟找一个基准点，大的放在基准点的右面，小的放在基准点的左面。
时间复杂度：O(nlogn),空间复杂度O(nlogn)。稳定
#寻找基准点，找到后交换元素
def Portation(s,low,high):
point_value=s[low] #当取了基准点这个值就固定住了 客观上独立的一个用来比较的常数
while low<high:
while low<high and s[high]>=point_value: #过滤掉大于基准点的
high-=1
s[low],s[high]= s[high],s[low] #关键
while low<high and s[low]<=point_value:#过滤掉小于基准点的
low+=1
s[low],s[high]= s[high],s[low] #关键
return low #当low=high，while结束point=low
def QuickSort(s,low,high): #初始化的默认参数为low=0,high=len(s)-
if low<high: #迭代截至条件
point=Portation(s,low,high) #point是一个下标
QuickSort(s,low,point-1) #递归寻找，比基准点小的放在右面
QuickSort(s,point+1,high)#递归寻找，比基准点大的放在左面
return s #注意这里返回原序列
if __name__ == '__main__':
a = [4, 7, 8, 3, 5, 9]
low=0
high=len(a)-1
print(QuickSort(a,low,high))
5：归并排序：归并就是合并。就是将原序列拆分，之后合并
时间复杂度：O(nlogn),空间复杂度O(n)。稳定
def MergerSort(s): #二路拆分
size=len(s)
if size>1:#递归截至条件
mid=size//2
s1=s[0:mid]
s2=s[mid:size]
MergerSort(s1) #递归拆分
MergerSort(s2) #递归拆分
return Merge(s1,s2)#合并
else:
return s #注意这里必须要有返回值，否则无法退出，且返回值为s
def Merge(s1,s2): #归并排序
size1=len(s1)
size2=len(s2)
res=[]
i,j=0,0
while i<size1 and j<size2:
if s1[i]<s2[j]:
res.append(s1[i])
i+=1
else:
res.append(s2[j])
j+=1
while i<size1:
res.append(s1[i])
i+=1
while j<size2:
res.append(s2[j])
j+=1
return res
if __name__ == '__main__':
a = [4, 7, 8, 3, 5, 9]
print(MergerSort(a))6:堆排序：利用完全二叉树的数据结构实现数组元素的排序。最大堆:父亲>孩子；最小堆：父亲<孩子；
算法步骤：
1：初始化建立一个最大堆。
数组大小为n，则需要进行n次完全二叉树的调整来满足最大堆的要求。在调整过程中我们一般从数组最后一个元素开始
2：交换堆顶元素和数组中的最后一个元素；之后去除最后一个元素（当前最大值），对剩下的数组进行堆的调整，之后进行交换。依次重复上述过程。
# -*- coding: utf-8 -*-
"""
Created on Wed Sep 4 15:43:51 2019
@author: Melo.qi
堆排序
"""
#完全二叉树的调整
def heapify(arr, n, i):
largest = i
l = 2 * i + 1 # left = 2*i + 1
r = 2 * i + 2 # right = 2*i + 2
if l < n and arr[i] < arr[l]:
largest = l
if r < n and arr[largest] < arr[r]:
largest = r
if largest != i:
arr[i],arr[largest] = arr[largest],arr[i] # 交换
heapify(arr, n, largest)
def heapSort(arr):
n = len(arr)
# 创建一个最大堆
for i in range(n, -1, -1): #从数组末尾开始
heapify(arr, n, i) #进行调整
# 一个个交换元素
for i in range(0,n):
arr[n-i-1], arr[0] = arr[0], arr[n-i-1] #数组末尾和堆顶交换
heapify(arr, n-i-1, 0) #剩下部分进行调整
arr = [ 12, 14, 13, 8, 6, 2]
heapSort(arr)
n = len(arr)
for i in range(n):
print ("%d" %arr[i])
扫一扫
257
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
