anyLinux, nonsense talking » DotNet http://anylinux.net 念書是一項每日任務，但是解完了也不給G Wed, 08 Sep 2010 03:32:14 +0000 en hourly 1 http://wordpress.org/?v=3.0.1 Bill retired http://anylinux.net/post/589.html http://anylinux.net/post/589.html#comments Fri, 04 Jul 2008 14:03:22 +0000 drivel http://anylinux.net/?p=589 Bill is good businessman,but Windows is a crap product.
CSharp is a good programing language,but .Net project sucks.

相关日志

]]> http://anylinux.net/post/589.html/feed 0 本地win32窗体查找 http://anylinux.net/post/384.html http://anylinux.net/post/384.html#comments Wed, 29 Aug 2007 03:03:49 +0000 drivel http://anylinux.net/post/384.html 　　 一个可行的办法使用System.Diagnostics.Process列举出所有的运行的进程，然后System.Diagnostics.ProcessThreadCollection 来得到他们的.Threads属性，为了得到thread Id，我们使用Win32 API EnumThreadWindows(DWORD threadId，WNDENUMPROC lpfn，LPARAM lParam) 来实现，这是一个回调(call back)函数，他可以列举出于进程相关的窗体。当我们得到了窗体的句柄以后，我们可以使用另一个API函数 GetWindowText(HWND hwnd，/*out*/LPTSTR lpString，int nMaxCount)来得到窗体的标题，然后根据已经有的窗体，调用API函数SendMessage(HWND hWnd，int msg，int wParam，int lParam)来关闭窗口。下面是演示代码

  1. Process[] myProcesses = Process.GetProcessesByName("IEXPLORE");
  2.  
  3. foreach(Process myProcess in myProcesses)
  4. {
  5. FindPopupToKill(myProcess);
  6. }
  7.  
  8. protected void FindPopupToKill(Process p)
  9. {
  10. // traverse all threads and enum all windows attached to the thread
  11. foreach (ProcessThread t in p.Threads)
  12. {
  13. int threadId = t.Id;
  14.  
  15. NativeWIN32.EnumThreadProc callbackProc =
  16. new NativeWIN32.EnumThreadProc(MyEnumThreadWindowsProc);
  17. NativeWIN32.EnumThreadWindows(threadId， callbackProc， IntPtr.Zero /*lParam*/);
  18. }
  19. }
  20.  
  21. // callback used to enumerate Windows attached to one of the threads
  22. bool MyEnumThreadWindowsProc(IntPtr hwnd， IntPtr lParam)
  23. {
  24. public const int WM_SYSCOMMAND = 0x0112;
  25. public const int SC_CLOSE = 0xF060;
  26.  
  27. // get window caption
  28. NativeWIN32.STRINGBUFFER sLimitedLengthWindowTitle;
  29. NativeWIN32.GetWindowText(hwnd， out sLimitedLengthWindowTitle， 256);
  30.  
  31. String sWindowTitle = sLimitedLengthWindowTitle.szText;
  32. if (sWindowTitle.Length==0) return true;
  33.  
  34. // find this caption in the list of banned captions
  35. foreach (ListViewItem item in listView1.Items)
  36. {
  37. if ( sWindowTitle.StartsWith(item.Text) )
  38. NativeWIN32.SendMessage(hwnd， NativeWIN32.WM_SYSCOMMAND，
  39. NativeWIN32.SC_CLOSE，
  40. IntPtr.Zero); // try soft kill
  41. }
  42.  
  43. return true;
  44. }
  45.  
  46. public class NativeWIN32
  47. {
  48. public delegate bool EnumThreadProc(IntPtr hwnd， IntPtr lParam);
  49.  
  50. [DllImport("user32.dll"， CharSet=CharSet.Auto)]
  51. public static extern bool EnumThreadWindows(int threadId， EnumThreadProc pfnEnum， IntPtr lParam);
  52.  
  53. // used for an output LPCTSTR parameter on a method call
  54. [StructLayout(LayoutKind.Sequential， CharSet=CharSet.Auto)]
  55. public struct STRINGBUFFER
  56. {
  57. [MarshalAs(UnmanagedType.ByValTStr， SizeConst=256)]
  58. public string szText;
  59. }
  60.  
  61. [DllImport("user32.dll"， CharSet=CharSet.Auto)]
  62. public static extern int GetWindowText(IntPtr hWnd， out STRINGBUFFER ClassName， int nMaxCount);
  63.  
  64. [DllImport("user32.dll"， CharSet=CharSet.Auto)]
  65. public static extern int SendMessage(IntPtr hWnd， int msg， int wParam， int lParam);
  66. }

　　上面的方法在性能上是不错的，因为他过滤了其他非IE的窗口.但是我们可以用一个更简单的方法来实现，就是调用API FindWindowEx(HWND hWndParent， HWND hWndNext， /*in*/LPCTSTR szClassName， /*in*/LPCTSTR szWindowTitle)方法.比较有用的是这句，我们可以使用registered window class name来找到IE窗口(IEFrame是所有打开的IE的标识).

  1. protected void FindPopupToKill()
  2. {
  3. IntPtr hParent = IntPtr.Zero;
  4. IntPtr hNext = IntPtr.Zero;
  5. String sClassNameFilter = "IEFrame"; // 所有IE窗口的类
  6. do
  7. {
  8. hNext = NativeWIN32.FindWindowEx(hParent，hNext，sClassNameFilter，IntPtr.Zero);
  9.  
  10. // we've got a hwnd to play with
  11. if ( !hNext.Equals(IntPtr.Zero) )
  12. {
  13. // get window caption
  14. NativeWIN32.STRINGBUFFER sLimitedLengthWindowTitle;
  15. NativeWIN32.GetWindowText(hNext， out sLimitedLengthWindowTitle， 256);
  16.  
  17. String sWindowTitle = sLimitedLengthWindowTitle.szText;
  18. if (sWindowTitle.Length>0)
  19. {
  20. // find this caption in the list of banned captions
  21. foreach (ListViewItem item in listView1.Items)
  22. {
  23. if ( sWindowTitle.StartsWith(item.Text) )
  24. NativeWIN32.SendMessage(hNext， NativeWIN32.WM_SYSCOMMAND，
  25. NativeWIN32.SC_CLOSE，
  26. IntPtr.Zero); // try soft kill
  27. }
  28. }
  29. }
  30. }
  31. while (!hNext.Equals(IntPtr.Zero));
  32.  
  33. }
  34.  
  35. public class NativeWIN32
  36. {
  37. [DllImport("user32.dll"， CharSet=CharSet.Auto)]
  38. public static extern IntPtr FindWindowEx(IntPtr parent /*HWND*/，
  39. IntPtr next /*HWND*/，
  40. string sClassName，
  41. IntPtr sWindowTitle);
  42.  
  43. }

随机日志

]]> http://anylinux.net/post/384.html/feed 0 选择排序 http://anylinux.net/post/292.html http://anylinux.net/post/292.html#comments Wed, 18 Jul 2007 16:13:54 +0000 drivel http://anylinux.net/post/292.html 交换排序的基本思想是：两两比较待排序记录的关键字，发现两个记录的次序相反时即进行交换，直到没有反序的记录为止。
应用交换排序基本思想的主要排序方法有：冒泡排序和快速排序。

冒泡排序

1、排序方法
将被排序的记录数组R[1..n]垂直排列，每个记录R[i]看作是重量为R[i].key的气泡。根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R：凡扫描到违反本原则的轻气泡，就使其向上”飘浮”。如此反复进行，直到最后任何两个气泡都是轻者在上，重者在下为止。

（1）初始
R[1..n]为无序区。
（2）第一趟扫描
从无序区底部向上依次比较相邻的两个气泡的重量，若发现轻者在下、重者在上，则交换二者的位置。即依次比较(R[n]，R[n-1])，(R[n-1]，R[n-2])，…，(R[2]，R[1])；对于每对气泡(R[j+1]，R[j])，若R[j+1].key<R[j].key，则交换R[j+1]和R[j]的内容。
第一趟扫描完毕时，”最轻”的气泡就飘浮到该区间的顶部，即关键字最小的记录被放在最高位置R[1]上。
（3）第二趟扫描
扫描R[2..n]。扫描完毕时，”次轻”的气泡飘浮到R[2]的位置上……
最后，经过n-1 趟扫描可得到有序区R[1..n]
注意：
第i趟扫描时，R[1..i-1]和R[i..n]分别为当前的有序区和无序区。扫描仍是从无序区底部向上直至该区顶部。扫描完毕时，该区中最轻气泡飘浮到顶部位置R[i]上，结果是R[1..i]变为新的有序区。
2、算法分析
（1）算法的最好时间复杂度
若文件的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数C和记录移动次数M均达到最小值：

Cmin=n-1

Mmin=0。

冒泡排序最好的时间复杂度为O(n)。

（2）算法的最坏时间复杂度
若初始文件是反序的，需要进行n-1趟排序。每趟排序要进行n-i次关键字的比较(1≤i≤n-1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：

Cmax=n(n-1)/2=O(n2)

Mmax=3n(n-1)/2=O(n2)

冒泡排序的最坏时间复杂度为O(n^2)。

（3）算法的平均时间复杂度为O(n^2)
虽然冒泡排序不一定要进行n-1趟，但由于它的记录移动次数较多，故平均时间性能比直接插入排序要差得多。
（4）算法稳定性
冒泡排序是就地排序，且它是稳定的。
3、算法改进
上述的冒泡排序还可做如下的改进：

（1）记住最后一次交换发生位置lastExchange的冒泡排序
在每趟扫描中，记住最后一次交换发生的位置lastExchange，（该位置之前的相邻记录均已有序）。下一趟排序开始时，R[1..lastExchange-1]是有序区，R[lastExchange..n]是无序区。这样，一趟排序可能使当前有序区扩充多个记录，从而减少排序的趟数。具体算法【参见习题】。
（2） 改变扫描方向的冒泡排序

①冒泡排序的不对称性

能一趟扫描完成排序的情况：

只有最轻的气泡位于R[n]的位置，其余的气泡均已排好序，那么也只需一趟扫描就可以完成排序。

【例】对初始关键字序列12，18，42，44，45，67，94，10就仅需一趟扫描。

需要n-1趟扫描完成排序情况：

当只有最重的气泡位于R[1]的位置，其余的气泡均已排好序时，则仍需做n-1趟扫描才能完成排序。

【例】对初始关键字序列：94，10，12，18，42，44，45，67就需七趟扫描。

②造成不对称性的原因
每趟扫描仅能使最重气泡”下沉”一个位置，因此使位于顶端的最重气泡下沉到底部时，需做n-1趟扫描。

③改进不对称性的方法
在排序过程中交替改变扫描方向，可改进不对称性。具体算法。

快速排序(QuickSort)

1、算法思想
快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。
（1） 分治法的基本思想
分治法的基本思想是：将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。
（2）快速排序的基本思想
设当前待排序的无序区为R[low..high]，利用分治法可将快速排序的基本思想描述为：
①分解：
在R[low..high]中任选一个记录作为基准(Pivot)，以此基准将当前无序区划分为左、右两个较小的子区间R[low..pivotpos-1)和R[pivotpos+1..high]，并使左边子区间中所有记录的关键字均小于等于基准记录(不妨记为pivot)的关键字pivot.key，右边的子区间中所有记录的关键字均大于等于pivot.key，而基准记录pivot则位于正确的位置(pivotpos)上，它无须参加后续的排序。

注意：

划分的关键是要求出基准记录所在的位置pivotpos。划分的结果可以简单地表示为(注意pivot=R[pivotpos])：

R[low..pivotpos-1].keys≤R[pivotpos].key≤R[pivotpos+1..high].keys

其中low≤pivotpos≤high。

②求解：
通过递归调用快速排序对左、右子区间R[low..pivotpos-1]和R[pivotpos+1..high]快速排序。
③组合：
因为当”求解”步骤中的两个递归调用结束时，其左、右两个子区间已有序。对快速排序而言，”组合”步骤无须做什么，可看作是空操作。
2、快速排序算法QuickSort
  1. void QuickSort(SeqList R，int low，int high)
  2. { //对R[low..high]快速排序
  3. int pivotpos； //划分后的基准记录的位置
  4. if(low&lt;high){//仅当区间长度大于1时才须排序
  5. pivotpos=Partition(R，low，high)； //对R[low..high]做划分
  6. QuickSort(R，low，pivotpos-1)； //对左区间递归排序
  7. QuickSort(R，pivotpos+1，high)； //对右区间递归排序
  8. }
  9. } //QuickSort

注意：

为排序整个文件，只须调用QuickSort(R，1，n)即可完成对R[l..n]的排序。

3、划分算法Partition
（1） 简单的划分方法

① 具体做法

第一步：(初始化)设置两个指针i和j，它们的初值分别为区间的下界和上界，即i=low，i=high；选取无序区的第一个记录R[i](即R[low])作为基准记录，并将它保存在变量pivot中；

第二步：令j自high起向左扫描，直到找到第1个关键字小于pivot.key的记录R[j]，将R[j])移至i所指的位置上，这相当于R[j]和基准R[i](即pivot)进行了交换，使关键字小于基准关键字pivot.key的记录移到了基准的左边，交换后R[j]中相当于是pivot；然后，令i指针自i+1位置开始向右扫描，直至找到第1个关键字大于pivot.key的记录R[i]，将R[i]移到i所指的位置上，这相当于交换了R[i]和基准R[j]，使关键字大于基准关键字的记录移到了基准的右边，交换后R[i]中又相当于存放了pivot；接着令指针j自位置j-1开始向左扫描，如此交替改变扫描方向，从两端各自往中间靠拢，直至i=j时，i便是基准pivot最终的位置，将pivot放在此位置上就完成了一次划分。

②一次划分过程

一次划分过程中，具体变化情况【参见动画演示】

③划分算法：

  1. int Partition(SeqList R，int i，int j)
  2. {//调用Partition(R，low，high)时，对R[low..high]做划分，
  3. //并返回基准记录的位置
  4. ReceType pivot=R[i]； //用区间的第1个记录作为基准 '
  5. while(i&lt;j){ //从区间两端交替向中间扫描，直至i=j为止
  6. while(i&lt;j&amp;&amp;R[j].key&gt;=pivot.key) //pivot相当于在位置i上
  7. j--； //从右向左扫描，查找第1个关键字小于pivot.key的记录R[j]
  8. if(i&lt;j) //表示找到的R[j]的关键字&lt;pivot.key
  9. R[i++]=R[j]； //相当于交换R[i]和R[j]，交换后i指针加1
  10. while(i&lt;j&amp;&amp;R[i].key&lt;=pivot.key) //pivot相当于在位置j上
  11. i++； //从左向右扫描，查找第1个关键字大于pivot.key的记录R[i]
  12. if(i&lt;j) //表示找到了R[i]，使R[i].key&gt;pivot.key
  13. R[j--]=R[i]; //相当于交换R[i]和R[j]，交换后j指针减1
  14. } //endwhile
  15. R[i]=pivot； //基准记录已被最后定位
  16. return i；
  17. } //partition

t84.swf

分析：
（1）递归执行的路线如图中带箭头的包络线所示。

（2） 递归树上每一结点左旁方括号表示当前待排序的区间，结点内的关键字是划分的基准关键字

注意：

叶结点对应的子区间只有一个关键字，无须划分，故叶结点内没有基准关键字

（3） 划分后得到的左、右两个子区间分别标在该结点的左、右两个孩子结点的左边方括号内。

【例】根结点左旁方括号[49，38，65，97，76，13，27，49]表示初始待排序的关键字，根内的49表示所选的划分基准记录的关键字，划分结果是[27，28，13]49[76，97，65，49_]，其左右子区间分别标在根结点的两个孩子的左边。

（4） 每个分支结点右旁圆括号中的内容表示对该结点左旁区间的排序过程结束之后返回的结果。它是其左右孩子对应的区间排序完成之后，将左右孩子对应的排序结果分别放在该分支结点的关键字前后所得到的关键字序列。

【例】分支结点76的左右孩子对应的区间排序后的结果分别是(49_，65)和(97)，将它们分别放在76的前后即得(49，65，76，97)，这是对结点76左旁区间[76，97，，65，49]排序的结果。

（5） 算法的执行顺序是递归树中的箭头顺序，实际上当把划分操作视为访问结点的操作时，快速排序的执行过程相当于是先序遍历其递归树。

注意：
任何递归算法均可用递归树来描述其执行过程。
5、快速排序各次划分后的状态变化
[49 38 65 97 76 13 27 49] //初始关键字

[27 38 13] 49 [76 97 65 49] //第1次划分完成之后，对应递归树第2层

[13] 27 [38] 49 [49 65] 76 [97] //对上一层各无序区划分完成后，对应递归树第3层

13 27 38 49 49 [65] 76 97 //对上一层各无序区划分完成后，对应递归树第4层

13 27 38 49 49 65 76 97 //最后的排序结果

6、算法分析
快速排序的时间主要耗费在划分操作上，对长度为k的区间进行划分，共需k-1次关键字的比较。

（1）最坏时间复杂度

最坏情况是每次划分选取的基准都是当前无序区中关键字最小(或最大)的记录，划分的结果是基准左边的子区间为空(或右边的子区间为空)，而划分所得的另一个非空的子区间中记录数目，仅仅比划分前的无序区中记录个数减少一个。
因此，快速排序必须做n-1次划分，第i次划分开始时区间长度为n-i+1，所需的比较次数为n-i(1≤i≤n-1)，故总的比较次数达到最大值：
Cmax = n(n-1)/2=O(n2)
如果按上面给出的划分算法，每次取当前无序区的第1个记录为基准，那么当文件的记录已按递增序(或递减序)排列时，每次划分所取的基准就是当前无序区中关键字最小(或最大)的记录，则快速排序所需的比较次数反而最多。
（2） 最好时间复杂度
在最好情况下，每次划分所取的基准都是当前无序区的”中值”记录，划分的结果是基准的左、右两个无序子区间的长度大致相等。总的关键字比较次数：
0(nlgn)
注意：
用递归树来分析最好情况下的比较次数更简单。因为每次划分后左、右子区间长度大致相等，故递归树的高度为O(lgn)，而递归树每一层上各结点所对应的划分过程中所需要的关键字比较次数总和不超过n，故整个排序过程所需要的关键字比较总次数C(n)=O(nlgn)。
因为快速排序的记录移动次数不大于比较的次数，所以快速排序的最坏时间复杂度应为0(n2)，最好时间复杂度为O(nlgn)。
（3）基准关键字的选取
在当前无序区中选取划分的基准关键字是决定算法性能的关键。
①”三者取中”的规则
“三者取中”规则，即在当前区间里，将该区间首、尾和中间位置上的关键字比较，取三者之中值所对应的记录作为基准，在划分开始前将该基准记录和该区伺的第1个记录进行交换，此后的划分过程与上面所给的Partition算法完全相同。

②取位于low和high之间的随机数k(low≤k≤high)，用R[k]作为基准
选取基准最好的方法是用一个随机函数产生一个取位于low和high之间的随机数k(low≤k≤high)，用R[k]作为基准，这相当于强迫R[low..high]中的记录是随机分布的。用此方法所得到的快速排序一般称为随机的快速排序。具体算法【参见教材】
注意：
随机化的快速排序与一般的快速排序算法差别很小。但随机化后，算法的性能大大地提高了，尤其是对初始有序的文件，一般不可能导致最坏情况的发生。算法的随机化不仅仅适用于快速排序，也适用于其它需要数据随机分布的算法。

（4）平均时间复杂度
尽管快速排序的最坏时间为O(n2)，但就平均性能而言，它是基于关键字比较的内部排序算法中速度最快者，快速排序亦因此而得名。它的平均时间复杂度为O(nlgn)。
（5）空间复杂度
快速排序在系统内部需要一个栈来实现递归。若每次划分较为均匀，则其递归树的高度为O(lgn)，故递归后需栈空间为O(lgn)。最坏情况下，递归树的高度为O(n)，所需的栈空间为O(n)。
（6）稳定性
快速排序是非稳定的，例如[2，2，1]。

随机日志

]]> http://anylinux.net/post/292.html/feed 2