数组元素值的交换
两个元素值互换
//声明并且初始化了一个名为nums有5个int类型元素的数组
int[] nums = { 1, 2, 3, 4, 5 };
//编译后 int[] numArray = new int[] { 1, 2, 3, 4, 5 };
//或者是 十六进制的数字
//int[] numArray = new int[] { 0x1, 0x2, 0x3, 0x4, 0x5 };
Console.WriteLine("没交换前各个元素的值");
for (int i = 0; i < nums.Length; i++)
{
Console.WriteLine("第{0}元素的值为 {1} ", i + 1, nums[i]);
}
//第一与第五两个元素值进行交换
//需要使用第三方变量进行过渡
int temp = 0;//第三方变量也可以称之为中间变量
temp = nums[0];//第一个元素的值赋值给temp
nums[0] = nums[4];//第五元素的值赋值给第一元素
nums[4] = temp;//相当于将第一元素的值赋值给第五元素
Console.WriteLine("");
Console.WriteLine("交换后各个元素的值");
//其他元素的值还是原值
for (int i = 0; i < nums.Length; i++)
{
Console.WriteLine("第{0}元素的值为 {1} ", i + 1, nums[i]);
}
Console.ReadKey(); 数据类型的排序规则
排序规则:排序时一定是同类型数据比较的结果,不同类型无法比较如object类型,一般只在数值,字符与字符串三种类型中进行排序
基本数据类型(部分)
1 数值类型数据排序规则按数值的大小进行排序
数值类型排序,其他的自测
2 字符型数据排序规则按ASCII码值的大小进行排序
汉字使用扩展的ASCII码,简体中文常见的编码方式是GB2312
字符类型排序
3 字符串类型数据排序规则底层还是按ASCII码值的大小进行排序
字符串类型排序
//首先将所有元素的字符串数据左对齐
//以下都是以升序排序来说
//1)获取字符串的第一个字符如 "6"与"19"
//只比较6与1的ASCII码值,因此 "6">"19"
//2)如果第一个字符码值相同,比较第二个字符如"67"与"69"
//比较7与9的码值 9>7 因此"67"<"69"
//字母与数字,数字>字母 不再赘述
//3)汉字的比较不再是字符型汉字的比较
//而是将汉字转换为拼音进行比较
//说是拼音其实就是按照西方的字母(文化入侵无处不在)
//字符型规则应该是中<神
//字符串规则则是中>神
//因此"神州"<"中国" 了解了以上数据类型的基本排序规则就可以使用冒泡排序方式将元素进行排序
冒泡排序(了解即可)
特点:简单易理解,但效率不高,用于至少有3个元素的排序,说这个冒泡排序只为了解排序方法的底层实现
有两个元素1,2的数组,直接使用if结构就可以解决
//=======================================
有3个元素1,2,3的数组
现将其按从大到小排序,刚好与原顺序相反
冒泡排序的核心是:两两比较
第一轮排序 1,2,3 由大到小排序
拿第一个元素与后面两个比较
1)1与2比较 1<2 为真 排序 213
2)1与3比较 1<3 为真 排序 231
三个比较过后最大的还没有排在最前面
比较过后将最小的排在最后
第二轮排序 2,3,1 由大到小排序
还是拿第一个元素与后面两个比较
3)2与3比较 2<3 为真 排序 321
4)2与1比较 2<1 为假 排序结束 多比较了一次
//=========================================
有5个元素1,2,3,4,5的数组
第一轮 1,2,3,4,5 由大到小排序
1与后面四个比较 为真就交换
1)1与2 1<2 为真 排序 21345
2)1与3 1<3 为真 排序 23145
3)1与2 1<4 为真 排序 23415
4)1与3 1<5 为真 排序 23451
第二轮 2,3,4,5,1 由大到小排序
2与后面四个比较 为真就交换
1)2与3 2<3 为真 排序 32451
2)2与4 2<4 为真 排序 34251
3)2与5 2<5 为真 排序 34521
4)2与1 2<1 为假 排序 34521 无效1次
第三轮 3,4,5,2,1 由大到小排序
3与后面四个比较 为真就交换
1)3与4 3<4 为真 排序 4,3,5,2,1
2)3与5 3<5 为真 排序 4,5,3,2,1
3)3与2 3<2 为假 排序 4,5,3,2,1 无效1次
4)3与1 3<1 为假 排序 4,5,3,2,1 无效2次
第四轮 4,5,3,2,1 由大到小排序
4与后面四个比较 为真就交换
1)4与5 4<5 为真 排序 5,4,3,2,1
2)4与3 4<3 为假 排序 5,4,3,2,1 无效1次
3)4与2 4<2 为假 排序 5,4,3,2,1 无效2次
4)4与1 4<1 为假 排序 5,4,3,2,1 无效3次
第五轮 5,4,3,2,1 由大到小
5与后面四个比较 完全无意义
1)5与4 5<4 为假 排序 5,4,3,2,1 无效1次
2)5与3 5<3 为假 排序 5,4,3,2,1 无效2次
3)5与2 5<2 为假 排序 5,4,3,2,1 无效3次
4)5与1 5<1 为假 排序 5,4,3,2,1 无效4次
//==================================
使用循环实现 降序排序
1,2,3,4,5 轮数 有效次数 比较次数
2,3,4,5,1 0 4 4
3,4,5,2,1 1 3 4
4,5,3,2,1 2 2 4
5,4,3,2,1 3 1 4
5,4,3,2,1 4 0 4 根据以上信息推导出实现公式 假设共有n个元素
int len=n-1;
循环4轮即可完成排序(有效比较) 所以循环次数为 len=4 即轮数
每轮有效比较次数总是依照轮数减少,所以循环次数为 4-i 即有效比较次数
因此使用双层循环实现冒泡排序
int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int len = nums.Length - 1;//轮数
int temp = 0;//中间变量 上面说过
//控制循环的轮数
for (int i = 0; i < len; i++)//共8轮
{
//每轮循环的有效次数
for (int j = 0; j < len - i; j++)
{
//第一个元素与后面一个元素比较
//如果前面小于后面就交换数据即挪位置
if (nums[j] < nums[j + 1])
{
temp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = temp;
}
}
}
//打印输出排序后的元素
for (int i = 0; i < nums.Length; i++)
{
Console.Write("{0} ", nums[i]);
}
Console.ReadKey(); 冒泡排序
//套用上面的循环
//上面是降序排序
//这个按升序排序
//将if中的条件改为 大于 即可
int[] nums = { 31,56,96, 42, 15, 86, 27, 8, 15 };
int len = nums.Length - 1;//轮数
int temp = 0;//中间变量
//控制循环的轮数
for (int i = 0; i < len; i++)//共8轮
{
//每轮循环的有效次数
for (int j = 0; j < len - i; j++)
{
//第一个元素与后面一个元素比较
//如果前面小于后面就交换数据即挪位置
if (nums[j] > nums[j + 1])//改为大于是升序
{
temp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = temp;
}
}
}
//打印输出排序后的元素
for (int i = 0; i < nums.Length; i++)
{
Console.Write("{0} ", nums[i]);
}
Console.ReadKey(); 升序排序
其他排序算法:插入排序,希尔排序,选择排序,归并排序,快速排序,堆排序,基数排序等,实现原理可以自己网上搜索学习
算法中说难不好理解的大概率在于循环嵌套时的代码,说简单整个实现代码只是将之前说过的组装在一起,基础牢靠后就是不断的去组装重构,做一些实用小程序
程序中循环或循环嵌套也是非常重要的节点,在着法中更重要,而一个好的算法也可以大大提高程序运行速度,更重要的是学习算法中的思想,因此可以多做一些了解