自做算法导论第一章练习题

打酱油的孩子又开始学算法导论了，作为一个it孩子实在是无法看pdf，不习惯呀不习惯，看着看着就睡意全来。。。这要怎么破呀。。。无奈看了两天的js只能先作罢了，等书到了再看吧。。。熊孩子呀熊孩子～

学习算法导论，想把自己完成的练习贴出来，如果有不对的，望大神指出哇。

一、直接插入排序

直接插入排序（Straight Insertion Sort）：是一种简单的排序方法，他的基本操作是将一个记录插入到已排好序的有序表中，从而得到一个新的、记录数增1的有序表。

下面写了一个java程序实现List直接插入排序：

import java.util.List;

import java.util.ArrayList;

import java.util.Scanner;

import java.util.Random;

public class InsertSort{
public static void main(String args[]){
List<Integer> list = new ArrayList<Integer>();  //定义链表
Random rand = new Random();
list.add(0);   //哨兵位置
for(int i=0; i<10; i++){   //随机生成一个待排序序列
//Scanner in=new Scanner(System.in);   //从键盘输入待排序数
//int t=in.nextInt();    //获取一个整型变量
//list.add(new Integer(t)) ;   //插入序列
list.add(rand.nextInt(100)+1); //随机生成一个数
}

               System.out.println(list)；
insertSort(list);
System.out.println(list);
}
public static boolean compare(Integer start, Integer end){  //比较函数
  if(start < end){
return true;
  }else{
return false;
  }
}
public static void insertSort(List<Integer> L){   //插入排序
for(int i=2; i<L.size(); i++){
if(compare(L.get(i),L.get(i-1))){   //元素插入
L.set(0,L.get(i));    //设为哨兵
L.set(i,L.get(i-1));  //元素后移
int j;
for(j=i-2; compare(L.get(0),L.get(j)); j--){
L.set(j+1,L.get(j));  //元素后移
}
L.set(j+1,L.get(0));  //元素插入
}
}
}

}

二、合并排序

2路归并排序中的核心操作是将一维数组中前后相邻的两个有序序列归并为一个有序序列。

下面写了一个java程序实现List合并排序：

import java.util.Random;

public class MergeSortNew{
public static void main(String args[]){
int list[] = new int[10];  //定义数组
Random rand = new Random();
for(int i=0; i<10; i++){   //随机生成一个待排序序列
list[i] = rand.nextInt(100)+1; //随机生成一个数
}
int result[] = new int[list.length];  //定义数组
for(int n=0; n<result.length; n++){
System.out.print(list
+ "  ");
}
System.out.println();
mSort(list,result,0,list.length-1);
for(int n=0; n<result.length; n++){
System.out.print(list
+ "  ");
}
}
public static void merge(int[] L,int[] result ,int start, int mid, int end){   //2路归并
int j,k=0; 
int lowIndex = start;
int len = end - lowIndex + 1;
for(j=mid+1; start<=mid&&j<=end;){    //将L中的数据由小到大插入result
if(L[start]<L[j]) {
result[k++] = L[start++];
}else{
result[k++] = L[j++];
}
}
while(start<=mid)  result[k++] = L[start++];     //将剩余的L[i..m]复制到result
while(j<=end)  result[k++] = L[j++];
//将剩余的L[m+1..n]复制到result
for(k=0; k<len; k++){
L[lowIndex + k] = result[k];
}
}
public static void mSort(int[] L,int result[],int start, int end){  
if(start == end) {
return;
}else{
int m = (start+end)/2;
mSort(L,result,start,m);
mSort(L,result,m+1,end);
merge(L,result,start,m,end);
}
}

}

1.2-2 假设我们要比较在同一台计算机上插入排序和合并排序的实现。对于规模为n的输入，插入排序要运行8n2步，而合并排序要运行64nlgn步。当n取怎样的值时，插入排序的性能要优于合并排序？（下面用java算法实现，运行结果是2）

public class CompareSort{
public static void main(String args[]){  

        for(int i=1; ;i++){
 if(8*i*i <  64*i*log(i,10)){
System.out.println("8*n*n=" + 8*i*i);
System.out.println("64*n*Logarithm.log(n,10)=" + 64*i*log(i,10));
System.out.println(i);
break;
}

      }
}

    static public double log(double value, double base) {   //对数函数
return Math.log(value) / Math.log(base);

    }

}

1.2-3   对于一个运行时间为100n^2的算法，使其在同一台机器上，比一个运行时间为2^n的算法运行得快，求n最小取值是多少？（下面用java算法实现，运行结果是15）

public class compare{
public static void main(String args[]){  
       for(int i=1; ;i++){
      if(100*i*i <  Math.pow(2,i)){
     System.out.println("100*n*n=" + 100*i*i);
     System.out.println("Math.pow(2,n)=" + Math.pow(2,i));
     System.out.println(i);
     break;
       }
     }
   }

}