黑马程序员------数组（排序、查询、进制转换）

最新推荐文章于 2016-01-26 11:18:48 发布

硅与神经键

最新推荐文章于 2016-01-26 11:18:48 发布

阅读量854

点赞数

分类专栏： Java SE 牛刀小试文章标签： java 二维数组堆栈数组

本文链接：https://blog.csdn.net/HelloXiaobi/article/details/11387949

版权

Java SE 牛刀小试专栏收录该内容

28 篇文章 0 订阅

订阅专栏

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

排序

选择排序：每一趟从待排序的数组元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。选择排序是不稳定的排序方法。示意图如下：

选择排序的实现：

public class ArrayDemo
{
	/*
	选择排序
	内循环一次，重复出现头下标的位置上。
	*/
	//打印数组的功能
	public static void printArray(int[] arr){
		System.out.print("[");
		for(int x=0 ;x<arr.length ;x++){
			if(x!=arr.length-1)
				System.out.print(arr[x]+",");
			else
				System.out.println(arr[x]+"]");
		}
	}
	//数组由小到大的排序功能
	public static void selectSort(int[] arr){
		for(int x = 0; x<arr.length;x++){
			for (int y = x+1;y<arr.length;y++){
				if(arr[x]>arr[y]){
					//当后面的小于时（arr[x]>arr[y]），值互换
					int temp = arr[x];
					arr[x] = arr[y];
					arr[y] = temp;
				}
			}
		}
	}
	public static void main(String[] args){
		int[] arr = {3,1,4,2,7,5};
		//排序前
		printArray(arr);
		//排序
		selectSort(arr);
		//排序后
		printArray(arr);
	}
}

冒泡排序的实现：

冒泡排序算法的运作原理如下：

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

/*
	冒泡排序
	*/
	public static void bubbleSort(int[] arr){
		for(int x = 0; x<arr.length-1;x++){
			//-x:让每一次比较的元素减少；-1，避免数组下标越界。
			for(int y = 0; y<arr.length-x-1;y++){
				if(arr[y]>arr[y+1]){
					int temp = arr[y];
					arr[y] = arr[y+1];
					arr[y+1] = temp;
				}
			}
		}
	}

为便于观察，从上面提取选择排序：

/*
	选择排序
	内循环一次，重复出现头下标的位置上。
	*/
	//打印数组的功能
	public static void printArray(int[] arr){
		System.out.print("[");
		for(int x=0 ;x<arr.length ;x++){
			if(x!=arr.length-1)
				System.out.print(arr[x]+",");
			else
				System.out.println(arr[x]+"]");
		}
	}

根据上面各程序发现，无论什么排序，都需要满足条件的元素进行位置置换。所以，可以把这部分相同的代码提取出来，单独封装成一个函数。

public static void swap(int[],int a,int b){
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}

查找

查找与折半查找：二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。

首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

算法要求：

必须采用顺序存储结构
必须按关键字大小有序排列。

public class ArrayDemo
{
	//定义功能，获取key第一次出现在数组中的位置，如果是-1，那么代表该key在数组中不存在。
	public static int getIndex(int[] arr,int key){
		for(int x = 0; x<arr.length;x++){
			if(arr[x]==key){
				return x;
			}
		}
		return -1;
	}

	//折半查找，提高效率，但是要保证是有效的数组。
	public static int halfSearch(int[] arr, int key){
		int min ,max ,mid;
		min = 0;
		max = arr.length-1;
		mid = (min+max)/2;
		while(arr[mid]!=key){
			if(key>arr[mid])
				min = mid + 1;
			else if(key<arr[mid])
				max = mid -1;
			if(min>max)
				return -1;
				mid = (min+max)/2;
		}
		return mid;
	}
	//折半的第二种方式。
	public static int halfSearch_2(int[] arr, int key){
		int min ,max ,mid;
		min = 0;
		max = arr.length-1;
		while(min<=max){
			mid = (min+max)/2;
			if(key>arr[mid])
				min = mid+1;
			else if (key<arr[mid])
				max = min-1;
			else
				return mid;
		}
		return -1;
	}

	//练习，有一个有序的数组，想要将一个元素插入该数组中，放在哪个位置，
	//还能保证这个数组有序。既，如何获取该元素在数组中的位置。
	public static int getIndex_2(int[] arr,int key){
		//折半的延伸....思考
		int min ,max ,mid;
		min = 0;
		max = arr.length-1;
		while(min<=max){
			mid = (min+max)/2;
			if(key>arr[mid])
				min = mid+1;
			else if (key<arr[mid])
				max = min-1;
			else
				return mid;
		}
		return min;        //折半查找的时候这里返回-1
	}

	public static void main(String[] args){
		int[] arr = {1,3,4,7,14,52};
		int index = getIndex_2(arr,45);
		//int index = halfSearch_2(arr,14);
		System.out.println("index:"+index);
	}
}

以上知识要多看多思考

进制转换

十进制转二进制

class ArrayDemo
{
	public static void main(String[] args){
		toBin(13);
	}
	//十进制转二进制
	public static void toBin(int num){
		StringBuffer sb = new StringBuffer();
		while(num>0){
			sb.append(num%2);
			num = num/2;
		}
		System.out.println(sb.reverse());//sb.reverse()字符串逆转。
	}
}

十进制转十六进制

算法：1.与15进行&运算。2.得到的数和10比较，小于10的记录数字，大于10的要记录字母。3.右移4位。

class ArrayDemo
{
	public static void main(String[] args){
		toHex(33);
	}
	//十进制转十六进制
	public static void toHex(int num){
		StringBuffer sb = new StringBuffer();
		for(int x=0; x<8;x++){
			//和15&运算
			int temp = num &15;
			//判断是否要输出数字或字母
			if(temp>9)
				sb.append((char)(temp-10+'A'));
			else
				sb.append(temp);
			//操作后向右移动4位
			num = num>>>4;
			}
		System.out.println(sb.reverse());
		}
}

查表法进制转换。

0 1 2 3 4 5 6 7 8 9 A B C D 十六进制中的元素

0 1 2 3 4 5 6 7 8 9 10 11 12 13 数组下标

查表法：

1.将所有的元素临时存储起来，建立对应关系。

2.每一次&15后的值作为索引去查建立好的表。就可以找到对应的元素。

class ArrayDemo
{
	//抽取出数据进制转换功能函数
	public static void trans(int num, int base, int offset){
		if(num == 0){
			System.out.println(0);
			return;
		}
		//数组中的元素为16进制的字符表示，而下标正好是0-15.与16进制相对应
		char[] chs = {'0','1','2','3'
					,'4','5','6','7'
					,'8','9','A','B'
					,'C','D','E','F'};
		//定义一个临时容器
		char[] arr = new char[32];
		int pos = arr.length;
		while(num!=0){
			int temp = num & base;
			arr[--pos] = chs[temp];
			num = num >>> offset;
		}
		//存储数据的arr数组遍历
		for(int x = pos;x<arr.length;x++){
			System.out.print(arr[x]);
		}
		System.out.println();
	}
	//10转换成2进制
	public static void toBin(int num){
		trans(num,1,1);
	}
	//10转换成8进制
	public static void toOctal(int num){
		trans(num,7,3);
	}
	//10转换成16进制
	public static void toHex(int num){
		trans(num,15,4);
	}
	public static void main(String[] args){
		toBin(13);
		toOctal(23);
		toHex(-84);
		toHex(0);
	}
}

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

详情请查看：http://edu.csdn.net