carray源码（c++ carray）
本文目录一览：
- 1、各位高手谁给我写一个数据结构（C语言版）源代码的主函数，子函数我自己加，或者写一个子函数举个例子！
- 2、c库函数源码
- 3、C语言如何编写旋转矩阵源代码
- 4、C语言，求解，谁能给一个完整的源代码
- 5、c语言一段代码看不懂
各位高手谁给我写一个数据结构（C语言版）源代码的主函数，子函数我自己加，或者写一个子函数举个例子！
//对10个数按照相反顺序排列
void inverted(int *po,int n)
{
int *i,*j,temp,m;
m=(n-1)/2;
j=po;i=po+n-1;
for(;j=po+m;j++,i--)
{
temp=*j;*j=*i;*i=temp;
}
}
main()
{
int i,array[10]={3,7,9,11,0,6,7,5,4,2},*p=array;
printf("对10个数按照相反顺序排列...\n\n");
printf("The original array:\n");
for(i=0;i10;i++)
printf("%d,",*p++);
printf("\n");
p=array;
inverted(p,10);
printf("The array has been inverted:\n");
for(i=0;i10;i++)
printf("%d,",*p++);
printf("\n");
system("pause");
}
c库函数源码
不是你表达不清，也许只是你根本不想仔细看一睛VC下面目录的源码，事实上就是有的。后附其中的qsort.c，以证明所言不虚。
VC的库是提供源码的，这东西也不值钱。
X:\Program Files\Microsoft Visual Studio\VCXX\CRT\SRC
注意有些可能本身是用汇编写的。
/***
*qsort.c - quicksort algorithm; qsort() library function for sorting arrays
*
* Copyright (c) 1985-1997, Microsoft Corporation. All rights reserved.
*
*Purpose:
* To implement the qsort() routine for sorting arrays.
*
*******************************************************************************/
#include cruntime.h
#include stdlib.h
#include search.h
/* prototypes for local routines */
static void __cdecl shortsort(char *lo, char *hi, unsigned width,
int (__cdecl *comp)(const void *, const void *));
static void __cdecl swap(char *p, char *q, unsigned int width);
/* this parameter defines the cutoff between using quick sort and
insertion sort for arrays; arrays with lengths shorter or equal to the
below value use insertion sort */
#define CUTOFF 8 /* testing shows that this is good value */
/***
*qsort(base, num, wid, comp) - quicksort function for sorting arrays
*
*Purpose:
* quicksort the array of elements
* side effects: sorts in place
*
*Entry:
* char *base = pointer to base of array
* unsigned num = number of elements in the array
* unsigned width = width in bytes of each array element
* int (*comp)() = pointer to function returning analog of strcmp for
* strings, but supplied by user for comparing the array elements.
* it accepts 2 pointers to elements and returns neg if 12, 0 if
* 1=2, pos if 12.
*
*Exit:
* returns void
*
*Exceptions:
*
*******************************************************************************/
/* sort the array between lo and hi (inclusive) */
void __cdecl qsort (
void *base,
unsigned num,
unsigned width,
int (__cdecl *comp)(const void *, const void *)
)
{
char *lo, *hi; /* ends of sub-array currently sorting */
char *mid; /* points to middle of subarray */
char *loguy, *higuy; /* traveling pointers for partition step */
unsigned size; /* size of the sub-array */
char *lostk[30], *histk[30];
int stkptr; /* stack for saving sub-array to be processed */
/* Note: the number of stack entries required is no more than
1 + log2(size), so 30 is sufficient for any array */
if (num 2 || width == 0)
return; /* nothing to do */
stkptr = 0; /* initialize stack */
lo = base;
hi = (char *)base + width * (num-1); /* initialize limits */
/* this entry point is for pseudo-recursion calling: setting
lo and hi and jumping to here is like recursion, but stkptr is
prserved, locals aren't, so we preserve stuff on the stack */
recurse:
size = (hi - lo) / width + 1; /* number of el's to sort */
/* below a certain size, it is faster to use a O(n^2) sorting method */
if (size = CUTOFF) {
shortsort(lo, hi, width, comp);
}
else {
/* First we pick a partititioning element. The efficiency of the
algorithm demands that we find one that is approximately the
median of the values, but also that we select one fast. Using
the first one produces bad performace if the array is already
sorted, so we use the middle one, which would require a very
wierdly arranged array for worst case performance. Testing shows
that a median-of-three algorithm does not, in general, increase
performance. */
mid = lo + (size / 2) * width; /* find middle element */
swap(mid, lo, width); /* swap it to beginning of array */
/* We now wish to partition the array into three pieces, one
consisiting of elements = partition element, one of elements
equal to the parition element, and one of element = to it. This
is done below; comments indicate conditions established at every
step. */
loguy = lo;
higuy = hi + width;
/* Note that higuy decreases and loguy increases on every iteration,
so loop must terminate. */
for (;;) {
/* lo = loguy hi, lo higuy = hi + 1,
A[i] = A[lo] for lo = i = loguy,
A[i] = A[lo] for higuy = i = hi */
do {
loguy += width;
} while (loguy = hi comp(loguy, lo) = 0);
/* lo loguy = hi+1, A[i] = A[lo] for lo = i loguy,
either loguy hi or A[loguy] A[lo] */
do {
higuy -= width;
} while (higuy lo comp(higuy, lo) = 0);
/* lo-1 = higuy = hi, A[i] = A[lo] for higuy i = hi,
either higuy = lo or A[higuy] A[lo] */
if (higuy loguy)
break;
/* if loguy hi or higuy = lo, then we would have exited, so
A[loguy] A[lo], A[higuy] A[lo],
loguy hi, highy lo */
swap(loguy, higuy, width);
/* A[loguy] A[lo], A[higuy] A[lo]; so condition at top
of loop is re-established */
}
/* A[i] = A[lo] for higuy i = hi,
A[i] = A[lo] for lo = i loguy,
higuy loguy, lo = higuy = hi
implying:
A[i] = A[lo] for loguy = i = hi,
A[i] = A[lo] for lo = i = higuy,
A[i] = A[lo] for higuy i loguy */
swap(lo, higuy, width); /* put partition element in place */
/* OK, now we have the following:
A[i] = A[higuy] for loguy = i = hi,
A[i] = A[higuy] for lo = i higuy
A[i] = A[lo] for higuy = i loguy */
/* We've finished the partition, now we want to sort the subarrays
[lo, higuy-1] and [loguy, hi].
We do the smaller one first to minimize stack usage.
We only sort arrays of length 2 or more.*/
if ( higuy - 1 - lo = hi - loguy ) {
if (lo + width higuy) {
lostk[stkptr] = lo;
histk[stkptr] = higuy - width;
++stkptr;
} /* save big recursion for later */
if (loguy hi) {
lo = loguy;
goto recurse; /* do small recursion */
}
}
else {
if (loguy hi) {
lostk[stkptr] = loguy;
histk[stkptr] = hi;
++stkptr; /* save big recursion for later */
}
if (lo + width higuy) {
hi = higuy - width;
goto recurse; /* do small recursion */
}
}
}
/* We have sorted the array, except for any pending sorts on the stack.
Check if there are any, and do them. */
--stkptr;
if (stkptr = 0) {
lo = lostk[stkptr];
hi = histk[stkptr];
goto recurse; /* pop subarray from stack */
}
else
return; /* all subarrays done */
}
/***
*shortsort(hi, lo, width, comp) - insertion sort for sorting short arrays
*
*Purpose:
* sorts the sub-array of elements between lo and hi (inclusive)
* side effects: sorts in place
* assumes that lo hi
*
*Entry:
* char *lo = pointer to low element to sort
* char *hi = pointer to high element to sort
* unsigned width = width in bytes of each array element
* int (*comp)() = pointer to function returning analog of strcmp for
* strings, but supplied by user for comparing the array elements.
* it accepts 2 pointers to elements and returns neg if 12, 0 if
* 1=2, pos if 12.
*
*Exit:
* returns void
*
*Exceptions:
*
*******************************************************************************/
static void __cdecl shortsort (
char *lo,
char *hi,
unsigned width,
int (__cdecl *comp)(const void *, const void *)
)
{
char *p, *max;
/* Note: in assertions below, i and j are alway inside original bound of
array to sort. */
while (hi lo) {
/* A[i] = A[j] for i = j, j hi */
max = lo;
for (p = lo+width; p = hi; p += width) {
/* A[i] = A[max] for lo = i p */
if (comp(p, max) 0) {
max = p;
}
/* A[i] = A[max] for lo = i = p */
}
/* A[i] = A[max] for lo = i = hi */
swap(max, hi, width);
/* A[i] = A[hi] for i = hi, so A[i] = A[j] for i = j, j = hi */
hi -= width;
/* A[i] = A[j] for i = j, j hi, loop top condition established */
}
/* A[i] = A[j] for i = j, j lo, which implies A[i] = A[j] for i j,
so array is sorted */
}
/***
*swap(a, b, width) - swap two elements
*
*Purpose:
* swaps the two array elements of size width
*
*Entry:
* char *a, *b = pointer to two elements to swap
* unsigned width = width in bytes of each array element
*
*Exit:
* returns void
*
*Exceptions:
*
*******************************************************************************/
static void __cdecl swap (
char *a,
char *b,
unsigned width
)
{
char tmp;
if ( a != b )
/* Do the swap one character at a time to avoid potential alignment
problems. */
while ( width-- ) {
tmp = *a;
*a++ = *b;
*b++ = tmp;
}
}
C语言如何编写旋转矩阵源代码
这里以顺时针旋转90°为例carray源码：
#includestdio.h
#includestdlib.h
#includetime.h
#define N 4
void main()
{
int i,j;
int a[N*N],b[N][N];//这里设置旋转为4*4的矩形，自己在这里改成其它的矩形
int *p=a;//用指针来指向这个一维数组。这样在旋转赋值的时候会轻松很多
srand(time(NULL));
for(i=0;iN*N;i++)
{
a[i]=rand()%100;//随机生成0~99
printf("%d\t",a[i]);
if((i+1)%4==0)
printf("\n");
}
for(i=N-1;i=0;i--) //旋转赋值，这里可修改旋转的方向和角度
for(j=0;jN;j++,p++)
b[j][i]=*p;
printf("顺时针旋转90度后：\n");
for(i=0;iN;i++)
{for(j=0;jN;j++)
printf("%d\t",b[i][j]);
printf("\n");
}
}
这种旋转矩形的，个人建议生成一维数组，用指针指向改数组，再用指针来赋值carray源码；也可生成二维数组，再定义数组指针来指向，这样稍麻烦一些些。
C语言，求解，谁能给一个完整的源代码
#includestdio.h
#includestdlib.h
void main()
{
int*a,n,i,j,t;
printf("input n:");
scanf("%d",n);
a=(int*)malloc(n*sizeof(int));
printf("input array:");
for(i=0;in;i++)
scanf("%d",a+i);
for(i=1;in;i++)
for(j=0;jn-i;j++)
if(a[j]a[j+1])
{t=a[j];
a[j]=a[j+1];
a[j+1]=t;
}
printf("差值为：%d\n",a[n-1]-a[0]);
}
你把我这个答案黏贴上去，绝对不会错！
c语言一段代码看不懂
carray源码你试试输入10个不为0的数carray源码，就会出错carray源码了。array[MAX]=0;是为了保证
for ( count = 0; num_array[count] != 0; count++)count加不到10以上，否则会内存越界
