数据结构--排序复习

数据结构排序

各排序综述：

一、直接插入排序

R[0] = R[i];		//设置哨兵
for(j = j-1; R[0].key < R[j].key; --j);		//从后往前找
//循环结束明R[i]的插入位置为j+1
	R[j+1] = R[j]
//查找过程中关键字不小于R[i].key的记录，查找同时往后移

整体代码：

void InsertSort(SqList &L){
//对顺序表L作直接插入排序
	for( i = 2; i <= L.length; ++i){
		if(L.r[i].key < L.r[i-1].key{
			L.r[0] = L.r[i]		//复制为监视哨
			L. r[i] =L. r[i-1];
			for(j = i-1; L.r[0]].key < L.r[j].kry; --j)
				L.r[j+1] = L.r[j];	//记录后移
			L.r[j+1] = L.r[0];		//插入到正确位置
			}
		}

二、折半插入排序

void BInsertSort(SqList &L){
	//对顺序表L作折半排序
	for(i = 2; i<= L.length; i++){
		L.r[0] = L.r[i];		//将L.r[i]暂存到L.r[0]
		low = 1; high = i-1;	
		while(low <= high){
			m = (low + high)/2;	//折半
			if(L.r[0].key < L.r[m].key)
				high = m-1;
			else low = m+1;
		}
		for (j = i-1; j>=high +1; --j) L.r[i+1] = L.r[j];		//记录后移
		L.r[high + 1] = L.r[0];			//插入
	}
}
		

三、起泡排序

void BUbbleSort(Elem R[],int n){
	i = n;
	while(i>i){
		lastExchangeIndex = 1;
		for(j =1; j<1; j++)
			if(R[j+!].key < R[j].key){
				Swap(R[j],R[j+1]);
				lastExchangeIndex = j;		//记下进行交换的记录位置
				}
			i= lastExchangeIndex;//本趟进行过交换的最后一个记录的位置
		}
	}

四、快速排序

void QSort(SqList &L,int low,int high){
	//对顺序表L的子序列L.r[low..high]作快速排序
	if (low<high){
	pivotloc = Partition(L,lowl,high);
	QSort(L,low ,pivotloc-1);
	QSort(L,pivotloc+1,high);
	}
}

五、简单排序

void SelectSort(SqList &T){
	//对顺序表进行简单排序
	for(i =1;i<L.length;++i){
	i = SelectMinkey(L,i)
	if(i!=j) L.r[i] <-->L.r[j];
	}
}

六、堆排序

七、归并排序

def merge(arr, l, m, r): 
    n1 = m - l + 1
    n2 = r - m 
  
    # 创建临时数组
    L = [0] * (n1)
    R = [0] * (n2)
  
    # 拷贝数据到临时数组 arrays L[] 和 R[] 
    for i in range(0 , n1): 
        L[i] = arr[l + i] 
  
    for j in range(0 , n2): 
        R[j] = arr[m + 1 + j] 
  
    # 归并临时数组到 arr[l..r] 
    i = 0     # 初始化第一个子数组的索引
    j = 0     # 初始化第二个子数组的索引
    k = l     # 初始归并子数组的索引
  
    while (i < n1 and j < n2): 
        if (L[i] <= R[j]): 
            arr[k] = L[i] 
            i += 1
        else: 
            arr[k] = R[j] 
            j += 1
        k += 1
  
    # 拷贝 L[] 的保留元素
    while (i < n1): 
        arr[k] = L[i] 
        i += 1
        k += 1
  
    # 拷贝 R[] 的保留元素
    while (j < n2): 
        arr[k] = R[j] 
        j += 1
        k += 1
  
def mergeSort(arr,l,r): 
    if (l < r):      
        m = int((l+(r-1))/2)       
        mergeSort(arr, l, m) 
        mergeSort(arr, m+1, r) 
        merge(arr, l, m, r) 
  
  
arr = np.random.randint(100, size=2000)

mergeSort(arr,0,2000-1) 
# print ("排序后的数组:", arr)