摘要: 设计一个可以存放任何类型变量，可存放大小运行时确定的类似数组的变量类型-------学习c++编程思想Lib.h定义了一些数据类型和操作函数的声明 /**//*****************************\example c librarypage24 in Thinking in c++array like&nb...  阅读全文

大家好？我又遇到个问题，是关于实体引用的
dtdFile2.dtd文件：

shiti.xml文件：

TestXML.java文件：【随便一个名为TestXML.java即可】
我在浏览器里打开时有如下提示
无效字符是;[引号]吗？那又该如何表示呢？谢谢大家

名称包含无效字符。处理资源 'file:///E:/web/TestXML.java' 时出错。第 19 行，位置: 22

 

 

 

 

   for(int k=0;k<size;k++)
    ---------------------^
实体引用中的特殊符号也要采用实体引用，相当简单的原因

唉！还真是麻烦不断俄，又有问题了，不知道为什么会符号错误！这书上的源代码都有毛病吗？
dtd文件：
java解析器：

错误信息是这样的：
---------- Java编译 ----------[此问题解决函数名大小写搞错了]
testone.java:13: 找不到符号
符号： 方法 newSaxParser()
位置： 类 javax.xml.parsers.SAXParserFactory
      SAXParser saxParser=factory.newSaxParser();
                                 ^
1 错误

Output completed (5 sec consumed) - Normal Termination
----------------------------------------------------------------------------
符号指什么啊？
错误信息第二个：
---------- Java运行 ----------
org.xml.sax.SAXParseException: The markup in the document preceding the root element must be well-formed.

Output completed (3 sec consumed) - Normal Termination
---------------------------------------------------------------------------------------------------------------------
 相关连接http://book.csdn.net/bookfiles/234/10023410858.shtml
使用浏览器检查xml文件得到如下信息：
-----------------------------------------------
无法显示 XML 页。
使用 样式表无法查看 XML 输入。请更正错误然后单击 刷新按钮，或以后重试。
文本内容中发现无效字符。处理资源 'file:///E:/web/dtdFile.dtd' 时出错。第 1 行，位置: 12

<!ELEMENT 
------------------------------------------------------ 

---------- Java运行 ----------[现在的错误]
com.sun.org.apache.xerces.internal.impl.io.MalformedByteSequenceException: Invalid byte 1 of 1-byte UTF-8 sequence.

Output completed (0 sec consumed) - Normal Termination

^_^终于所有问题都解决了
最后一个问题是因为dtd文件没有按utf-8编码方式保存所导致的！

现在的运行结果：
---------- Java运行 ----------
<车>该标记的属性：
<汽车>该标记的属性：
属性名称：车牌  属性类型：CDATA  属性的值：汽 A1234567  <汽车>
<驴车>该标记的属性：
属性名称：车牌  属性类型：CDATA  属性的值：驴 A7654321  <驴车>
<车>

Output completed (0 sec consumed) - Normal Termination

在网上查了些资料，发现类似问题挺多，但都讲的不太明白，在这里请教大家：
xml文件如下：
java解析器如下：

经过编译出现如下错误：
---------- Java编译 ----------
TestXML.java:23: cannot resolve symbol
symbol  : method getTextContent ()
location: interface org.w3c.dom.Node
      String content=node.getTextContent();
                                                     ^
1 error

Output completed (0 sec consumed) - Normal Termination
---------------------------------------------------------------------
网上说这个getTextContent ()方法是dom level3开始能用的
我用的是j2sdk1.4.2_13编译的
郁闷了，不知道哪里错了?还有就是解析来有什么用呢？请教高手给我介绍一下具体的应用，欢迎贴点代码额，呵呵
---------------------------------------------------------------------
查了一下源代码，发现根本没有这个函数，猜想可能是sdk版本过期了
于是到java官方下了个最新版的jdk1.6.0
^_^！很成功的通过了
---------- Java运行 ----------
goods: 
电视机3400元

手机2780元

Output completed (0 sec consumed) - Normal Termination
--------------------------------------------------------------

求解整型数组长度可以使用sizeof(a)/sizeof(int)，当今天我编写插入排序时遇到个问题，代码如下：

搜集资料得到的答案是，数组传入函数时，传入的是指针，并不是我想的那样拷贝副本，
所以此时sizeof(a)/sizeof(int)等于1，条件不符合，跳出循环。
这里只能添加一个数组长度的参数：

不知道各位高手有什么好办法，小弟谢了！
             

 知道的越多就越觉得自己无知，我一直感觉挺有道理的一句话。今天早晨起来莫名其妙想到了这句话，感觉有点怪。这句话可以表述为  越有知就觉得越无知  那么我们这么定义一下
1.有知为q，无知为nq
2.觉得有知p,觉得无知np

那么这句话就是 若q则np，逆否命题是 若p则nq 就是说 越觉得有知就越无知

那么作为一个知道这句话的一个理性人，假设你学的很多，就可以得到你自己变的更有知的结论。那么知道的越多你就越有知，就应该觉得自己有知（理性的分析），是成立的  就是若q则p

综合上述我们得到认可的三条简单表述是：
1. q --> np
2. p --> nq(based on 1,we know 1 is true)
3. q -->p

所以就有 q --> p -->nq ,哇塞，矛盾出现了！

文字表述就是 你越是有知那么你就越是无知（注意这里没有“觉得”不“觉得”了）
所以从今以后我们可以逍遥了，耶！不用读书咯！哈，明天出去庆祝一下！

或者用集合的观点看，假设存在这样的说明：
集合P是无知（无知是有知的一种状态，可以说有知趋于无穷小），集合Q是拓展后的知识即有知，集合U是宇宙知识集合。
那么显然有P<Q<U

我们就可以想象一个文氏图，可以用周长L表示感觉无知的程度，用面积表示S表示有知程度，那么就有这样的表述
S(P)<S(Q)<S(U)，呵呵，由于包含关系这是显然的，说明学的越多就越有知

但是感觉有知无知却不能简单的说L(P)<L(Q)<L(U),因为虽然是包含关系但周长说不定是小的长，形状不同嘛。
由此我们有这样的结论：即感觉这个东西比较复杂，跟知识的多少可能有一定关系，但至少与知识的构成（形状）肯定有关系。

     合并排序的runningtime是O(nlgn),插入排序为O(n*n),当合并排序的划分到一定程度时可以应用插入排序。此时插入排序比合并排序的效率高,所以对合并排序做个修改：n/k 长度为k的子序列用插入法排序。（要确定k的值）

a.证明最坏情况下，n/k个子序列用插入来排序的时间时O(nk).
   插入排序为O(n*n)，那么对长度为k的子序列排序为O(k*k),n/k个子序列排序时间和是(n/k)*O(k*k)=O(n*k),得证

b.证明在最坏情况下各子序列可以在O(nlg(n/k))下合并.

c.设修改后合并算法的时间阶为O(nk+nlg(n/k)).请给出最大渐近值k（以O记号，k是n的函数）使得修改后的算法有和标准合并算法一样的渐近运行时间

d.k的值在实际中如何确定？

自己错的程序mergesort放在各个论坛上寻求答案，结果三天没人回复。想来也是高手无暇，菜鸟无语。于是自己静下心来，仔细看了一下，还是标号弄错了。既然开了两个数组，那么数据拷贝进去后，标号应该是当前数组的，结果用了原来数组的标号，导致错误。这是修改后的源码：

小小的错误，找了我半天

     分治法，顾名思义：切分然后治理，治理就是各个解决问题然后合并整理。递归的解决分成n个较小规模的子问题，然后将各个结果合并从而解决原来的问题。
DIVIDE：将问题分解成一系列子问题。
CONQUER：递归地解决各个子问题，若问题足够小，则直接解决。
COMBINE：将子问题的结果合并成原问题的解。
自己编的代码，结果又运行不起来：ps:几经修改，看来细节问题要注意，简化推理是个好办法
//mergesort
#include<iostream>
using namespace std;

int merge(int*A,int p,int q,int r){
 int n1=q-p+1;
 int n2=r-q;
 int* L = new int[n1];
 int* R = new int[n2];
 for(int i=0;i<n1;++i)
  L[i]=A[p+i];
 for(int j=0;j<n2;++j)
  R[j]=A[q+1+j];
 i=0;j=0;
 for(int k=p;k<r;k++){
  if(L[i]<=R[j]){A[k]=L[i++];}
  else {A[k]=R[j++];}
 }
 return(0);
}

int mergesort(int*A,int p,int r){
 int q;
 if(p<r){
  q=(p+r)/2;
  mergesort(A,p,q);
  mergesort(A,q+1,r);
  merge(A,p,q,r);
 }
 return(0);
}

int main(){
    int b[6]={11,65,53,78,38,63};
    mergesort(b,0,5);
 for(int i=0;i<6;++i)
  cout<<b[i]<<'\t';
 return(0);
}

以下引用自：gooler的专栏http://blog.csdn.net/Gooler/archive/2006/03/22/632422.aspx有各种排序算法quicksort,heapsort...
/*
 * A is an array and p, q, and r are indices numbering elements of the array
 * such that p <= q < r.
 *
 * This procedure assumes that the subarrays A[p. .q] and A[q + 1. .r] are in
 * sorted order. It merges them to form a single sorted subarray that replaces
 * the current subarray A[p. .r].
 */
void merge(int A[], int p, int q, int r) {
    int i, j, k, size;
    int* B;
   
    size = r - p + 1;

    B = new int[size]; /* temp arry for storing the merge result */
   
    /* initialize B */
    for (i = 0; i < size; ++i) {
        B[i] = 0;
    }

    i = p;
    j = q + 1;
    k = 0;
   
    /* compare and copy the smaller to B */
    while (i <= q && j <= r) {
        if (A[i] < A[j]) {
            B[k++] = A[i++];
        } else {
            B[k++] = A[j++];
        }
    }
   
    /* copy the rest to B */
    while (i <= q) {
        B[k++] = A[i++];
    }   
    while (j <= r) {
        B[k++] = A[j++];
    }
   
    /* replace A[p..r] with B[0..r-p] */
    for (i = p, k = 0; i <= r; ++i, ++k) {
        A[i] = B[k];
    }

    delete[] B;
}

/*
 * This procedure sorts the elements in the subarray A[p. .r].
 *
 * If p >= r, the subarray has at most one element and is therefore
 * already sorted. Otherwise, the divide step simply computes an index
 * q that partitions A[p. .r] into two subarrays: A[p. .q], containing n/2
 * elements, and A[q + 1. .r], containing n/2 elements.
 */
void mergeSort(int A[], int p, int r) {
    if (p >= r) return;
   
    int q = (p + r) / 2;
   
    mergeSort(A, p, q);
    mergeSort(A, q + 1, r);
    merge(A, p, q, r);
}

排序选择何种算法取决于排序元素个数及已排序的程度以及所使用的存储设备
  A[1..n]含n个元素的数组  个数n=length[A]
  插入排序－－适合少量元素的排序
   for j<-- 2 to length[A]
       do key<--A[j] 
         //将A[j]插入到排好序的序列A[1..j-1]
          i<--j-1
         while i>0 and A[i]>key
            do A[i+1]<--A[i]
            i<-- i-1
         A[i-1]<--key

用c++源程序描述：
#include<iostream>
using namespace std;
int insertSort(int*array){
int key,i;
for(int j=1;j<6;++j){
     key=array[j];  //将第二个开始的元素放入key
      i=j-1;
      while(i>=0&&array[i]>key){     //将大于key的元素至key原本所在位置的所有元素向后移动一个，并覆盖了key原来的位置
           array[i+1]=array[i];
                   --i;
                                           }
       array[i+1]=key;//将key插入到array[i]的位置
                            }
return(0);

}

int main(){
int a[6]={11,65,53,78,38,63};
insertSort(a);
for(int i=0;i<6;++i)
cout<<a[i]<<'\t';
return(0);
}

该方法在算法设计中叫增量方法Incremental