算法上机题目mergesort，priority queue，Quicksort，divide and conquer

1．Implement exercise 2.3-7.

2． Implement priority queue.

3． Implement Quicksort and answer the following questions. (1) How many comparisons will Quicksort do on a list of n elements that all have the same value? (2) What are the maximum and minimum number of comparisons will Quicksort do on a list of n elements, give an instance for maximum and minimum case respectively.

4． Give a divide and conquer algorithm for the following problem: you are given two sorted lists of size m and n, and are allowed unit time access to the ith element of each list. Give an O(lg m + lgn) time algorithm for computing the kth largest element in the union of the two lists. (For simplicity, you can assume that the elements of the two lists are distinct).

l  实验过程

1.先读懂题目，由于题目是英文的，所以读懂题目很重要。

2.根据题目回想自己课堂上所学的知识，进行初步思路构思。

3.在本子上写出伪代码，可以简练，自己懂就好。

4.检查伪代码，并上机运行，转换成实际C代码。

5.代码纠错和运行调试，并进行数据测试，数据测试尽可能全面。

l  具体代码

1.mergesort

#include<stdio.h>

#include<stdlib.h>

#include<time.h>

#include<malloc.h>

#define MAX 10000

void merge_sort(int a[],int p,int r);             //定义函数

int main()

{

for(;;)                                      //无限循环的函数，方便测试

{

int a[10],i;

int j=9;

int x;

srand((int)time(NULL));                //产生随机数

for(i=0;i<10;i++)

{

a[i]=rand()%100;

printf("%d\t",a[i]);

}

printf("请输入给定的和：\n");

scanf("%d",&x);

merge_sort(a,0,9);

i=0;

while(j>i)

{

if(a[i]+a[j]>x)

j--;

else if(a[i]+a[j]<x)

i++;

else

{

printf("a中存在两个数和等于x, 它们分别是%d\t%d\n",a[i],a[j]);

break;

}

}

if(i==j)

printf("a中不存在两个数和等于x\n");

}

system("pause");

return 0;

}

void merge(int a[],int p,int q,int r)

{

int n1,n2;

int i,j,k;

n1=q-p+1;

n2=r-q;

int* L=(int*)malloc(sizeof(int)*(n1+1));

int* R=(int*)malloc(sizeof(int)*(n2+1));

for(i=0;i<n1;i++)

L[i]=a[p+i];

for(j=0;j<n2;j++)

R[j]=a[q+j+1];

L[n1]=MAX;

R[n2]=MAX;

i=0;

j=0;

for(k=p;k<=r;k++)

{

if(L[i]<=R[j])

{

a[k]=L[i];

i++;

}

else

{

a[k]=R[j];

j++;

}

}

free(L);

free(R);

}

void merge_sort(int a[],int p,int r)

{

int q;

if(p<r)

{

q=(p+r)/2;

merge_sort(a,p,q);

merge_sort(a,q+1,r);

merge(a,p,q,r);

}

}

2.priority queue

#include<stdio.h>

#include<stdlib.h>

#include<time.h>

#include<malloc.h>

void build_max_heap(int a[]);

int heap_maximum(int a[]);

int heap_extract_max(int a[]);

void heap_increase_key(int a[],int i,int key);

void max_heap_insert(int a[],int key);

static int heapsize=0;

static int length=0;

int  main()

{

printf("请输入数组的大小：");

scanf("%d",&heapsize);

int m;

int* a=(int *)malloc(sizeof(int)*heapsize);

int i;

srand((int)time(NULL));

for(i=0;i<heapsize;i++)

{

a[i]=rand()%100;

printf("%d\t",a[i]);

}

printf("\n");

build_max_heap(a);

for(i=0;i<heapsize;i++)

{

printf("%d\t",a[i]);

}

printf("\n");

printf("MAXIMUM(S):返回S中具有最大关键字的元素:");

printf("%d\n",heap_maximum(a));

m=heap_maximum(a);

printf("EXTRACT_MAX(S):返回S中具有最大关键字的元素并删除之:");

printf("%d\n",heap_extract_max(a));

printf("MAXIMUM(S):返回新的S中具有最大关键字的元素:");

printf("%d\n",heap_maximum(a));

heapsize++;

a[heapsize-1]=m;

build_max_heap(a);

heap_increase_key(a,1,100);

printf("INCREASE_KEY(S,1,100):将数组下标为1的元素改变为100后的数组:");

for(i=0;i<heapsize;i++)

{

printf("%d\t",a[i]);

}

printf("\n");

max_heap_insert(a,10);

printf("INSORT(S,10):插入元素10后的数组:");

for(i=0;i<heapsize;i++)

{

printf("%d\t",a[i]);

}

printf("\n");

free(a);

system("pause");

return 0;

}

int parent(int i)

{

return (i-1)/2;

}

int left(int i)

{

return 2*i+1;

}

int right(int i)

{

return 2*i+2;

}

void max_heapify(int a[],int i)

{

int l,r,largest;

l=left(i);

r=right(i);

if((l<=heapsize-1)&&a[l]>a[i])

largest=l;

else

largest=i;

if((r<=heapsize-1)&&a[r]>a[largest])

largest=r;

if(largest!=i)

{

int temp=a[i];

a[i]=a[largest];

a[largest]=temp;

max_heapify(a,largest);

}

}

//建立大顶堆过程

void build_max_heap(int a[])

{

length=heapsize;

int i;

for(i=(length-1)/2;i>=0;i--)

max_heapify(a,i);

}

int heap_maximum(int a[])

{

return a[0];

}

int heap_extract_max(int a[])

{

int max;

if(heapsize<1)

{

printf("heap underflow\n");

return -1;

}

else

{

max=a[0];

a[0]=a[heapsize-1];

heapsize=heapsize-1;

max_heapify(a,0);

return max;

}

}

void heap_increase_key(int a[],int i,int key)

{

if(key<a[i]||i>heapsize-1)

printf("new key is smaller than current key\n");

else

{

a[i]=key;

while(i>0&&a[parent(i)]<a[i])

{

int temp=a[i];

a[i]=a[parent(i)];

a[parent(i)]=temp;

i=parent(i);

}

}

}

void max_heap_insert(int a[],int key)

{

heapsize++;

realloc(a,sizeof(int)*heapsize);

a[heapsize-1]=-1;

heap_increase_key(a,heapsize-1,key);

}

3.Quicksort

#include<stdio.h>

#include<stdlib.h>

#include<time.h>

int partition(int a[],int p,int r);

void quicksort(int a[],int p,int r);

void main()

{

int i,a[10];

srand((int)time(NULL));

for(i=0;i<10;i++)

{

a[i]=rand()%100;

printf("%d\t",a[i]);

}

quicksort(a,0,9);

for(i=0;i<10;i++)

{

printf("%d\t",a[i]);

}

}

void quicksort(int a[],int p,int r)

{

int q;

if(p<r)

{

q=partition(a,p,r);

quicksort(a,p,q-1);

quicksort(a,q+1,r);

}

}

int partition(int a[],int p,int r)

{

int x,i,j,temp;

x=a[r];

i=p-1;

for(j=p;j<r;j++)

{

if(a[j]<=x)

{

i++;

temp=a[i];

a[i]=a[j];

a[j]=temp;

}

}

temp=a[i+1];

a[i+1]=a[r];

a[r]=temp;

return i+1;

}

4.divide and conquer

#include<stdio.h>

#include<stdlib.h>

#include<time.h>

#include<malloc.h>

int partition(int a[],int p,int r);

void quicksort(int a[],int p,int r);

int findi(int a[],int i);

int FindTheKth(int a[],int b[],int aLeft, int aRight, int bLeft, int bRight, int k) ;

void main()

{

int n,m,i;

srand((int)time(NULL));

printf("请输入两个数组的大小:\n");

printf("n:");

scanf("%d",&n);

printf("m:");

scanf("%d",&m);

int* a=(int*)malloc(sizeof(int)*n);

int* b=(int*)malloc(sizeof(int)*m);

printf("a数组:\n");

for(i=0;i<n;i++)

{

a[i]=rand()%100;

printf("%d\t",a[i]);

}

printf("\nb数组:\n");

for(i=0;i<m;i++)

{

b[i]=rand()%100;

printf("%d\t",b[i]);

}

quicksort(a,0,n-1);

quicksort(b,0,m-1);

printf("\n排序后的a数组:\n");

for(i=0;i<n;i++)

{

printf("%d\t",a[i]);

}

printf("\n排序后的b数组:\n");

for(i=0;i<m;i++)

{

printf("%d\t",b[i]);

}

printf("\n");

printf("数组a的第4个元素:%d\n",findi(a,4));

printf("数组b的第4个元素:%d\n",findi(b,4));

printf("%d\n",FindTheKth(a,b,0, n-1, 0, m-1, 7));

free(a);

free(b);

}

void quicksort(int a[],int p,int r)

{

int q;

if(p<r)

{

q=partition(a,p,r);

quicksort(a,p,q-1);

quicksort(a,q+1,r);

}

}

int partition(int a[],int p,int r)

{

int x,i,j,temp;

x=a[r];

i=p-1;

for(j=p;j<r;j++)

{

if(a[j]<=x)

{

i++;

temp=a[i];

a[i]=a[j];

a[j]=temp;

}

}

temp=a[i+1];

a[i+1]=a[r];

a[r]=temp;

return i+1;

}

int findi(int a[],int i)

{

int size=0;

for(;;)

if(a[size]>=0&&a[size]<=100)

size++;

else

break;

if(i>size||i<1)

{

return -1;

}

else

return a[i-1];

}

int FindTheKth(int a[],int b[],int aLeft, int aRight, int bLeft, int bRight, int k)

{

int aMid = (aLeft + aRight) / 2, bMid = (bLeft + bRight) / 2;

if (aLeft > aRight) return b[bLeft+k-1];

if (bLeft > bRight) return a[aLeft+k-1];

if (a[aMid] <= b[bMid])

{

if (k <= (aMid - aLeft) + (bMid - bLeft) + 1)

{

return FindTheKth(a,b,aLeft, aRight, bLeft, bMid-1, k);

}

else

{

return FindTheKth(a,b,aMid+1, aRight, bLeft, bRight, k-(aMid-aLeft)-1);

}

}

else

{

if (k <= (aMid - aLeft) + (bMid - bLeft) + 1)

{

return FindTheKth(a,b,aLeft, aMid-1, bLeft, bRight, k);

}

else

{

return FindTheKth(a,b,aLeft, aRight, bMid+1, bRight, k-(bMid-bLeft)-1);

}

}

return -1;

}

l  实验结果

mergesort结果

通过实验我们知道：归并排序是一个典型的分治合并算法，对一个大小的记录序列排序，可以把记录划分成2个记录序列，如果这两个子序列还是不能直接排序，则一真划分，直到序列剩下2个素或者1个元素。分治完毕后再依次两两，直至合并成一个有序表。

如果问题规模为T(n),则分治过程中分成了两个子问题每个子问题的规模是1/2 * T(n/2)
合并排序的运行时间可以分解为：

分解：就是算出中间位置
解决：递归解决两个子问题，时间为1/2 * T(n/2)
合并：我们注意到，在一个含有n个元素的子数组上，Merge过程的运行时间为O(n),由于O(n)是线性关系，不妨设O(n)
= cn;每一层的总规模是cn,一共有logn + 1层，那么复杂度为cn*logn,所以得出O(nlogn)。

priority queue结果

优先队列最基本的功能就是出队时不是按照先进先出的规则，而是按照队列中优先级顺序出队。

1、一般存放实型类型，可比较大小

2、默认情况下底层以Vector实现

3、默认情况下是大顶堆，也就是大者优先级高，后面可以自定义优先级比较规则

堆分为大根堆和小根堆，是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值，即A[PARENT[i]] >= A[i]。在数组的非降序排序中，需要使用的就是大根堆，因为根据大根堆的要求可知，最大的值一定在堆顶。

堆排序法利用二叉树最大堆实现对数字的排序。其排序的时间为O（nlgn)

divide and conquer结果及分析

原问题是规模为 n 的问题，在树的第一层，把问题分为规模为n/2的两个子问题，如果解决了这两个子问题，把它们合并就能得到原问题的解。现在来看其中的一个子问题，为了解决他们，又把它分为两个规模更小的问题n/4。解决了规模为n/4的问题，合并之就能得到规模 n/2 的问题的解。按照上面的思想，把原问题递归的分解为规模小的问题，然后合并之就能得到原问题的解。

Quicksort结果及分析

本例产生随机数，并将其排序。

快速排序采用的“大事化小，小事化了”的思想，用递归的方法，将原问题分解成若干规模较小但与原问题相似的子问题进行求解。快速算法的平均时间复杂度为O(nlogn) ，平均而言，快速排序是基于关键字比较的内部排序算法中速度最快者；但是由于快速排序采用的是递归的方法，因此当序列的长度比较大时，对系统栈占用会比较多。快速算法尤其适用于随机序列的排序。

l  实验总结

这次实验总的来说还是蛮顺利的，由于课本上的基础知识提前都看了，而且关于实验的内容提前在课下做了很多，所以还是蛮轻松的，不过，有一点就是，如何将所学习的知识应用于真正的实践中，比如说这次的实验，将伪代码转换称自己的思想是要经消化的，再通过自己的语言表达出来，或者用C，或者C++，或者Java都可以。关于上机，自己也更体会到了算法这门课的奥妙，通过上机，我们才真正怎么将复杂的算法简化，然后减轻计算机的负担，优化程序的执行时间，这在我们以后的编程之中是很有用的。

还有就是课本上的伪代码便于理解，但是如果直接转换成可以运行的代码则又会有一些问题，比如有关数组的下标问题，有关部分循环结构的问题。

总的来说，受益匪浅，辅导老师也解决了我的几个问题。谢谢老师。