1、不使用额外空间, A,B两链表的元素交叉归并

  1. /**  
  2.  *   
  3.  * @author phinecos  
  4.  * @since 2009-05-19  
  5.  *  
  6.  */ 
  7. public class LinkList   
  8. {  
  9.     private static class Node  
  10.     {//内部节点类  
  11.         private int value;//节点值  
  12.         Node next;//下一个节点  
  13.         public Node(int value)  
  14.         {  
  15.             this.value = value;  
  16.             this.next = null;  
  17.         }  
  18.         public Node(int value, Node next)  
  19.         {  
  20.             this.value = value;  
  21.             this.next = next;  
  22.         }  
  23.         public int getValue()   
  24.         {  
  25.             return value;  
  26.         }  
  27.         public void setValue(int value)   
  28.         {  
  29.             this.value = value;  
  30.         }  
  31.         public Node getNext()   
  32.         {  
  33.             return next;  
  34.         }  
  35.         public void setNext(Node next)  
  36.         {  
  37.             this.next = next;  
  38.         }  
  39.     }  
  40.     private Node head;//头节点  
  41.  
  42.     public LinkList()  
  43.     {  
  44.         this.head = null;  
  45.     }  
  46.     public LinkList(LinkList rhs)  
  47.     {  
  48.         Node current = rhs.head;  
  49.         while (current!= null)  
  50.         {  
  51.             this.add(current.value);  
  52.             current = current.next;  
  53.         }  
  54.     }  
  55.     public boolean add(int num)  
  56.     {//以递增方式增加节点到链表头部  
  57.         Node newNode = new Node(num);  
  58.         if (this.head == null)  
  59.         {//第一个节点  
  60.             this.head = newNode;  
  61.         }  
  62.         else 
  63.         {  
  64.             Node pre = null,current = this.head;  
  65.             while (current != null && current.value < num)  
  66.             {//找到合适的插入位置  
  67.                 pre = current;  
  68.                 current = current.next;  
  69.             }  
  70.             //插入新节点  
  71.             pre.next = newNode;  
  72.             newNode.next = current;  
  73.         }  
  74.         return true;  
  75.     }  
  76.  
  77.     public boolean remove(Node node)  
  78.     {//删除节点  
  79.         Node pre = null,current = this.head;  
  80.         if (node == this.head)  
  81.         {//要删除的是头节点  
  82.             this.head = this.head.next;  
  83.         }  
  84.         else 
  85.         {  
  86.             while (current != node)  
  87.             {  
  88.                 pre = current;  
  89.                 current = current.next;  
  90.             }  
  91.             pre.next = current.next;  
  92.         }  
  93.         current = null;  
  94.         return true;  
  95.     }  
  96.  
  97.     public boolean merge(LinkList rhs)  
  98.     {//和另一个链表合并(不使用额外空间),以当前链表为基准  
  99.         boolean result = false;  
  100.         Node p1,p2,p2Pre;  
  101.         p2Pre = null;  
  102.         p1 = this.head;  
  103.         p2 = rhs.head;  
  104.         while ((p1 != null) && (p2 != null))  
  105.         {  
  106.             if (p1.value < p2.value)  
  107.             {  
  108.                 p1 = p1.next;  
  109.             }  
  110.             else if(p1.value >= p2.value)  
  111.             {  
  112.                 p2Pre = p2;  
  113.                 p2 = p2.next;  
  114.                 rhs.remove(p2Pre);  
  115.                 this.add(p2Pre.value);  
  116.             }  
  117.         }  
  118.         while (p2 != null)  
  119.         {  
  120.             p2Pre = p2;  
  121.             rhs.remove(p2Pre);  
  122.             this.add(p2Pre.value);  
  123.             p2 = p2.next;  
  124.         }  
  125.         return result;  
  126.     }  
  127.     @Override  
  128.     public String toString()   
  129.     {  
  130.         StringBuilder sb = new StringBuilder();  
  131.         Node current = this.head;  
  132.         while (current != null)  
  133.         {  
  134.             sb.append(current.value);  
  135.             current = current.next;  
  136.         }  
  137.         return sb.toString();  
  138.     }  
  139.       
  140.     public static void main(String[] args)  
  141.     {  
  142.         LinkList list1 = new LinkList();  
  143.         list1.add(1);  
  144.         list1.add(7);  
  145.         list1.add(5);  
  146.         list1.add(4);  
  147.         list1.add(3);  
  148.         LinkList list2 = new LinkList();  
  149.         list2.add(2);  
  150.         list2.add(4);  
  151.         list2.add(8);  
  152.           
  153.         list1.merge(list2);  
  154.           
  155.         System.out.println(list1);  
  156.         System.out.println(list2);  
  157.     }  

2,字节对齐

  1. #include <iostream>  
  2. using namespace std;  
  3.  
  4. struct A  
  5. {     
  6.     short   a1;     
  7.     short   a2;     
  8.     short   a3;     
  9. };     
  10. struct B  
  11. {     
  12.     long   a1;     
  13.     short   a2;     
  14. };  
  15. struct C  
  16. {  
  17.     int a1;   
  18.     short a2;   
  19.     char a3;   
  20. };  
  21. int main()  
  22. {  
  23.     cout<<sizeof(A)<<endl;  
  24.     cout<<sizeof(B)<<endl;  
  25.     cout<<sizeof(C)<<endl;  
  26.     return 0;  

输出:

  1. 6  
  2. 8  
  3. 8  

结构体A中有3short类型变量,各自以2字节对齐,结构体对齐参数按默认的8字节对齐,则a1,a2,a3都取2字节对齐,则sizeof(A)6,其也是2的整数倍.

Ba14字节对齐,a22字节对齐,结构体默认对齐参数为8,则a14字节对齐,a22字节对齐,结构体大小6字节,6不为4的整数倍,补空字节,增到8时,符合所有条件,则sizeof(B)8

C中补空字节,结构体大小加到8时,是4的倍数,符合条件.

根据上述原理可做如下实验:

  1. struct C  
  2. {  
  3.     int i;//4个字节  
  4.     short s;//2个字节  
  5.     char c;//1个字节  
  6.     long a4;//4个字节  
  7. }; 

   此时sizeof(C)输出12,因为结构体大小填充字节到12时,是4的倍数,符合条件。

   那如果想抛弃掉字节对齐呢,如何做呢?只需要加入下面语句即可

  1. #pragma   pack(1)  

3,插入排序

  1. import java.util.*;   
  2. class InsertSort   
  3. {   
  4.     List al = null;   
  5.     public InsertSort(int num,int mod)   
  6.     {   
  7.         al = new ArrayList(num);   
  8.         Random rand = new Random();   
  9.         System.out.println("The ArrayList Sort Before:");   
  10.         for (int i=0;i<num ;i++ )   
  11.         {   
  12.         al.add(new Integer(Math.abs(rand.nextInt()) % mod + 1));   
  13.         System.out.println("al["+i+"]="+al.get(i));   
  14.         }   
  15.     }   
  16.     public void sortList()   
  17.     {   
  18.         Integer tempInt;   
  19.         int MaxSize=1;   
  20.         for(int i=1;i<al.size();i++)   
  21.         {   
  22.             tempInt = (Integer)al.remove(i); //待插入的数据  
  23.             if(tempInt.intValue()>=((Integer)al.get(MaxSize-1)).intValue())   
  24.             {   
  25.                 al.add(MaxSize,tempInt); //插入  
  26.                 MaxSize++;   
  27.                 System.out.println(al.toString());   
  28.             }   
  29.             else   
  30.             { //比结尾数据小,找到插入位置  
  31.                 for (int j=0;j<MaxSize ;j++ )   
  32.                 {   
  33.                     if (((Integer)al.get(j)).intValue()>=tempInt.intValue())   
  34.                     {   
  35.                         al.add(j,tempInt);   
  36.                         MaxSize++;   
  37.                         System.out.println(al.toString());   
  38.                         break;   
  39.                     }   
  40.                 }   
  41.             }   
  42.         }   
  43.         System.out.println("The ArrayList Sort After:");   
  44.         for(int i=0;i<al.size();i++)   
  45.         {   
  46.             System.out.println("al["+i+"]="+al.get(i));   
  47.         }   
  48.     }   
  49.     public static void main(String[] args)  
  50.     {  
  51.         InsertSort is = new InsertSort(10,100);   
  52.         is.sortList();   
  53.     }  

4,编写一个截取字符串的函数,输入为一个字符串和字节数,输出为按字节截取的字符串。但是要保证汉字不被截半个,如ABC”4,应该截为AB”,输入ABCDEF”6,应该输出为ABC”而不是ABC+汉的半个

  1. import java.util.ArrayList;  
  2. import java.util.List;  
  3. import java.util.regex.Matcher;  
  4. import java.util.regex.Pattern;  
  5.  
  6. /**  
  7.  *   
  8.  * @author phinecos  
  9.  * @since 2009-05-19  
  10.  *  
  11.  */ 
  12. public class Test   
  13. {  
  14.     public static boolean isChinense(String str)  
  15.     {//是否中文  
  16.          boolean result = false;  
  17.          //U+4e00   ~   U+9FB0  
  18.          Pattern p1 = Pattern.compile("[\u4E00-\u9FB0]") ;  
  19.          Matcher m = p1.matcher(str);  
  20.          if (m.matches())   
  21.          {  
  22.              result = true;  
  23.          }  
  24.          return result;  
  25.     }  
  26.     public static List<String> splitString(String strInfo, int n)  
  27.     {  
  28.         List<String> result = new ArrayList<String>();  
  29.         String strTmp;  
  30.         int count = 0;  
  31.         StringBuilder sb = new StringBuilder();  
  32.         for (int i=0; i < strInfo.length(); ++i)  
  33.         {  
  34.             strTmp = strInfo.substring(i,i+1);  
  35.               
  36.             if (count < n)  
  37.             {  
  38.                 if (isChinense(strTmp))  
  39.                 {//是中文  
  40.                     count += 2;  
  41.                     sb.append(strTmp);  
  42.                       
  43.                 }  
  44.                 else 
  45.                 {  
  46.                     ++count;  
  47.                     sb.append(strTmp);  
  48.                 }  
  49.             }  
  50.             else if(count >n)  
  51.             {  
  52.                 sb.deleteCharAt(sb.length()-1);  
  53.                 i -= 2;  
  54.                 count = 0;  
  55.                 result.add(sb.toString());  
  56.                 sb.delete(0,sb.length());  
  57.             }  
  58.             else 
  59.             {  
  60.                 count = 0;  
  61.                 result.add(sb.toString());  
  62.                 sb.delete(0, sb.length());  
  63.                 --i;  
  64.             }  
  65.         }  
  66.           
  67.         return result;  
  68.     }  
  69.     public static void main(String[] args)  
  70.     {  
  71.         String strInfo = "中国,我是phinecos爱好java";  
  72.         List<String> result = splitString(strInfo,6);  
  73.         for (String s : result)  
  74.         {  
  75.             System.out.println(s);  
  76.         }  
  77.  
  78.     }  

5

  1. #include <iostream>  
  2. using namespace std;  
  3.  
  4. struct bit   
  5. {   
  6.     int a:3;   
  7.     int b:2;   
  8.     int c:3;   
  9. };   
  10. int main(int argc, char* argv[])   
  11. {   
  12.     bit s;   
  13.     char *c = (char*)&s;   
  14.     int a = 2;  
  15.     a += 2;  
  16.     *c = 0x99;   
  17.     cout << s.a << endl << s.b << endl << s.c << endl;   
  18.     return 0;   
  19. }  

输出:

1

-1

-4

 

解答:int a:3的意思是a3bit依次类推

c指向s,*c=0x99后,c指向的值变为0x99,100 11 001a=1 b= -1 c= -4

 

因为最高位为符号位

100(算术右移)

=>1111 1111 1111 1100 = -4

 

11(算术右移)

=>1111 1111 1111 1111 = -1

 

001(算术右移)

=>0000 0000 0000 0001 = 1

 

最高位是1,就向左补齐1,最高位是0,就补0,然后按补码看,

100,最高位是1,按32位补齐成1111 1111 1111 1100 ,这是补码,还原成原码,减一取反为100,负的100,即-4