Connect with us

0cs

非常经典的C语言趣味题目

在这个网站上发现一套很有趣的C语言测试题,如果你招聘C语言相关开发人员,或者正在学习C语言,很值得做一做

Published

on

http://stevenkobes.com/ctest.html

在这个网站上发现一套很有趣的C语言测试题,如果你招聘C语言相关开发人员,或者正在学习C语言,很值得做一做。

如果没有做,下面内容暂时不要看,最好自己先完成一遍。

OK,假设你做的答案没有完全正确,那你可以继续看下去了,否则,后面内容对你来说就是小菜一碟,不值得看。

第一题:

#include <setjmp.h>
static jmp_buf buf;
int main(void)
{
volatile int b = 3;
if (setjmp(buf) != 0)
{
printf(“%d\n”, b);
exit(0);
}
b = 5;
longjmp(buf, 1);
}

输出结果为A)3 B)5 C)0 D)都不是

答案为B,也就是输出5。

关键点在于理解setjmp以及longjmp,(http://en.wikipedia.org/wiki/Setjmp.h )第一次运行到setjmp,会设置jmp_buf,然后返回0。当调用longjmp时,会把longjmp里面的非0值作为setjmp的返回值返回(如果longjmp的value参数为0,setjmp恢复后返回1,也就是当恢复到setjmp存储点的时候,setjmp一定不会返回0)。

setjmp-longjmp组合的用处类似于游戏中的存盘读盘功能,经常被用于类似C++的异常恢复操作。

第二题:

struct node
{
int a; int b; int c;
};
struct node s = { 3, 5, 6 };
struct node *pt = &s;
printf(“%d\n”, *(int*)pt);
返回结果为3,这个算是比较简单,pt为指向结构s的指针,然后将pt转换为int指针,进行dereference,取出一个int值,那就是结构中第一个数。

我们将题目改动一下,如下代码

复制代码 代码如下:
struct node
{
char a; char b; short c; int d;
};
struct node s = { 3, 5, 6, 99 };
struct node *pt = &s;
printf(“%X\n”, *(int*)pt);

需要注意的是一般32位C编译器都认为char是8bit,short是16bit,int为32bit,所以node在内存中应该正好是对齐的,也就是abc这几个成员之间没有空隙。最终结果应该为60503,如果不是,欢迎你告诉我你具体的编译环境以及硬件配置。

第三题:

复制代码 代码如下:
int foo(int x, int n){
int val = 1;
if (n > 0)
{
if (n % 2 == 1) val *= x;
val *= foo(x * x, n / 2);
}
return val;
}

这道题其实最简单的办法就是在纸上做一个推演计算,一步一步跑一下,就能得到答案了,这里面没有任何复杂的C语言概念。

第四题:

复制代码 代码如下:
int a[5] = { 1, 2, 3, 4, 5 };
int *ptr = (int*)(&a + 1);
printf(“%d %d\n”, *(a + 1), *(ptr – 1));

这道题考的其实是指向数组的指针,&a是一个隐式的指向int [5]数组的指针,它和int* ptr是不一样的,如果真要定义这个指针,应该是int (*ptoa)[5]。所以ptoa每一次加一操作都相当于跨越int a[5]的内存步长(也就是5个int长度),也就是说&a + 1其实就是指向了a[5]这个位置,实际上内存里面这个位置是非法的,但是对ptr的强制转换导致了后面ptr-1的内存步长改为了1个int长度,所以ptr-1实际指向了a[4]。至于*(a+1)没什么好说的,值就是2。

第五题:

复制代码 代码如下:
void foo(int[][3]);
int main(void)
{
int a[3][3] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };
foo(a);
printf(“%d\n”, a[2][1]);
return 0;
}
void foo(int b[][3])
{
++b;
b[1][1] = 9;
}

其实和前一题有异曲同工之妙,++b的步长实际上是3个int,也就是++b运算以后,b指向{4,5,6}这个数组的开始,而b[1]就是{7,8,9}, b[1][1]实际上就是8这个值也就是main函数中的a[2][1].

第六题:

复制代码 代码如下:
int a, b, c, d;
a = 3;
b = 5;
c = a, b;
d = (a, b);
printf(“c=%d “, c);
printf(“d=%d\n”, d);

这个其实有两个C语言知识点,一个是等号操作符优先级高于逗号操作符,另一个是逗号操作符相当于运算逗号前半部后半部的表达式,然后返回后半部表达式的值。所以c等于a(先计算等号),而d等于b(逗号表达式返回b)。

第七题:

复制代码 代码如下:
int a[][3] = {1, 2, 3, 4, 5, 6};
int (*ptr)[3] = a;
printf(“%d %d “, (*ptr)[1], (*ptr)[2]);
++ptr;
printf(“%d %d\n”, (*ptr)[1], (*ptr)[2]);

依然是2维数组相关题目,ptr为指向int [3]数组的指针,首先指向a[0],所以(*ptr)[1], (*ptr)[2]就是a[0][1], a[0][2].然后++ptr,相当于ptr指向了a[1],这时得到的是a[1][1],a[1][2],所以结果就是2,3, 5, 6。

第八题:

复制代码 代码如下:
int *f1(void)
{
int x = 10; return &x;
}
int *f2(void)
{
int *ptr; *ptr = 10; return ptr;
}
int *f3(void)
{
int *ptr; ptr = malloc(sizeof *ptr); return ptr;
}

这里考的是返回一个指针的问题,一般来说返回指针的函数,里面一定有malloc之类的内存申请操作,传入指针类型,则是对指针指向的内容做修改。如果想修改指针本身,那就要传入指针的指针。

第九题:

复制代码 代码如下:
int i = 3; int j;
j = sizeof(++i + ++i);
printf(“i=%d j=%d\n”, i, j);

这道题考的内容其实就是sizeof,我在这篇文章里提到过http://sunxiunan.com/?p=1637 sizeof如果计算表达式,那么表达式是不会做计算的,也就是不管加加减减,sizeof就是针对i计算大小。在32位机器上,这个j应该为4。

我将代码扩展了一下,看看大家能不能想到结果:

复制代码 代码如下:
short m; int n; double dn;
int j = sizeof ( m + n);
int k = sizeof ( n + n);
int l = sizeof ( m);
int l2 = sizeof (m * m);
int l3 = sizeof (m + dn);
int l4 = sizeof (m + m);

第十题:

复制代码 代码如下:
void f1(int*, int);
void (*p[2])(int*, int);
int main(void)
{
int a = 3;
int b = 5;
p[0] = f1;
p[1] = f1;
p[0](&a, b);
printf(“%d %d “, a, b);
p[1](&a, b);
printf(“%d %d\n”, a, b);
return 0;
}
void f1(int *p, int q)
{
int tmp = *p; *p = q; q = tmp;
}

函数指针的数组p勉强算是一个知识点,另外一个知识点就是第八题提到的,对于int q这样的参数,是不会修改其内容的。而*p则可修改p指向的内容。

第十一题:

复制代码 代码如下:
void e(int);
int main(void)
{
int a = 3;
e(a);
putchar(‘\n’);
return 0;
}
void e(int n)
{
if (n > 0)
{
e(–n);
printf(“%d “, n);
e(–n);
}
}

这道题自己debug一下就完全明白了,主要知识点就是递归调用,另外前置后置自减操作的返回值问题。

第十二题:

复制代码 代码如下:
typedef int (*test)(float*, float*);
test tmp;

也是经常出现的一类题,对复杂的指针定义做解析,实际上K&R里面(5.12)也有介绍该如何解读。不熟悉的朋友可以试着练习练习标准库中的bsearch,qsort以及signal函数。

第十三题:

复制代码 代码如下:
char p;
char buf[10] = {1, 2, 3, 4, 5, 6, 9, 8};
p = (buf + 1)[5];
printf(“%d\n”, p);

这道题我在http://sunxiunan.com/?p=1637 也提到过相关知识点,也就是p实际指向*(buf + 1 + 5),写的更诡异一些就是p=5[buf +1];也是同样结果。

第十四题:

类似十三题,也是把数组弄得有些诡异,(p += sizeof(int))[-1];相当于*(p + sizeof(int) + (-1))。

第十五题:

复制代码 代码如下:
int ripple(int n, …)
{
int i, j, k;
va_list p;
k = 0;
j = 1;
va_start(p, n);
for (; j < n; ++j)
{
i = va_arg(p, int);
for (; i; i &= i – 1)
++k;
}
return k;
}
int main(void)
{
printf(“%d\n”, ripple(3, 5, 7));
return 0;
}

这道题也是两个知识点,一个是可变参数函数定义以及如何实现,va_arg会把5,7依次取出来。另一个知识点是i &= i-1,实际上是计算了i二进制形式中1的个数,每次计算都会消减掉最低有效位上的1。比如7二进制表示为111。i &= i –1的计算结果依次为110,100, 000 (也就是0)。在hacker’s Delights这本书里介绍了很多类似技巧。

第十六题:

复制代码 代码如下:
int counter(int i)
{
static int count = 0;
count = count + i;
return count;
}
int main(void)
{
int i, j;
for (i = 0; i <= 5; i++) j = counter(i);
printf(“%d\n”, j);
return 0;
}

只要了解静态局部变量的真正内涵,这道题就是小菜一碟碟碟碟碟碟。。。。。。

0cs

C#实现在底图上动态生成文字和图片

这篇文章主要为大家详细介绍了C#实现在底图上动态生成文字和图片,具有一定的参考价值,感兴趣的小伙伴们可以参考一下

Published

on

本文主要记录在图片上动态的生成需要添加的文字和把指定的图片加到底图上,直接上代码

/// <summary>
/// 在底图上画指定路径的图片
/// </summary>
/// <param name="g">画板实例</param>
/// <param name="path">图片路径</param>
/// <param name="totalWidth">画区总长度</param>
/// <param name="totalHeight">画区总高度</param>
/// <param name="px">起点X坐标</param>
/// <param name="py">起点Y坐标</param>
  private void FontPic(ref Graphics g, string path, int totalWidth, int totalHeight, int px, int py)
  {
   if (File.Exists(path))
   {
    var pImg = Image.FromFile(path);
    //如果图片大于画布区域,则缩小
    if (totalHeight < pImg.Height && totalWidth < pImg.Width)
    {
     Image newPic = GetReducedImage(pImg, totalWidth, totalHeight);
     if (newPic != null)
     {
      DrawPic(ref g, totalWidth, totalHeight, px, py, newPic);
     }
    }
    else if (totalHeight < pImg.Height && totalWidth >= pImg.Width)
    {
     Image newPic = GetReducedImage(pImg, pImg.Width, totalHeight);
     if (newPic != null)
     {
      DrawPic(ref g, totalWidth, totalHeight, px, py, newPic);
     }
    }
    else if (totalHeight >= pImg.Height && totalWidth < pImg.Width)
    {
     Image newPic = GetReducedImage(pImg, totalWidth, pImg.Height);
     if (newPic != null)
     {
      DrawPic(ref g, totalWidth, totalHeight, px, py, newPic);
     }
    }
    else
    {
     DrawPic(ref g, totalWidth, totalHeight, px, py, pImg);
    }
   }
  }
  /// <summary>
  /// 在图上画图片
  /// </summary>
  /// <param name="g">画板实例</param>
  /// <param name="totalWidth">画区总长度</param>
  /// <param name="totalHeight">画区总高度</param>
  /// <param name="px">起点X坐标</param>
  /// <param name="py">起点Y坐标</param>
  /// <param name="pImg">要画的图片实例</param>
  private void DrawPic(ref Graphics g, int totalWidth, int totalHeight, int px, int py, Image pImg)
  {
   px += GetValue(totalWidth, pImg.Width);
   py += GetValue(totalHeight, pImg.Height);
 
   g.DrawImage(new Bitmap(pImg, new Size(GetSize(totalWidth, pImg.Width), GetSize(totalHeight, pImg.Height))),
    new Rectangle(px, py, totalWidth, totalHeight),
    0, 0, totalWidth, totalHeight, GraphicsUnit.Pixel);
  }
  /// <summary> 
  /// 生成缩略图重载方法1,返回缩略图的Image对象 
  /// </summary> 
  /// <param name="width">缩略图的宽度</param> 
  /// <param name="height">缩略图的高度</param> 
  /// <returns>缩略图的Image对象</returns> 
  public Image GetReducedImage(Image resourceImage, int width, int height)
  {
   try
   {
    Image data = null;
    //用指定的大小和格式初始化Bitmap类的新实例 
    using (Bitmap bitmap = new Bitmap(width, height, PixelFormat.Format32bppArgb))
    {
     //从指定的Image对象创建新Graphics对象 
     using (Graphics graphics = Graphics.FromImage(bitmap))
     {
      //清除整个绘图面并以透明背景色填充 
      //graphics.Clear(Color.Transparent);
      //在指定位置并且按指定大小绘制原图片对象 
      graphics.DrawImage(resourceImage, new Rectangle(0, 0, width, height));
     }
     data = new Bitmap(bitmap);
    }
    return data;
   }
   catch (Exception e)
   {
    throw e;
   }
  }
  /// <summary>
  /// 比较两个值,得到给到给定值(判断是否越界)
  /// </summary>
  /// <param name="total">总长度</param>
  /// <param name="width">指定长度</param>
  /// <returns></returns>
  public int GetSize(int total, int width)
  {
   if (total > width)
   {
    return width;
   }
   else
   {
    return total;
   }
  }
  /// <summary>
  /// 更加传入的值计算得到新值(计算点坐标)
  /// </summary>
  /// <param name="total">总长度</param>
  /// <param name="width">指定长度</param>
  /// <returns></returns>
  private int GetValue(int total, int width)
  {
   return (total - width) / 2;
  }
  /// <summary>
  /// 在图片上画出文字
  /// </summary>
  /// <param name="g">图片对象</param>
  /// <param name="pointX">文字x坐标</param>
  /// <param name="pointY">文字y坐标</param>
  /// <param name="word">文字内容</param>
  /// <param name="textWidth">文本宽度</param>
  /// <param name="textHeight">文本高度</param>
  private static void DrawStringWord(Graphics g, int pointX, int pointY, string word, int textWidth, int textHeight, int fontSize = 30)
  {
   Font font = new Font("微软雅黑", fontSize, (FontStyle.Regular));
   RectangleF textArea = new RectangleF(pointX, pointY, textWidth, textHeight);
   Brush brush = new SolidBrush(Color.Black);
   g.DrawString(word, font, brush, textArea);
  }

希望对需要这方面操作的朋友有所帮助。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本小子。

Continue Reading

0cs

C#生成Word文件(图片、文字)

这篇文章主要为大家详细介绍了C#生成Word文件,包括图片、文字等素材,具有一定的参考价值,感兴趣的小伙伴们可以参考一下

Published

on

本文实例为大家分享了C#生成Word文件的具体代码,供大家参考,具体内容如下

通过Microsoft.Office.Interop.Word生成Word文档

1.引用类 WordReport.cs,代码如下:

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Office.Interop.Word;
using MSWord = Microsoft.Office.Interop.Word;
using System.Reflection;
using System.IO;
 
namespace CRM.Common
{
  public class WordReport
  {
    private _Application wordApp = null;
    private _Document wordDoc = null;
    object unite = MSWord.WdUnits.wdStory;
    Object Nothing = Missing.Value;
    public _Application Application
    {
      get
      {
        return wordApp;
      }
      set
      {
        wordApp = value;
      }
    }
    public _Document Document
    {
      get
      {
        return wordDoc;
      }
      set
      {
        wordDoc = value;
      }
    }
 
    // 通过模板创建新文档
    public void CreateNewDocument(string filePath)
    {
      try
      {
        killWinWordProcess();
        wordApp = new ApplicationClass();
        wordApp.DisplayAlerts = WdAlertLevel.wdAlertsNone;
        wordApp.Visible = false;
        object missing = System.Reflection.Missing.Value;
        object templateName = filePath;
        wordDoc = wordApp.Documents.Open(ref templateName, ref missing,
          ref missing, ref missing, ref missing, ref missing, ref missing,
          ref missing, ref missing, ref missing, ref missing, ref missing,
          ref missing, ref missing, ref missing, ref missing);
      }
      catch (Exception ex)
      {
        
      }
    }
    public void CreateNewDocument()
    {
      try
      {
        //killWinWordProcess();
        wordApp = new ApplicationClass();
        wordApp.DisplayAlerts = WdAlertLevel.wdAlertsNone;
        wordApp.Visible = false;
        Object Nothing = Missing.Value;
        wordDoc = wordApp.Documents.Add(ref Nothing, ref Nothing, ref Nothing, ref Nothing);
      }
      catch (Exception ex)
      {
        
      }
    }
    // 保存新文件
    public void SaveDocument(string filePath)
    {
      if (File.Exists((string)filePath))
      {
        File.Delete((string)filePath);
      }
      object fileName = filePath;
      object format = WdSaveFormat.wdFormatDocument;//保存格式
      object miss = System.Reflection.Missing.Value;
      wordDoc.SaveAs(ref fileName, ref format, ref miss,
        ref miss, ref miss, ref miss, ref miss,
        ref miss, ref miss, ref miss, ref miss,
        ref miss, ref miss, ref miss, ref miss,
        ref miss);
      //关闭wordDoc,wordApp对象
      object SaveChanges = WdSaveOptions.wdSaveChanges;
      object OriginalFormat = WdOriginalFormat.wdOriginalDocumentFormat;
      object RouteDocument = false;
      wordDoc.Close(ref SaveChanges, ref OriginalFormat, ref RouteDocument);
      wordApp.Quit(ref SaveChanges, ref OriginalFormat, ref RouteDocument);
    }
    public void InsertText(string strContent)
    {
      //写入普通文本
      wordDoc.Content.InsertAfter(strContent);
      wordApp.Selection.EndKey(ref unite, ref Nothing); //将光标移动到文档末尾
 
      
    }
    public void InsertTitle(string strContent)
    {
      //写入普通文本
      wordApp.Selection.EndKey(ref unite, ref Nothing); //将光标移动到文档末尾
 
      try
      {
        wordDoc.Paragraphs.Last.Range.set_Style("标题 5");
      }
      catch (Exception ex)
      {
        wordDoc.Paragraphs.Last.Range.set_Style("Heading 5");
      }
      wordDoc.Paragraphs.Last.Range.Font.Color = MSWord.WdColor.wdColorBlack;
      wordDoc.Paragraphs.Last.Range.Font.Size = 11;
      wordDoc.Paragraphs.Last.Range.Font.Name = "宋体";
      wordDoc.Paragraphs.Last.Range.Text = strContent;
      wordApp.Selection.EndKey(ref unite, ref Nothing); //将光标移动到文档末尾
      try
      {
        wordDoc.Paragraphs.Last.Range.set_Style("Normal");
      }
      catch (Exception ex)
      {
        wordDoc.Paragraphs.Last.Range.set_Style("正文");
      }
 
 
    }
    // 在书签处插入值
    public bool InsertValue(string bookmark, string value)
    {
      object bkObj = bookmark;
      if (wordApp.ActiveDocument.Bookmarks.Exists(bookmark))
      {
        wordApp.ActiveDocument.Bookmarks.get_Item(ref bkObj).Select();
        wordApp.Selection.TypeText(value);
        return true;
      }
      return false;
    }
 
    // 插入表格,bookmark书签
    public Table InsertTable(string bookmark, int rows, int columns, float width)
    {
      object miss = System.Reflection.Missing.Value;
      object oStart = bookmark;
      Range range = wordDoc.Bookmarks.get_Item(ref oStart).Range;//表格插入位置
      Table newTable = wordDoc.Tables.Add(range, rows, columns, ref miss, ref miss);
      //设置表的格式
      newTable.Borders.Enable = 1; //允许有边框,默认没有边框(为0时报错,1为实线边框,2、3为虚线边框,以后的数字没试过)
      newTable.Borders.OutsideLineWidth = WdLineWidth.wdLineWidth050pt;//边框宽度
      if (width != 0)
      {
        newTable.PreferredWidth = width;//表格宽度
      }
      newTable.AllowPageBreaks = false;
      return newTable;
    }
 
 
    // 合并单元格 表id,开始行号,开始列号,结束行号,结束列号
    public void MergeCell(int n, int row1, int column1, int row2, int column2)
    {
      wordDoc.Content.Tables[n].Cell(row1, column1).Merge(wordDoc.Content.Tables[n].Cell(row2, column2));
    }
 
    // 合并单元格 表名,开始行号,开始列号,结束行号,结束列号
    public void MergeCell(Microsoft.Office.Interop.Word.Table table, int row1, int column1, int row2, int column2)
    {
      table.Cell(row1, column1).Merge(table.Cell(row2, column2));
    }
 
    // 设置表格内容对齐方式 Align水平方向,Vertical垂直方向(左对齐,居中对齐,右对齐分别对应Align和Vertical的值为-1,0,1)Microsoft.Office.Interop.Word.Table table
    public void SetParagraph_Table(int n, int Align, int Vertical)
    {
      switch (Align)
      {
        case -1: wordDoc.Content.Tables[n].Range.ParagraphFormat.Alignment = WdParagraphAlignment.wdAlignParagraphLeft; break;//左对齐
        case 0: wordDoc.Content.Tables[n].Range.ParagraphFormat.Alignment = WdParagraphAlignment.wdAlignParagraphCenter; break;//水平居中
        case 1: wordDoc.Content.Tables[n].Range.ParagraphFormat.Alignment = WdParagraphAlignment.wdAlignParagraphRight; break;//右对齐
      }
      switch (Vertical)
      {
        case -1: wordDoc.Content.Tables[n].Range.Cells.VerticalAlignment = WdCellVerticalAlignment.wdCellAlignVerticalTop; break;//顶端对齐
        case 0: wordDoc.Content.Tables[n].Range.Cells.VerticalAlignment = WdCellVerticalAlignment.wdCellAlignVerticalCenter; break;//垂直居中
        case 1: wordDoc.Content.Tables[n].Range.Cells.VerticalAlignment = WdCellVerticalAlignment.wdCellAlignVerticalBottom; break;//底端对齐
      }
    }
 
    // 设置单元格内容对齐方式
    public void SetParagraph_Table(int n, int row, int column, int Align, int Vertical)
    {
      switch (Align)
      {
        case -1: wordDoc.Content.Tables[n].Cell(row, column).Range.ParagraphFormat.Alignment = WdParagraphAlignment.wdAlignParagraphLeft; break;//左对齐
        case 0: wordDoc.Content.Tables[n].Cell(row, column).Range.ParagraphFormat.Alignment = WdParagraphAlignment.wdAlignParagraphCenter; break;//水平居中
        case 1: wordDoc.Content.Tables[n].Cell(row, column).Range.ParagraphFormat.Alignment = WdParagraphAlignment.wdAlignParagraphRight; break;//右对齐
      }
      switch (Vertical)
      {
        case -1: wordDoc.Content.Tables[n].Cell(row, column).Range.Cells.VerticalAlignment = WdCellVerticalAlignment.wdCellAlignVerticalTop; break;//顶端对齐
        case 0: wordDoc.Content.Tables[n].Cell(row, column).Range.Cells.VerticalAlignment = WdCellVerticalAlignment.wdCellAlignVerticalCenter; break;//垂直居中
        case 1: wordDoc.Content.Tables[n].Cell(row, column).Range.Cells.VerticalAlignment = WdCellVerticalAlignment.wdCellAlignVerticalBottom; break;//底端对齐
      }
 
    }
 
 
    // 设置表格字体
    public void SetFont_Table(Microsoft.Office.Interop.Word.Table table, string fontName, double size)
    {
      if (size != 0)
      {
        table.Range.Font.Size = Convert.ToSingle(size);
      }
      if (fontName != "")
      {
        table.Range.Font.Name = fontName;
      }
    }
 
    // 设置单元格字体
    public void SetFont_Table(int n, int row, int column, string fontName, double size, int bold)
    {
      if (size != 0)
      {
        wordDoc.Content.Tables[n].Cell(row, column).Range.Font.Size = Convert.ToSingle(size);
      }
      if (fontName != "")
      {
        wordDoc.Content.Tables[n].Cell(row, column).Range.Font.Name = fontName;
      }
      wordDoc.Content.Tables[n].Cell(row, column).Range.Font.Bold = bold;// 0 表示不是粗体,其他值都是
    }
 
    // 是否使用边框,n表格的序号,use是或否
    // 该处边框参数可以用int代替bool可以让方法更全面
    // 具体值方法中介绍
    public void UseBorder(int n, bool use)
    {
      if (use)
      {
        wordDoc.Content.Tables[n].Borders.Enable = 1;
        //允许有边框,默认没有边框(为0时无边框,1为实线边框,2、3为虚线边框,以后的数字没试过)
      }
      else
      {
        wordDoc.Content.Tables[n].Borders.Enable = 0;
      }
    }
 
    // 给表格插入一行,n表格的序号从1开始记
    public void AddRow(int n)
    {
      object miss = System.Reflection.Missing.Value;
      wordDoc.Content.Tables[n].Rows.Add(ref miss);
    }
 
    // 给表格添加一行
    public void AddRow(Microsoft.Office.Interop.Word.Table table)
    {
      object miss = System.Reflection.Missing.Value;
      table.Rows.Add(ref miss);
    }
 
    // 给表格插入rows行,n为表格的序号
    public void AddRow(int n, int rows)
    {
      object miss = System.Reflection.Missing.Value;
      Microsoft.Office.Interop.Word.Table table = wordDoc.Content.Tables[n];
      for (int i = 0; i < rows; i++)
      {
        table.Rows.Add(ref miss);
      }
    }
 
    // 删除表格第rows行,n为表格的序号
    public void DeleteRow(int n, int row)
    {
      Microsoft.Office.Interop.Word.Table table = wordDoc.Content.Tables[n];
      table.Rows[row].Delete();
    }
 
    // 给表格中单元格插入元素,table所在表格,row行号,column列号,value插入的元素
    public void InsertCell(Microsoft.Office.Interop.Word.Table table, int row, int column, string value)
    {
      table.Cell(row, column).Range.Text = value;
    }
 
    // 给表格中单元格插入元素,n表格的序号从1开始记,row行号,column列号,value插入的元素
    public void InsertCell(int n, int row, int column, string value)
    {
      wordDoc.Content.Tables[n].Cell(row, column).Range.Text = value;
    }
 
    // 给表格插入一行数据,n为表格的序号,row行号,columns列数,values插入的值
    public void InsertCell(int n, int row, int columns, string[] values)
    {
      Microsoft.Office.Interop.Word.Table table = wordDoc.Content.Tables[n];
      for (int i = 0; i < columns; i++)
      {
        table.Cell(row, i + 1).Range.Text = values[i];
      }
    }
 
    // 插入图片
    public void InsertPicture(string bookmark, string picturePath, float width, float hight)
    {
      object miss = System.Reflection.Missing.Value;
      object oStart = bookmark;
      Object linkToFile = false;    //图片是否为外部链接
      Object saveWithDocument = true; //图片是否随文档一起保存 
      object range = wordDoc.Bookmarks.get_Item(ref oStart).Range;//图片插入位置
      wordDoc.InlineShapes.AddPicture(picturePath, ref linkToFile, ref saveWithDocument, ref range);
      wordDoc.Application.ActiveDocument.InlineShapes[1].Width = width;  //设置图片宽度
      wordDoc.Application.ActiveDocument.InlineShapes[1].Height = hight; //设置图片高度
    }
    public void InsertPicture(string picturePath, float width, float hight,WdParagraphAlignment align)
    {
      object unite = MSWord.WdUnits.wdStory;
      Object Nothing = Missing.Value;
      Application.Selection.EndKey(ref unite, ref Nothing); //将光标移动到文档末尾
      //要向Word文档中插入图片的位置
      Object range = wordDoc.Paragraphs.Last.Range;
      //定义该插入的图片是否为外部链接
      Object linkToFile = false;        //默认,这里貌似设置为bool类型更清晰一些
      //定义要插入的图片是否随Word文档一起保存
      Object saveWithDocument = true;       //默认
      //使用InlineShapes.AddPicture方法(【即“嵌入型”】)插入图片
      InlineShape shape = wordDoc.InlineShapes.AddPicture(picturePath, ref linkToFile, ref saveWithDocument, ref range);
      wordApp.Selection.ParagraphFormat.Alignment = align;//
      
      //设置图片宽高的绝对大小
      if (width!=-1)
        wordDoc.InlineShapes[1].Width = width;
      if(hight!=-1)
        wordDoc.InlineShapes[1].Height = hight;
      try
      {
        wordDoc.Paragraphs.Last.Range.set_Style("正文");
      }
      catch(Exception ex)
      {
        wordDoc.Paragraphs.Last.Range.set_Style("Normal");
      }   
      shape.Borders.Enable = 12;
    
      //shape.ConvertToShape().WrapFormat.Type = MSWord.WdWrapType.wdWrapSquare;//四周环绕的方式
    }
 
    // 插入一段文字,text为文字内容
    public void InsertText(string bookmark, string text)
    {
      object oStart = bookmark;
      object range = wordDoc.Bookmarks.get_Item(ref oStart).Range;
      Paragraph wp = wordDoc.Content.Paragraphs.Add(ref range);
      wp.Format.SpaceBefore = 6;
      wp.Range.Text = text;
      wp.Format.SpaceAfter = 24;
      wp.Range.InsertParagraphAfter();
      wordDoc.Paragraphs.Last.Range.Text = "\n";
    }
 
    // 杀掉winword.exe进程
    public void killWinWordProcess()
    {
      System.Diagnostics.Process[] processes = System.Diagnostics.Process.GetProcessesByName("WINWORD");
      foreach (System.Diagnostics.Process process in processes)
      {
        bool b = process.MainWindowTitle == "";
        if (process.MainWindowTitle == "")
        {
          process.Kill();
        }
      }
    }
 
 
 
    internal void InsertTable(int tableRow, int tableColumn,List<string> imagePaths)
    {
      wordApp.Selection.EndKey(ref unite, ref Nothing); //将光标移动到文档末尾
      MSWord.Table table = wordDoc.Tables.Add(wordApp.Selection.Range,
                          tableRow, tableColumn, ref Nothing, ref Nothing);
 
      //默认创建的表格没有边框,这里修改其属性,使得创建的表格带有边框 
      table.Borders.Enable = 0;//这个值可以设置得很大,例如5、13等等
 
      //表格的索引是从1开始的。
      for (int i = 1; i <= tableRow; i++)
      {
        for (int j = 1; j <= tableColumn; j++)
        {
          
          int index = (i-1) * tableColumn + j-1;
          if (index < imagePaths.Count)//有文件
          {
            string FileName = imagePaths[index]; //图片所在路径
            object LinkToFile = false;
            object SaveWithDocument = true;
            object Anchor = table.Cell(i, j).Range;//选中要添加图片的单元格
            MSWord.InlineShape il = wordDoc.Application.ActiveDocument.InlineShapes.AddPicture(FileName, ref LinkToFile, ref SaveWithDocument, ref Anchor);
 
            //图片大小
            il.Width = 100;//图片宽度
            il.Height = 100;//图片高度
            table.Rows[i].Cells[j].Split(2, 1);
            table.Cell(i+1, j).Range.Text = "图片名称:"+(index+1).ToString(); //
            table.Cell(i+1, j).Merge(table.Cell(i, j));//纵向合并
          }
        }
      }
      //设置table样式
      table.Rows.HeightRule = MSWord.WdRowHeightRule.wdRowHeightAtLeast;//高度规则是:行高有最低值下限?
      table.Rows.Height = wordApp.CentimetersToPoints(float.Parse("0.8"));// 
 
      table.Range.Font.Size = 10.5F;
      table.Range.Font.Bold = 0;
 
      table.Range.ParagraphFormat.Alignment = MSWord.WdParagraphAlignment.wdAlignParagraphCenter;//表格文本居中
      table.Range.Cells.VerticalAlignment = MSWord.WdCellVerticalAlignment.wdCellAlignVerticalBottom;//文本垂直贴到底部
      //设置table边框样式
      table.Borders.OutsideLineStyle = MSWord.WdLineStyle.wdLineStyleNone;//表格外框是双线
      table.Borders.InsideLineStyle = MSWord.WdLineStyle.wdLineStyleNone;//表格内框是单线
 
      table.Rows[1].Range.Font.Bold = 1;//加粗
      table.Rows[1].Range.Font.Size = 12F;
      table.Cell(1, 1).Range.Font.Size = 10.5F;
    }
  }
}

2.生成Word文档

/// <summary>
/// 
/// </summary>
/// <param name="path">like string path=@"c:\\temp\\"</param>
public void GengerateWord(string path)
    {
      string fileName = "test.doc";
      WordReport report = new WordReport();
      report.CreateNewDocument(); //创建文件
      report.InsertTitle("标题");
      float width = 420;//图片宽度
      float height = 200;//图片高度
      report.InsertPicture("图片地址", width, height, WdParagraphAlignment.wdAlignParagraphCenter);
      report.SaveDocument(path+ fileName);
}


 以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本小子。

Continue Reading

0cs

C/C++实现双路快速排序算法原理

这篇文章主要为大家详细介绍了C/C++实现双路快速排序算法原理,具有一定的参考价值,感兴趣的小伙伴们可以参考一下

Published

on

本文实例为大家分享了C/C++实现双路快速排序算法的具体代码,供大家参考,具体内容如下

看了刘宇波的视频,讲双路快速排序的,原理讲的很直观,程序讲解也一看就懂。这里写一下自己的理解过程,也加深一下自己的理解。

首先说一下为什么需要双路排序,在有些带有许多重复数据的数组里,使用随机快速排序或者最简单的快速排序算法时,由于重复的数据会放在原来的索引位置不动,就回导致划分数组时划分的某一部分太长,起不到分段排序的效果,这样就导致算法退化成O(n^2)的复杂度。就像下图:

为了解决这个问题,双路快速排序采用的方法是对等于v的数也进行交换,原理如下所述:

首先选择一个数作为标志,放在数组的最左侧,下标为l,在数组左边放小于v的数,右侧放大于v的数。
之后,先从l+1开始遍历数组,当数据小于v时,该数据属于左侧橙色部分,保持其位置不动,i++,继续向后遍历,当找到某个数大于或者等于(注意,这里等于很重要)v时,停止遍历。转而开始根据j来遍历数组,j不断减小,索引数组的数据,当索引到某个数小于或者等于v时,停止遍历。如下图所示:

这时两个绿色的区域就是分别属于<v和>v的部分,而i,j所对应的索引数据要交换位置。

之后,将i,j分别向后向前移动一位,继续开始新的索引,直到i和j重合或者i>j位置,就完成了partition的过程。

下面贴出代码:

主函数 main.cpp

// QuickSort2.cpp : 双路快速排序,适用于解决有很多重复数据的数组。
//

#include "stdafx.h"
#include "E:/学习/C++/数据结构和算法/code/算法/排序算法/common/sortTestHelper.h"
#include "QuickSort.h"
#include "RadomQuickSort.h"
#include "QuickSort2.h"

using namespace std;

int main()
{
 int n = 100000;
 int *arr1 = SortTestHelper::generateRadomArray(n, 0, 50);
 int *arr2 = SortTestHelper::generateRadomArray(n, 0, 50);
 int *arr3 = SortTestHelper::generateRadomArray(n, 0,50);
 SortTestHelper::sortTime("随机快速排序", RadomQuickSort, arr1, n);
 SortTestHelper::sortTime("快速排序", QuickSort, arr2, n);
 SortTestHelper::sortTime("双路快速排序", QuickSort2, arr3, n);
 delete[] arr1;
 delete[] arr2;
 delete[] arr3;
 return 0;
}

双路快速排序算法 QuickSort2.h

#ifndef QUICKSORT2_H
#define QUICKSORT2_H

#include <stdlib.h>
#include <iostream>
using namespace std;

template <typename T>
int __partition3(T *arr, int l, int r)
{
//此处结合随机快速排序的算法进行了优化,标记点在数组里随机选择
 int RAND = (rand() % (r - l + 1) + l);
 swap(arr[RAND], arr[l]);

 int v = arr[l];
 int i = l + 1;
 int j = r;
 while (true)
 {
 while (i <= r&&arr[i] < v) i++;
 while (j >= l + 1 && arr[j] > v) j--;
 if (i > j)
 {
 break;
 }
 swap(arr[i], arr[j]);
 i++;
 j--;
 }
 swap(arr[l], arr[j]);
 return j;
}

template <typename T>
void __QuickSort2(T *arr,int l,int r)
{
 if (l>=r)
 {
 return;
 }
 int p = __partition3(arr, l, r);
 __QuickSort2(arr, l, p - 1);
 __QuickSort2(arr, p + 1, r);
}

template <typename T>
void QuickSort2(T *arr, int n)
{
 __QuickSort2(arr, 0,n-1);
}


#endif

随机快速排序 RadomQuickSort.h

#ifndef RADOMQUICKSORT_H
#define RADOMQUICKSORT_H

#include <iostream>
#include <stdlib.h>

using namespace std;

template <typename T>
int __Randpartition(T *arr, int l, int r)
{
 //选择开头的数作为分割的数
 int RAND = arr[rand() % (r - l + 1) + l];
 swap(arr[l], RAND);
 int i = arr[l];
 //遍历数组,使得arr[l,l+1,...j]<arr[l],arr[j+1,...,k)>arr[l]
 int j = l;
 //如果当前数据大于arr[l],就无需改变位置,如果小于arr[l],就将当前数据与分割点的数据后一个数据交换
 for (size_t k = j + 1; k <= r; k++)
 {
 if (arr[k]<i)
 {
 swap(arr[j + 1], arr[k]);
 j++;
 }
 }
 //最后一步,要记得将arr[l]和找到的分割点数据交换
 swap(arr[l], arr[j]);
 return j;
}

template <typename T>
void __RadomQuickSort(T *arr, int l, int r)
{
 if (l >= r)
 {
 return;
 }
 int p = __Randpartition(arr, l, r);
 __RadomQuickSort(arr, l, p - 1);
 __RadomQuickSort(arr, p + 1, r);
}

template <typename T>
void RadomQuickSort(T *arr, int n)
{
 __RadomQuickSort(arr, 0, n - 1);
}

#endif

快速排序 QuickSort.h

#ifndef QUICKSORT_H
#define QUICKSORT_H

using namespace std;

template <typename T>
int __partition(T *arr, int l, int r)
{
 //选择开头的数作为分割的数
 int i = arr[l];
 //遍历数组,使得arr[l,l+1,...j]<arr[l],arr[j+1,...,k)>arr[l]
 int j = l;
 //如果当前数据大于arr[l],就无需改变位置,如果小于arr[l],就将当前数据与分割点的数据后一个数据交换
 for (size_t k = j + 1; k <= r; k++)
 {
 if (arr[k]<i)
 {
 swap(arr[j + 1], arr[k]);
 j++;
 }
 }
 //最后一步,要记得将arr[l]和找到的分割点数据交换
 swap(arr[l], arr[j]);
 return j;
}

template <typename T>
void __QuickSort(T *arr, int l, int r)
{
 if (l >= r)
 {
 return;
 }
 int p = __partition(arr, l, r);
 __QuickSort(arr, l, p - 1);
 __QuickSort(arr, p + 1, r);
}

template <typename T>
void QuickSort(T *arr, int n)
{
 __QuickSort(arr, 0, n - 1);
}

#endif

SortTestHelper 函数

#ifndef SORTTESTHELPER_H
#define SORTTESTHELPER_H

#include <iostream>
#include <cassert>
#include <ctime>
#include <string>

using namespace std;

namespace SortTestHelper 
{
//产生一个从[rangeL,rangeH]的随机数组,数组个数是n
 int* generateRadomArray(int n,int rangeL,int rangeH)
 {
 //为了算法的健壮性,需要判断错误输入
 assert(rangeL < rangeH);
 int* arr = new int[n];
 //时间为种子的随机数
 srand((unsigned)time(NULL));
 for (int i = 0;i < n;i++)
 {
 //生成rangeL到rangeH之间的随机数的算法
 arr[i] = rand() % (rangeH - rangeL + 1) + rangeL;
 }
 return arr;
 }

//产生近乎有序的随机数
 int *generateNearlyOrderedArray(int n, int swapnum)
 {
 int *arr = new int[n];
 srand((unsigned)time(NULL));
 for (size_t i = 0; i < n; i++)
 {
 arr[i] = i;
 }
 for (size_t i = 0; i < swapnum; i++)
 {
 int x = rand() % n;
 int y = rand() % n;
 swap(arr[x], arr[y]);
 }
 return arr;
 }

//打印数组:输入数组,数组元素的个数
 template<typename T>
 void printArr(T *arr,int n)
 {
 for (size_t i = 0; i < n; i++)
 {
 std::cout << arr[i] << " ";
 }
 std::cout << std::endl;
 }

//判断是否已经排序
 template<typename T>
 bool ifSort(T *arr,int n)
 {
 for (size_t i = 0; i < n-1; i++)
 {
 if (arr[i]>arr[i+1])
 {
 return false;
 }
 }
 return true;
 }

//计算程序运行时间
 template<typename T>
 //函数输入参数是:所需要计算的运行的函数的名称,函数的指针,函数的输入数组,输入数组的个数
 void sortTime(string funName,void(*sort)(T*arr, int), T* arr,int n)
 {
 clock_t startime = clock();
 sort(arr,n);
 clock_t endtime = clock();

 assert(ifSort(arr, n));
 std::cout <<funName<<"的运行时间:" << double(endtime-startime) / CLOCKS_PER_SEC <<"s"<< std::endl;
 }

//拷贝随机生成的数组:输入要拷贝的数组指针(整型),输入需要拷贝多少个数
 int* copyarr(int* a, int n)
 {
 int *arr = new int[n];
 copy(a,a+n, arr);
 return arr;
 }
}
#endif

最终结果三种算法对10万个具有重复的数据的排序时间如下:

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本小子。

Continue Reading

趋势

Copyright © 2017 Zox News Theme. Theme by MVP Themes, powered by WordPress.