编程珠玑第二章2.6（5-10）

最新推荐文章于 2025-05-22 09:04:59 发布

原创最新推荐文章于 2025-05-22 09:04:59 发布 · 770 阅读

2 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#编程珠玑第二章习题

编程珠玑专栏收录该内容

15 篇文章

订阅专栏

本文介绍了一种通过向量求逆实现向量旋转的方法，并提供了C++实现示例。同时，还探讨了使用Java实现矩阵转置的算法思路，通过自定义数据结构和排序策略完成矩阵元素的位置交换。

**5.题目描述：向量旋转函数将向量ab变为ba(利用(a’b’)’=ba 这里’代表求逆）。如何
将向量abc变为cba(这对交换非相邻内存块的问题进行了建模)?
解决方法，利用(a’b’c’)’=cba [注：’还是代表求逆]。如果想到这里基本上就解决了。
只需对问题B的算法进行更改即可。**

#include<iostream>
#define Length 9
using namespace std;
char array[Length]="abcdefgh";
void reverse(int start,int end){
    int increment;
    char temp;
    int middle=(start+end)/2;
    for(increment=0;increment+start<=middle;increment++){
        temp=array[increment+start];
        array[increment+start]=array[end-increment];
        array[end-increment]=temp;
    }
}
void printCharArr(){
    for(int i=0;i<Length-1;i++)
    cout<<array[i]<<" ";
    cout<<endl;
}

void do_swap(int aLength,int bLength) 
    {
        cout<<"对前"<<aLength<<"个求逆\n"; 
        reverse(0,aLength-1);
        printCharArr();
        cout<<"对接下来的"<<bLength<<"个求逆\n"; 
        reverse(aLength,aLength+bLength-1);
        printCharArr();
        cout<<"对剩下来的求逆\n"; 
        reverse(aLength+bLength,Length-2);
        printCharArr();
        cout<<"对所有的求逆\n"; 
        reverse(0,Length-2);
        printCharArr();
    }
int main(){
    do_swap(3,2);//这里取 abc为向量A, de为向量B, fgh为向量C 
    return 0; 
}

6.如果用Java来写的话，可以用HashMap<String, TreeSet<String>> 来进行保存，键String用来保存指定的按键编码，值TreeSet<String>用来保存对应的名字表；类似的，C++可用map<string,vector<stirng>> 来存储。其实这题习题2.6的第一题存储的方式差不多。
**7.矩阵转置
Java代码实现，我发现只要根据列排序，就可以将元素换到同一行，并且相对有序。
输入文件是4*4的矩阵**
如下图原矩阵

package chapter2;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
class Data{
    public int row;
    public int column;
    public int value;
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return value+"";
    }
}
class RowCmp implements Comparator<Data>{

    @Override
    public int compare(Data o1, Data o2) {
        // TODO Auto-generated method stub
        return o1.row-o2.row;
    }

}
class ColCmp implements Comparator<Data>{

    @Override
    public int compare(Data o1, Data o2) {
        // TODO Auto-generated method stub
        return o1.column-o2.column;
    }

}
public class t7 {
    public static void printArr(Data[] datas){
        for(int i=0;i<datas.length;i++){
            System.out.print(datas[i].value+" ");
            if(i!=0&&(i+1)%4==0){
                System.out.println();
            }
        }
    }
     public static void main(String []args){
         Data datas[]=new Data[16];
         try {
             Scanner scanner=new Scanner(new File("E://matrix.txt"));
            int current_row=0,current_column=0;
            int value=-1;
            int index=0;
            while(scanner.hasNextInt()){
                value=scanner.nextInt();
                if(current_column==4){
                    current_column=0;
                    current_row++;
                }
                Data data=new Data();
                data.column=current_column;
                data.row=current_row;
                data.value=value;
//              System.out.print(value+" ");
                datas[index++]=data;
                current_column++;
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        finally{
            System.out.println(Arrays.toString(datas));
            printArr(datas);
            Arrays.sort(datas,new ColCmp());
            System.out.println(Arrays.toString(datas));
//          Arrays.sort(datas,new RowCmp());
            printArr(datas);
        }

     }
}

8.进行排序，选前k个元素判断它的和是否小于t
9.s次顺序搜索n元表格所需的平均时间复杂度为O(（1+2+3+…+n）/n*s)=O(ns);而二分搜索要保证所有元素有序，所以要先进行排序，O(nlogn)的排序时间要用掉(注：底数为2），每一次二分搜索寻找的时间又是O(（1+2+3+logn）/logn)=O(logn); 综上s次二分搜索时间复杂度为O(nlogn)+sO(logn)=O((n+s)logn);
比较O(ns)与O(nlogn)明显当n数目巨大，且s较多时，二分搜索更有利。
10.将空灯泡装满水，再倒到量筒中。数学思想里的等价转换，化繁为简。