C初级阶段练习题目（三）

于 2016-06-09 20:04:27 发布
阅读量362 收藏
点赞数
分类专栏： C/C++ 文章标签： C语言 初级练习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/asd7486/article/details/51622526
版权
//***********************21、求一个3*3矩阵对角线元素之和**********************
int main()
{
                 int i, j;
                 int sum1 = 0;
                 int sum2 = 0;
                 int a[3][3] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
                 for (i = 0; i < 3; i++)
                {
                                 for (j = 0; j < 3; j++)
                                {
                                                 if (i == j)  //       \方向 主对角线元素之和
                                                {
                                                                sum1 = sum1 + a[i][j];
                                                }
                                                 if (i + j == 2)  //    /方向 副对角线元素之和
                                                {
                                                                sum2 = sum2 + a[i][j];
                                                }
                                }
                }
                                printf( "主对角线元素之和=%d\n" , sum1);
                                printf( "副对角线元素之和=%d\n" , sum2);
                                printf( "对角线元素之和=%d\n" , sum1 + sum2 - a[1][1]);

                 return 0;

}

//******扩展：当矩阵为N*N时
#define N 4
int main()
{
                 int i, j;
                 int sum1 = 0;
                 int sum2 = 0;
                 int a[ N ][ N ] = { 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 };
                 for (i = 0; i < N ; i++)
                {
                                 for (j = 0; j < N ; j++)
                                {
                                                 if (i == j)  //       \方向 主对角线元素之和
                                                {
                                                                sum1 = sum1 + a[i][j];
                                                }
                                                 if (i + j == N -1)  //    /方向 副对角线元素之和
                                                {
                                                                sum2 = sum2 + a[i][j];
                                                }
                                }
                }
                printf( "主对角线元素之和=%d\n" , sum1);
                printf( "副对角线元素之和=%d\n" , sum2);
                 if ( N % 2 == 0)  //偶数矩阵
                {
                                printf( "对角线元素之和=%d\n" , sum1 + sum2);
                }
                 if ( N % 2 != 0)
                {
                                printf( "对角线元素之和=%d\n" , sum1 + sum2 - a[( N - 1) / 2][( N - 1) / 2]);
                }
                 return 0;
}

//******************22、将一个整形数组逆序**************************
int * Reverse( int * a , int left , int right )
{
                 int temp = 0;
                 while ( left < right )
                {
                                temp = a [ left ];
                                 a [ left ] = a [ right ];
                                 a [ right ] = temp;
                                 left ++;
                                 right --;
                }
                 return a ;
}

int main()
{
                 int i = 0;
                 int arr[] = { 1, 2, 3, 4, 5 };
                 int size = sizeof (arr) / sizeof (arr[0]);
                Reverse(arr, 0, size - 1);
                 for (i = 0; i < size; i++)
                {
                                printf( "arr[i]=%d\n" , arr[i]);
                }
                 return 0;
}

//*****************23、对一个整型数组排序(冒泡排序)*******************
int * BubbleSort( int * a , int size )
{
                 int i = 0;
                 int j = 0;
                 int tmp = 0;
                 for (i = 0; i < size ; i++)
                {
                                 for (j = 0; j < size ; j++)
                                {
                                                 if ( a [j] < a [j + 1])
                                                {
                                                                tmp = a [j];
                                                                 a [j] = a [j + 1];
                                                                 a [j + 1] = tmp;
                                                }
                                }
                }
                 return a ;
}


int main()
{
                 int i = 0;
                 int arr[] = { 1, 4, 3, 7, 2, 9, 5, 0, 6 };
                 int size = sizeof (arr) / sizeof (arr[0]);
                BubbleSort(arr, size);
                 for (i = 0; i < size; i++)
                {
                                printf( "%d  " , arr[i]);
                }
                 return 0;
}

//*****************25、用递归的方式求斐波那契的第n个数**********************
//           | 0    n=0
//           | 1    n=1
//  F(n)=| 1    n=2
//           | F(n-1)+F(n-2)   n>2

//   0  1  1  2  3  5  8  13  21  34  55  89 ...
typedef long long   INT ;
INT Fib( int num )
{
                 if ( num == 0)
                                 return 0;
                 if ( num == 1)
                                 return 1;
                 return Fib( num - 1) + Fib( num - 2);
}

int main()
{
                 int n = 0;
                 INT ret = 0;
                printf( "请输入序号：" );
                scanf( "%d" , &n);
                ret=Fib(n);
                printf( "%d" , ret);
                 return 0;
}

//**************26、用非递归的方式求斐波那契数列的第n个数********************
//用数组的话不知道要开辟多大的空间，如果num的值小，而开辟的空间太大，会造成空间浪费
//最好的方法是用三个变量不停交换值，循环num-1次,占用空间12个字节，效率也不慢
//如果是在C++中，可以用vector类型的数组来放数据，可自动增容，也可用三个指针

int Fib( int num )
{
                 int a = 0;
                 int b = 1;
                 int c = 0;
                 int i = 0;
                 if ( num == 0)
                                 return a;
                 if ( num == 1)
                                 return b;
                 for (i = 2; i <= num ; i++)
                {
                                c = a + b; //  1   2   3   5
                                a = b;    //   0   1   1   2
                                b = c;    //   1   1   2   3
                }
                 return c;
}


int main()
{
                 int n = 0;
                scanf( "%d" , &n);
                 int ret=Fib(n);
                printf( "第%d项的值=%d" , n,ret);
                 return 0;
}

//************27、编写一个函数求字符串的长度（不使用库函数）***************
//注意：*p的类型要和str的类型一致，否则传参失败，程序结果出错
#include <assert.h>
int my_strlen( const char * str )
{
                 assert (str);
                 int count = 0;
                 char *p = str ;
                 if (*p == NULL )
                                 return 0;
                 while (*p != '\0' )
                {
                                count++;
                                p++;
                }
                 return count;
}


int main()
{
                 char a[] = "abcdef" ;
                 int ret=my_strlen(a);
                printf( "字符串长度=%d" ,ret);
                 return 0;
}


//*******************28、不允许创建临时变量求一个字符串的长度*****************
//注意：进入程序要判断参数是否存在，参数是否为空
#include <assert.h>
int   _strlen( const char * a )
{
                 assert (a);
                 if (* a == NULL )
                                 return 0;
                 else
                                 return (1 + _strlen( a + 1));
}

int main()
{
                 char a[] = "abcdefgh1234556" ;
                 int ret=_strlen(a);
                printf( "字符串长度=%d" , ret);
                 return 0;
}


//*******************29、对任意一个整型数组排序（选择排序）*******************
//选择排序举例： 5  7  4  9  3  0  8  2  1
//               0  7  4  9  3  5  8  2  1
//               0  1  4  9  3  5  8  2  7
//               0  1  2  9  3  5  8  4  7
//               0  1  2  3  9  5  8  4  7
//               0  1  2  3  4  5  8  9  7     .....
//begin从第一个数开始，从除第一个数以外的数中找到最小的数，然后与第一个数交换
//begin++,指向第二个数，从第二个往后的数中找最小数，然后与之交换
//直到begin指向最后一个数时，表示顺序以及排好

//NOTE:：找其余数中的最小值
#include <assert.h>
void SelectSort( int * a , int size )
{
                 assert (a);
                 int begin = 0;
                 int i = 0;
                 int Min = 0;
                 int temp = 0;
                 while (begin < size - 1)   //当begin指向倒数第一个数时已经排好
                {
                                Min = begin;
                                 for (i = begin + 1; i < size ; i++)
                                {
                                                 if ( a [i] < a [Min])    //每次都和最小的那个数比较
                                                {
                                                                Min = i;
                                                }
                                }
                                
                                temp = a [Min];
                                 a [Min] = a [begin];
                                 a [begin] = temp;
                                
                                begin++;
                }
}


int main()
{
                 int i = 0;
                 int arr[] = { 9, 7, 4, 9, 3, 1, 8, 2, 0 };
                SelectSort(arr, sizeof (arr) / sizeof (arr[0]));
                 for (i = 0; i < sizeof (arr) / sizeof (arr[0]); i++)
                {
                                printf( "%d   " , arr[i]);
                }
                 return 0;
}


//*****************30、求一个数的二进制序列中1的个数**************************
//利用十进制转二进制的方法，余数倒写则为十进制的二进制表示
//在这里不用看顺序，只需要统计1的个数，所以只需统计每次除以2余数是1的个数

int main()
{
                 size_t data = 0;
                 int count = 0;
                scanf( "%d" , &data);
                 while (data)
                {
                                 if (data % 2 == 1)
                                {
                                                count++;
                                }
                                data = data >> 1;  // data=data/2;
                }
                printf( "count=%d\n" , count);

                 return 0;
}


评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值