需要协助编程问题。
必须是Java。不能使用任何库（Arraylist等）。
int[] a = {1, 2, 3, 4, 8, 5, 7, 9, 6, 0}
int[] b = {0, 2, 11, 12, 5, 6, 8}
必须创建一个引用这两个数组的对象，该方法将它们合并在一起，删除重复项并对它们进行排序。
到目前为止，这是我的排序。虽然难以组合两个数组并删除重复数据。
int lastPos;
int index;
int temp;
for(lastPos = a.length - 1; lastPos >= 0; lastPos--) {
for(index = 0; index <= lastPos - 1; index++) {
if(a[index] > a[index+1]) {
temp = a[index];
a[index] = a[index+1];
a[index+1] = temp;
}
}
}
答案 0 :(得分：3)
将它们合并在一起的方法，删除重复项并对它们进行排序。
我建议你把它分解为帮助方法（并且稍微调整操作的顺序）。第1步，合并两个数组。像，
static int[] mergeArrays(int[] a, int[] b) {
int[] c = new int[a.length + b.length];
for (int i = 0; i < a.length; i++) {
c[i] = a[i];
}
for (int i = 0; i < b.length; i++) {
c[a.length + i] = b[i];
}
return c;
}
第2步，对新数组进行排序（现有的排序算法很好）。像，
static void sortArray(int[] a) {
for (int lastPos = a.length - 1; lastPos >= 0; lastPos--) {
for (int index = 0; index <= lastPos - 1; index++) {
if (a[index] > a[index + 1]) {
int temp = a[index];
a[index] = a[index + 1];
a[index + 1] = temp;
}
}
}
}
最后，删除重复项。步骤3a，计算unique个值。假设它们是唯一的，并通过计算相邻（和相等）值来减少它们。像，
static int countUniqueValues(int[] c) {
int unique = c.length;
for (int i = 0; i < c.length; i++) {
while (i + 1 < c.length && c[i] == c[i + 1]) {
i++;
unique--;
}
}
return unique;
}
然后执行步骤3b，获取唯一计数并使用以前的方法构建结果。像，
public static int[] mergeDedupSort(int[] a, int[] b) {
int[] c = mergeArrays(a, b);
sortArray(c);
int unique = countUniqueValues(c);
int[] d = new int[unique];
int p = 0;
for (int i = 0; i < c.length; i++) {
d[p++] = c[i];
while (i + 1 < c.length && c[i] == c[i + 1]) {
i++;
}
}
return d;
}
然后你可以用你的数组测试它，比如
public static void main(String[] args) {
int[] a = { 1, 2, 3, 4, 8, 5, 7, 9, 6, 0 };
int[] b = { 0, 2, 11, 12, 5, 6, 8 };
int[] c = mergeDedupSort(a, b);
System.out.println(Arrays.toString(c));
}
我得到了
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12]
答案 1 :(得分：2)
你应该像这样使用IntStream。
int[] a = {1, 2, 3, 4, 8, 5, 7, 9, 6, 0};
int[] b = {0, 2, 11, 12, 5, 6, 8};
int[] merged = IntStream
.concat(IntStream.of(a), IntStream.of(b))
.distinct()
.sorted()
.toArray();
System.out.println(Arrays.toString(merged));
答案 2 :(得分：1)
合并两个没有重复的数组并对其进行排序（不使用库）。 使用对象。
public class MergeRemoveDupSort {
public int[] mergeRemoveDupSortIt(int[] a, int[] b) {
int [] c = mergeIt(a,b);
int [] d = removeIt(c);
int [] e = sortIt(d);
return e;
}
private int[] mergeIt(int[] a, int[] b) {
int[] c = new int[a.length + b.length];
int k=0;
for (int n : a) c[k++]=n;
for (int n : b) c[k++]=n;
return c;
}
private int[] removeIt(int[] c) {
int len=c.length;
for (int i=0;i<len-1;i++)
for (int j=i+1;j<len;j++)
if (c[i] == c[j]) {
for (int k=j;k<len-1;k++)
c[k]=c[k+1];
--len;
}
int [] r = new int[len];
for (int i=0;i<r.length;i++)
r[i]=c[i];
return r;
}
private int[] sortIt(int[] a) {
for(int index=0; index<a.length-1; index++)
for(int i=index+1; i<a.length; i++)
if(a[index] > a[i]){
int temp = a[index];
a[index] = a[i];
a[i] = temp;
}
return a;
}
public void printIt(int[] a) {
System.out.print("[");
for (int i=0;i<a.length;i++){
System.out.print(a[i]);
if (i!=a.length-1) System.out.print(",");
else System.out.print("]");
}
}
public static void main(String[] args) {
int[] a = {1, 2, 3, 4, 8, 5, 7, 9, 6, 0};
int[] b = {0, 2, 11, 12, 5, 6, 8};
MergeRemoveDupSort array = new MergeRemoveDupSort();
int [] r = array.mergeRemoveDupSortIt(a, b);
array.printIt(r);
}
}
答案 3 :(得分：0)
try{
int[] a = {1, 2, 3, 4, 8, 5, 7, 9, 6, 0};
int[] b = {0, 2, 11, 12, 5, 6, 8};
int[] c = new int[a.length+b.length];
int[] final = new int[a.length+b.length];
int i = 0;
for(int j : final){
final[i++] = -1;
}
i = 0;
for(int j : a){
c[i++] = j;
}
for(int j : b){
c[i++] = j;
}
boolean check = false;
for(int j = 0,k = 0; j < c.length; j++){
for(int l : fin){
if( l == c[j] )
check = true;
}
if(!check){
final[k++] = c[j];
} else check = false;
}
} catch(Exception ex){
ex.printStackTrace();
}
我更喜欢你使用Hashset，因为它永远不会允许重复 并且在java 8中有另一种方法可以让arraylist删除重复项 将所有元素复制到c后，请遵循此代码
List<Integer> d = array.asList(c);
List<Integer> final = d.Stream().distinct().collect(Collectors.toList());
final.forEach(System.out::println());
这段代码比前一段好得多，你可以再次将final转换为数组
int array[] = new int[final.size()];
for(int j =0;j<final.size();j++){
array[j] = final.get(j);
}
希望我的工作能有所帮助。
答案 4 :(得分：0)
让我重申你的问题。
你想要一个带有两个任意数组的程序，合并它们去除任何重复项，然后对结果进行排序。
首先，如果您可以访问任何数据结构，那么更多更好的方法可以做到这一点。理想情况下，您会使用类似TreeSet的内容。
但是，假设你有权访问的是数组，那么你的选择就会受到更多限制。我将继续并假设两个阵列中的每一个最初都没有重复。
假设第一个数组的长度为m，第二个数组的长度为n。
int[] array1; // length m
int[] array2; // length n
首先，让我们对两个数组进行排序。
Arrays.sort(array1);
Arrays.sort(array2);
这假设您可以访问作为标准Java Collections Framework一部分的Arrays类。如果没有，任何合理的合并实现（如MergeSort）都可以解决问题。
排序将O(n log n + m log m)用于最好的排序实现。
接下来，让我们合并两个排序的数组。首先，我们需要分配一个足够大的新数组来容纳所有元素。
int[] array3 = new int[size];
现在，我们需要按顺序插入array1和array2的元素，注意不要插入任何重复项。
int index=0, next=0, i=0, j=0;
int last = Integer.MAX_INT;
while(i < m || j < n) {
if(i == m)
next = array2[j++];
else if(j == n)
next = array1[i++];
else if(array1[i] <= array2[j])
next = array1[i++];
else
next = array2[j++];
if(last == next)
continue;
array3[index++] = next;
}
现在，你有了你的阵列。只有一个问题 - 它可能在最后有无效的元素。最后一个副本应该照顾它......
int[] result = Arrays.copyOf(array3, index + 1);
插入和最终副本将采用O(n + m)，因此算法的整体效率应为O(n log n + m log n)。
答案 5 :(得分：0)
假设数组 a 和数组 b 已排序，以下代码会将它们合并为第三个数组 merged_array 而不重复：
inner join希望这可能有所帮助，一切顺利：）