京东笔试题3

[编程题] 有趣的排序

时间限制：1秒

空间限制：32768K

度度熊有一个N个数的数组，他想将数组从大到小排好序，但是萌萌的度度熊只会下面这个操作：
任取数组中的一个数然后将它放置在数组的最后一个位置。
问最少操作多少次可以使得数组从小到大有序？ 

输入描述:

首先输入一个正整数N，接下来的一行输入N个整数。(N <= 50, 每个数的绝对值小于等于1000)

输出描述:

输出一个整数表示最少的操作次数。

输入例子:

4
19 7 8 25

输出例子:

2

思想：

（1）原始数组： 19 7 8 25

（2）排序后数组： 7 8 19 25

（3）通过二者的动态比较可以得到：a中按大小顺序已经站好位置的元素的个数，即元素移动中，不需要移动就可以归位的元素，那么剩下的元素个数就是必须经过移动才能归位的元素，即最小的移动次数。按照这个思路，除了不需要动的元素以外，如果每次按照剩余元素从小到大的顺序依次取出，并放到数组的末尾的方法，就是最小移动次数的方法。总结一句话就是（总数-不需要移动的数=移动的数）

1、第一种方式

package com.Main;

import java.util.*;  
public class shuzusort2 {  
    public static void main(String[] args) {  
        Scanner sc = new Scanner(System.in);  
        int n = sc.nextInt();  
        int[] arr = new int[n];  
        int[] sort = new int[n];   
        for(int i=0;i<n;i++){  
            arr[i] = sc.nextInt();  
            sort[i]=arr[i];  
        }  
        Arrays.sort(sort); 
        for (int i = 0; i < sort.length; i++) {
            System.out.println(sort[i]);
		}
        int count = 0;  
        for(int i=0;i<n;i++){  
            if(arr[i]==sort[count]){  
                count++;  
                if(count==n)   
                	break;                  
            }  
        }  
        System.out.println(n-count);  
    }  
}  

2、第二种方式

import java.util.Scanner;

public class Main {
//	度度熊有一个N个数的数组，他想将数组从大到小排好序，但是萌萌的度度熊只会下面这个操作：
//	任取数组中的一个数然后将它放置在数组的最后一个位置。
//	问最少操作多少次可以使得数组从小到大有序？ 
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
                //  输入： 4
                //	   19 7 8 25
		//  输出： 2
		Scanner sc=new Scanner(System.in);
		//总数N
		int N=sc.nextInt();
	    int[] arr=new int[N] ;
		//开始读入数据
	    for (int i = 0; i < N; i++) {
			arr[i]=sc.nextInt();
		}
	    int[] arr1=new int[N] ;
	    //arr1=arr;    ****
	    for (int i = 0; i < arr.length; i++) {
		    arr1[i]=arr[i];
			}
	    //读入数据完成
	    //插入排序
        for (int i = 1; i < arr.length; i++)
        {
            int j = i;
            int target = arr[i];
     
            while (j > 0 && target < arr[j - 1])
            {
                arr[j] = arr[j - 1];
                j--;
            }
            arr[j] = target;
        }
        int count =0;
        for(int i=0;i<N;i++){  
            if(arr1[i]==arr[count]){  
                count++;  
                if(count==N)   
                	break;                  
            }  
        }  
        System.out.println(N-count);  

	}

}

容易犯错的小知识点：

	    //arr1=arr;    ****

数组的复制不能直接复制，直接复制后的数组与原有数组共占一块内存地址，任何一个数组值得改变都会影响另外一个数组。

理由：因为数组是一个对象

    int[] i1 = new int[10];
    int[] i2 = i1;
这样的话i1和i2访问的是内存中的同一段数据,所以修改一个,另一个也跟着改变了；

这样也是不行的：

    int[] i1 = new int[10];

    int[] i2 = new int[10];

    int[] i2 = i1;

正确的方法是这样：

int[] i1 = new int[10];
int[] i2 = new int[10];
for(int i=0;i<i1.length;i++){
i2[i]=i1[i];
}

编程题没有严格要求的也可以这样：    int[] arr3=Arrays.copyOf(arr, arr.length);

每次new都会在内存中开辟一个新的空间,然后把值拿过去，这样两个数组所访问的就不是同一地址了，两个数组就可以独立操作了


但是如果是一个复合引用类型的数组,即使用第二种方式复制,结果仍是修改一个,另一个跟着变