算法导论 practice1

1、      (2.3.7) Describe a Θ(n lg n)-time algorithm that, given a set S of n integers and another integer x, determines whether or not there exist two elements in S whose sum is exactly x.给定含有n个整型数的集合S和整型数x，确定s中是否存在两个元素的和等于x。算法时间复杂度为c塔nlgn。

 

判断是否存在的函数的时间复杂度小于0（nlgn），归并排序的时间复杂度是0（nlgn）。

#include<stdio.h>
#include<stdlib.h>
void merge(int arr[],int low,int mid,int high){
     int i,k;
     int *tmp=(int*)malloc((high-low+1)*sizeof(int));
     int left_low=low;
     int left_high=mid;
     int right_low=mid+1;
     int right_high=high;
     for(k=0;left_low<=left_high&&right_low<=right_high;k++)
     {
     if(arr[left_low]<=arr[right_low]){
                                       tmp[k]=arr[left_low++];
                                       }
     else{
          tmp[k]=arr[right_low++];
          }
} 
     
     if(left_low<=left_high){
                             for(i=left_low;i<=left_high;i++){
                                                              tmp[k++]=arr[i];
                                                              }
                             }
      if(right_low<=right_high){
                             for(i=right_low;i<=right_high;i++)
                                                               tmp[k++]=arr[i];
                                                       }
                             for(i=0;i<high-low+1;i++)
                                                      arr[low+i]=tmp[i];
     
}

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);
             }
     }
int main(){
    int a[8]={3,5,8,6,4,1,1};
    int i,j;
    int x=10;
    merge_sort(a,0,6);
    printf("after Merging-Sort:
");
    for(i=0;i<7;i++){
                     printf("%d",a[i]);
                     }
    printf("
");
    i=0;j=6;
    do{
                 
                 if(a[i]+a[j]==x){
                                 printf("exist");
                                 break;
                                 }
                 if(a[i]+a[j]>x)
                                j--;
                 if(a[i]+a[j]<x)
                                i++;
                      }while(i<=j);
    if(i>j) 
            printf("not exist");
    system("pause");
    return 0;
    }

2、      Implement priority queue.

优先队列

 

 

#include<stdlib.h>
#include<stdio.h>
#include<math.h>
#define SIZE 7
int PARENT(int i){
    return (int)floor(i/2);
    }
int LEFT(int i){
    return 2*i;
    }
int RIGHT(int i){
    return 2*i+1;
    }
void MAX_HEAPIFY(int arr[],int i){
     int l=LEFT(i);
     int r=RIGHT(i);
     int largest;
     if(l<=SIZE&&arr[l]>arr[i]){
                                           largest=l;
                                           }
     else largest=i;
     if(r<SIZE&&arr[r]>arr[largest]){
                                                 largest=r;
                                                 }
     if(!largest==i){
                    int t;
                    t=arr[i];arr[i]=arr[largest];arr[largest]=t;
                    MAX_HEAPIFY(arr,i);
                    }
     }
void BULID_MAX_HEAP(int arr[]){
     //SIZE=arr[].length;
     for(int i=(int)floor(SIZE/2);i>0;i--){
             MAX_HEAPIFY(arr,i);
             }
     }
void HEAPSORT(int arr[]){
     BULID_MAX_HEAP(arr);
     int length=SIZE;
     for(int i=length;i>1;i--){
             int t;
             t=arr[1];arr[1]=arr[i];arr[i]=t;
             length=length-1;
             MAX_HEAPIFY(arr,1);
             }
     }

int HEAP_MAXIMUM(int arr[]){
    return arr[1];
    }
int HEAP_EXTRACT_MAX(int arr[]){
    if (SIZE<1){
                           printf("error:heap underflow");
                           }
    int max=arr[1];
    arr[1]=arr[SIZE];
    int length=SIZE;
    length=length-1;
    MAX_HEAPIFY(arr,1);
    return max;
    }
void HEAP_INCREASE_KEY(int arr[],int i,int key){
     if(key<arr[i]){
                    printf("error:new key is smaller than current key");
                    }
     arr[i]=key;
     while (i>1&&arr[PARENT(i)]<arr[i]){
           int t;
           t=arr[i];arr[i]=arr[PARENT(i)];arr[PARENT(i)]=t;
           i=PARENT(i);
           } 
     }
void MAX_HEAP_INSERT(int arr[],int key){
     int length=SIZE;
    length=length+1;
     arr[SIZE]=-10000;
     HEAP_INCREASE_KEY(arr,SIZE,key);
     }
/*int HEAP_MAXIMUM(int arr[]){
    BULID_MAX_HEAP(arr[]);
    return arr[1];
    }
    */
int main(){
    int arr[7]={3,5,8,6,4,1,1};
    int key,i;
    HEAPSORT(arr);
    printf("堆排序后：");
    for(int i=0;i<7;i++){
                     printf("%d ",arr[i]);
                     }
    printf("
"); 
    printf("最大值是：%d
",HEAP_MAXIMUM(arr));
    HEAP_EXTRACT_MAX(arr);
    printf("已经去掉最大值
");
    printf("请输入key的值");
    scanf("%d",&key); 
    printf("请输入i的值");
    scanf("%d",&i);
    HEAP_INCREASE_KEY(arr,i,key);
    printf("已经把下标为i的元素值增加到key");
    system("pause");    
    return 0;

    }

3、      Implement Quicksort and Randomized Quicksort. 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.

实现Quicksoet和Randomized。

实现普通快速排序的两个函数：

实现随机快速排序的两个函数：

  

请回答1、列表中n个元素的值都相同时，Quicksoet比较几次。

答: (n-1)+(n-2)+…+1=n(n-1)/2

2、列表中有n个元素,比较次数的最大值最小值是多少，分别给出对应情况。

答：最坏情况是枢纽元素把其余数字分的个数区别很大，O（n­­方）

最好情况是枢纽元素恰好是中位数，O（nlgn）

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
int PARTITION(int a[],int p,int r){
    int x=a[r];
    int i=p-1;
    int j;
    for(j=p;j<r;j++){
                     if(a[j]<=x){
                                 i=i+1;
                                 int t=a[i];a[i]=a[j];a[j]=t;
                                 }
                     } 
    int t=a[i+1];a[i+1]=a[r];a[r]=t;
    return i+1;
    }
    
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 RAN_PAR(int a[],int p,int r){
    int i=p + rand()%(r-p+1);
    int t=a[r];a[r]=a[i];a[i]=t;
    return PARTITION(a,p,r);
    }
void RAN_QUI(int a[],int p,int r){
     if(p<r){
             int q=RAN_PAR(a,p,r);
             RAN_QUI(a,p,q-1);
             RAN_QUI(a,q+1,r);
             }
     }

int main(){
    int a[8]={3,5,8,6,4,1,1};
    int i;
    printf("输入1进行QUICKSORT,输入2进行RAN-QUI
请输入：
");
    int k;
    scanf("%d",&k);
    
    if(k==1){ 
    printf("after QUICKSORT:
");
    QUICKSORT(a,0,6);
    for(i=0;i<7;i++){
                     printf("%d",a[i]);
                     }
    printf("
");
    }
    
    if(k==2){
    printf("after RAN-QUI:
");
    RAN_QUI(a,0,6);
    for(i=0;i<7;i++){
                     printf("%d",a[i]);
                     }
    printf("
");
    }
    system("pause");
    return 0;
    }

4、(8.2) Sorting in place in linear time

Suppose that we have an array of n data records to sort and that the key of each record has the value 0 or 1. An algorithm for sorting such a set of records might possess some subset of the following three desirable characteristics:

1. The algorithm runs in O(n) time.

2. The algorithm is stable.

3. The algorithm sorts in place, using no more than a constant amount of storage space in addition to the original array.

a. Give an algorithm that satisfies criteria 1 and 2 above.

b. Give an algorithm that satisfies criteria 1 and 3 above.

c. Give an algorithm that satisfies criteria 2 and 3 above.

d. Can you use any of your sorting algorithms from parts (a)–(c) as the sorting method used in line 2 of RADIX-SORT, so that RADIX-SORT sorts n records with b-bit keys in O(bn) time? Explain how or why not.

e. Suppose that the n records have keys in the range from 1 to k. Show how to modify counting sort so that it sorts the records in place in O(n+k) time. You may use O(k) storage outside the input array. Is your algorithm stable? (Hint: How would you do it for k = 3?)

线性时间排序假设对一个有n个数据记录的数组进行排序，每个记录的key值是0或1,。设计给其排序的算法，该算法要包含以下3个要求:1、O(N);2、稳定；3、原址排序，使用的空间不能超过原数据的

A、满足1 2

B、满足1 3

C、满足2 3

D、能否将abc中的算法用于基数排序第二行，使其在排序有b个关键字的n个记录时的时间复杂度为o（bn）

E、假设有n条记录，关键字的范围是1-k。怎么修改基数排序使其为o（n+k）的原址排序。除了输入数组外，可以使用o（k）的额外存储。给出的算法稳定么（提示：当k=3时怎么做？）

4a计数排序满足o(n)和稳定

#include<stdio.h>
#include<stdlib.h>
#define A_LENGTH 8
void COUNTING_SORT(int a[],int b[],int k){
     int c[6];
     for(int i=0;i<k;i++){
             c[i]=0;
             }
     for(int j=0;j<A_LENGTH;j++){
             c[a[j]]=c[a[j]]+1;
             }
     for(int i=0;i<k;i++){
             c[i]=c[i]+c[i-1];
             }
     for(int j=A_LENGTH-1;j>0;j--){
             b[c[a[j]]]=a[j];
             c[a[j]]=c[a[j]]-1;
            }
      }
int main(){
    int a[8]={2,5,3,0,2,3,0,3};
    int b[8]={0,0,0,0,0,0,0,0};
    COUNTING_SORT(a,b,6);
    for(int i=0;i<A_LENGTH;i++){
            printf("%d ",b[i]);
            }
            
    system("pause");
    return 0;
    }

4b 冒泡排序满足o（n）和原址

 

#include<stdio.h>
#include<stdlib.h>
void bubble_sort(int a[],int n)
{
    for(int i=0; i<n-1; i++)
    {
        for(int j=0; j<n-1-i; j++)
        {
            if(a[j] > a[j+1])
            {
                int temp = a[j];a[j] = a[j+1];a[j+1]=temp;
            }
        }
    }
}
int main(){
    int a[8]={4,5,6,3,2,1,8,7};
    bubble_sort(a,8);
    printf("冒泡排序最好情况满足o（n）和原址
");
    for(int i=0;i<8;i++){
            printf("%d ",a[i]);
            }
    system("pause");
    return 0;
    }

4c 插入排序满足稳定和原址

#include<stdio.h>
#include<stdlib.h>
#define N 8
void insert_sort(int a[],int n)
{
    for(int i=1; i<n; i++)
    {
        int j=0;
        while( (a[j]<a[i]) && (j<i))
        {
            j++;
        }
        if(i != j)        {
            int temp = a[i];
            for(int k = i; k > j; k--)
            {
                a[k] = a[k-1];
            }
            a[j] = temp;
        }
    }
}
int  main()
{
    int num[N] = {4,5,6,3,2,1,8,7};
    insert_sort(num, N);
    printf("插入排序满足稳定和原址
");
    for(int i=0; i<N; i++)
        printf("%d  ", num[i]);
    printf("
");
    system("pause");
    return 0;
}

4d

计数排序可以，因为其时间复杂度为o（n）且稳定。给定n

个b位数，其中每一个数位有k种可能取值，耗时为c塔n+k，则基数排序耗时c塔（b（n+k）），即o（bn）。

4e

当K=3时的示例图：

伪代码：

For i=k downto 1{

For(n=a.length;c[k]>0;c[k]--){

                                    A[n]=I;

                                    n--;

}

}

根据c数组记录a中元素出现的次数，在a数组中直接替换，不引入b数组。