⑴ 使用java設計演算法，完成將兩個有序遞增的單鏈表合並為一個有序遞增的單鏈表，重復的元素只出現一次。
type
point=^node;
node=record
data:integer;
next:point;
end;
var h1,h2,h:point;
procere prt(p:point); //列印鏈表
begin
p:=p^.next;
while p<>nil do
begin
write(p^.data,' ');
p:=p^.next;
end;
writeln;
end;
procere creat(var h:point); //建立鏈表
var x:integer; p,q:^node;
begin
writeln('請輸入升序的數，負數結束：');
new(h);
p:=h;
read(x);
while(x>=0)do
begin
new(q);
q^.data:=x;
p^.next:=q;
p:=q;
read(x);
end;
p^.next:=nil;
end;
function merge_link(var p,q:point):point; //升序合並二個升序鏈表
var h,w:^node;
begin
w:=p; p:=p^.next; dispose(w); //回收一個頭結點，p指向首個數據結點
w:=q; h:=q; q:=q^.next; //h:合並後的頭結點，q指向首個數據結點
while (p<>nil)and(q<>nil) do //當二個鏈表都不空時
if(p^.data<q^.data) then //選一個小的結點
begin
w^.next:=p; //把小結點鏈入
p:=p^.next; //跳過此結點
w:=w^.next; //w指向當前合並後鏈表的尾結點
end
else
begin //下面三行作用同上
w^.next:=q;
q:=q^.next;
w:=w^.next;
end;
if p<>nil then w^.next:=p; //將未完的鏈表接入
if q<>nil then w^.next:=q; //將未完的鏈表接入
merge_link:=h; //返回合並後的鏈表頭指針
end;
begin
creat(h1);
creat(h2);
h:=merge_link(h1,h2);
writeln('合並後的鏈表：');
prt(h);
⑵ Java hashMap合並演算法
用Kotlin語言寫了一下，Java只要把MutableMap改成Map就可以了
importkotlin.random.Random;
funmain(arg:Array<String>){
println("HelloWorld");
valmap:Map<String,String>=hashMapOf(
"1242"to"A31_001","2424"to"A31_001",
"3646"to"A31_002");
println("原map:$map");
valgroups:HashMap<String,MutableMap<String,String>>=hashMapOf();
for((k,v)inmap.entries){
if(!groups.containsKey(v))groups.put(v,hashMapOf());
valm=groups.getValue(v);
m.put(k,v);
}
println("重組新map:$groups");
//給換成新隨機id,沒必要但為滿足要求
valnewMap:HashMap<Int,MutableMap<String,String>>=hashMapOf();
varid:Int;
for(vingroups.values){
do{id=Random.nextInt();}
while(newMap.containsKey(id));
newMap.put(id,v);
}
println("新隨機生成ID:$newMap");
}
>Task:run
HelloWorld
原map:{1242=A31_001,3646=A31_002,2424=A31_001}
重組新map:{A31_002={3646=A31_002},A31_001={2424=A31_001,1242=A31_001}}
新隨機生成ID:{-91779881={2424=A31_001,1242=A31_001},2102779363={3646=A31_002}}
BUILDSUCCESSFULin0s
⑶ java如何將兩個元素個數不同的一維數組合並成一個從小到大排列的數組
public class T3 {
public static void main(String[] args) {
int a[]={4,5,6,7,2,4,56,7};
int b[]={4545,14,9,3,67};
int c[]=Merger(a, b);
Sorting(c);
for (int i : c) {
System.out.print(i+" ");
}
}
//合並
public static int[] Merger(int[] a,int[] b){
int c[]=new int[a.length+b.length];
for (int i = 0; i < c.length; i++) {
if(i<a.length){
c[i]=a[i];
}else{
c[i]=b[i-a.length];
}
}
return c;
}
//排序
public static void Sorting(int[] c){
for (int i = 0; i < c.length-1; i++) {
for (int j = i+1; j < c.length; j++) {
if(c[i]>c[j]){
int tmp=c[i];
c[i]=c[j];
c[j]=tmp;
}
}
}
}
}
⑷ Java合並兩個排序的鏈表問題（劍指offer）
1、先將兩個鏈表分別進行各自排序。如果題目已說明原來的兩個鏈表是已經排好序的話，此步可以省略。
2、新建一個空鏈表，按照順序（或者由小到大或者由大到小），依次將兩個鏈表的數據排列到新的鏈表中。
這樣最後得到的鏈表就是最終合並的鏈表。
⑸ JAVA歸並排序演算法，有兩行代碼看不懂
以var a = [4,2,6,3,1,9,5,7,8,0];為例子。
1.希爾排序。 希爾排序是在插入排序上面做的升級。是先跟距離較遠的進行比較的一些方法。
function shellsort(arr){ var i,k,j,len=arr.length,gap = Math.ceil(len/2),temp; while(gap>0){ for (var k = 0; k < gap; k++) { var tagArr = []; tagArr.push(arr[k]) for (i = k+gap; i < len; i=i+gap) { temp = arr[i]; tagArr.push(temp); for (j=i-gap; j >-1; j=j-gap) { if(arr[j]>temp){ arr[j+gap] = arr[j]; }else{ break; } } arr[j+gap] = temp; } console.log(tagArr,"gap:"+gap);//輸出當前進行插入排序的數組。 console.log(arr);//輸出此輪排序後的數組。 } gap = parseInt(gap/2); } return arr; }
過程輸出：
[4, 9] "gap:5" [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [2, 5] "gap:5" [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [6, 7] "gap:5" [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [3, 8] "gap:5" [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [1, 0] "gap:5" [4, 2, 6, 3, 0, 9, 5, 7, 8, 1] [4, 6, 0, 5, 8] "gap:2" [0, 2, 4, 3, 5, 9, 6, 7, 8, 1] [2, 3, 9, 7, 1] "gap:2" [0, 1, 4, 2, 5, 3, 6, 7, 8, 9] [0, 1, 4, 2, 5, 3, 6, 7, 8, 9] "gap:1" [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
由輸出可以看到。第一輪間隔為5。依次對這些間隔的數組插入排序。
間隔為5：
[4, 9] "gap:5" [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [2, 5] "gap:5" [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [6, 7] "gap:5" [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [3, 8] "gap:5" [4, 2, 6, 3, 1, 9, 5, 7, 8, 0] [1, 0] "gap:5" [4, 2, 6, 3, 0, 9, 5, 7, 8, 1] [4, 6, 0, 5, 8] "gap:2" [0, 2, 4, 3, 5, 9, 6, 7, 8, 1] [2, 3, 9, 7, 1] "gap:2" [0, 1, 4, 2, 5, 3, 6, 7, 8, 9] [0, 1, 4, 2, 5, 3, 6, 7, 8, 9] "gap:1" [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
間隔為2：
[4, 2, 6, 3, 0, 9, 5, 7, 8, 1] 4 6 0 5 8 2 3 9 7 1
排序後：
[0, 1, 4, 2, 5, 3, 6, 7, 8, 9]
間隔為1：
排序後：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]。
2.快速排序。把一個數組以數組中的某個值為標記。比這個值小的放到數組的左邊，比這個值得大的放到數組的右邊。然後再遞歸 對左邊和右邊的數組進行同樣的操作。直到排序完成。通常以數組的第一個值為標記。
代碼:
function quickSort(arr){ var len = arr.length,leftArr=[],rightArr=[],tag; if(len<2){ return arr; } tag = arr[0]; for(i=1;i<len;i++){ if(arr[i]<=tag){ leftArr.push(arr[i]) }else{ rightArr.push(arr[i]); } } return quickSort(leftArr).concat(tag,quickSort(rightArr)); }
3.歸並排序。把一系列排好序的子序列合並成一個大的完整有序序列。從最小的單位開始合並。然後再逐步合並合並好的有序數組。最終實現歸並排序。
合並兩個有序數組的方法：
function subSort(arr1,arr2){ var len1 = arr1.length,len2 = arr2.length,i=0,j=0,arr3=[],bArr1 = arr1.slice(),bArr2 = arr2.slice(); while(bArr1.length!=0 || bArr2.length!=0){ if(bArr1.length == 0){ arr3 = arr3.concat(bArr2); bArr2.length = 0; }else if(bArr2.length == 0){ arr3 = arr3.concat(bArr1); bArr1.length = 0; }else{ if(bArr1[0]<=bArr2[0]){ arr3.push(bArr1[0]); bArr1.shift(); }else{ arr3.push(bArr2[0]); bArr2.shift(); } } } return arr3; }
歸並排序：
function mergeSort(arr){ var len= arr.length,arrleft=[],arrright =[],gap=1,maxgap=len-1,gapArr=[],glen,n; while(gap<maxgap){ gap = Math.pow(2,n); if(gap<=maxgap){ gapArr.push(gap); } n++; } glen = gapArr.length; for (var i = 0; i < glen; i++) { gap = gapArr[i]; for (var j = 0; j < len; j=j+gap*2) { arrleft = arr.slice(j, j+gap); arrright = arr.slice(j+gap,j+gap*2); console.log("left:"+arrleft,"right:"+arrright); arr = arr.slice(0,j).concat(subSort(arrleft,arrright),arr.slice(j+gap*2)); } } return arr; }
排序[4,2,6,3,1,9,5,7,8,0]輸出：
left:4 right:2 left:6 right:3 left:1 right:9 left:5 right:7 left:8 right:0 left:2,4 right:3,6 left:1,9 right:5,7 left:0,8 right: left:2,3,4,6 right:1,5,7,9 left:0,8 right: left:1,2,3,4,5,6,7,9 right:0,8
看出來從最小的單位入手。
第一輪先依次合並相鄰元素：4,2; 6,3; 1,9; 5,7; 8,0
合並完成之後變成： [2,4,3,6,1,9,5,7,0,8]
第二輪以2個元素為一個單位進行合並：[2,4],[3,6]; [1,9],[5,7]; [0,8],[];
合並完成之後變成：[2,3,4,6,1,5,7,9,0,8]
第三輪以4個元素為一個單位進行合並：[2,3,4,6],[1,5,7,9]; [0,8],[]
合並完成之後變成： [1,2,3,4,5,6,7,9,0,8];
第四輪以8個元素為一個單位進行合並： [1,2,3,4,5,6,7,9],[0,8];
合並完成。 [0,1,2,3,4,5,6,7,8,9];
⑹ Java中如何將兩個字元串合並,並且把重復的元素去掉，不能用任何排序指令那些，純手打寫出來。
packagetest;
publicclassStringHeBing{
publicstaticStringmerge(Stringstr1,Stringstr2){
intlen=str2.length();
for(inti=0;i<len;i++){
charc=str2.charAt(i);
if(str1.indexOf(c)==-1){
str1=str1.concat(c+"");
}
}
System.err.println(str1);
returnstr1;
}
publicstaticvoidmain(String[]args){
Stringstr1="上海金融大廈";
Stringstr2="上港集團";
merge(str1,str2);
}
}
上面的做法只把加加進來的字元串去重，而未把原來的字元串去重復，下面做了個新的
publicstaticStringmerge1(Stringstr1,Stringstr2){
Stringadd=str1.concat(str2);
Stringresult=add.charAt(0)+"";
for(inti=1;i<add.length();i++){
charc=add.charAt(i);
if(result.indexOf(c)==-1){
result=result.concat(c+"");
}
}
returnresult;
}
⑺ java十大演算法
演算法一：快速排序演算法
快速排序是由東尼·霍爾所發展的一種排序演算法。在平均狀況下，排序 n 個項目要Ο(n log n)次比較。在最壞狀況下則需要Ο(n2)次比較，但這種狀況並不常見。事實上，快速排序通常明顯比其他Ο(n log n) 演算法更快，因為它的內部循環（inner loop）可以在大部分的架構上很有效率地被實現出來。
快速排序使用分治法（Divide and conquer）策略來把一個串列（list）分為兩個子串列（sub-lists）。
演算法步驟：
1 從數列中挑出一個元素，稱為 "基準"（pivot），
2 重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面（相同的數可以到任一邊）。在這個分區退出之後，該基準就處於數列的中間位置。這個稱為分區（partition）操作。
3 遞歸地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序。
遞歸的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。雖然一直遞歸下去，但是這個演算法總會退出，因為在每次的迭代（iteration）中，它至少會把一個元素擺到它最後的位置去。
演算法二：堆排序演算法
堆排序（Heapsort）是指利用堆這種數據結構所設計的一種排序演算法。堆積是一個近似完全二叉樹的結構，並同時滿足堆積的性質：即子結點的鍵值或索引總是小於（或者大於）它的父節點。
堆排序的平均時間復雜度為Ο(nlogn) 。
演算法步驟：
創建一個堆H[0..n-1]
把堆首（最大值）和堆尾互換
3. 把堆的尺寸縮小1，並調用shift_down(0),目的是把新的數組頂端數據調整到相應位置
4. 重復步驟2，直到堆的尺寸為1
演算法三：歸並排序
歸並排序（Merge sort，台灣譯作：合並排序）是建立在歸並操作上的一種有效的排序演算法。該演算法是採用分治法（Divide and Conquer）的一個非常典型的應用。
演算法步驟：
1. 申請空間，使其大小為兩個已經排序序列之和，該空間用來存放合並後的序列
2. 設定兩個指針，最初位置分別為兩個已經排序序列的起始位置
3. 比較兩個指針所指向的元素，選擇相對小的元素放入到合並空間，並移動指針到下一位置
4. 重復步驟3直到某一指針達到序列尾
5. 將另一序列剩下的所有元素
⑻ Java 合並排序 求程序
網路文庫找了一個http://wenku..com/view/332fd62d453610661ed9f414.html
四、合並排序 1、基本思想
合並排序的基本操作是：首先將待排序序列劃分為兩個長度相等的子序列；然後分別對兩個子序列進行歸並排序，得到兩個有序的子序列；最後將兩個有序的子序列合並成一個有序數列。
MergeSort(A[2*n]) {
divide A[2*n] into A[1,……,n],A[n-1,……,2*n];//劃分 MergeSort(A[1,……,n]);//歸並排序前半個子序列
MergeSort(A[[n-1,……,2*n]);//歸並排序後半個子序列 Merge;//合並 }
2、演算法復雜度分析
合並步的時間復雜度為O(n)。合並排序演算法的時間復雜度為O(nlog2n)。
3、編程實現
public int[] MergeSort(int[] A, int[] tempA, int s, int t){
//如果序列中有一個以上的元素，即s<t則進行排序
if(s < t){
int center = (s + t) / 2;
MergeSort(A, tempA, s, center)
;//歸並排序前半個子序列
MergeSort(A, tempA, center + 1, t);
//歸並排序後半個子序列
Merge(A,tempA, s, center, t);
//合並
}
return tempA;
}
public int[] Merge(int[] A, int[] tempA, int s, int m, int t){ int n = t- s + 1;
//n為數據總個數
int i=s;j=m+1;k=s
while(i <= m&& j <= t){
//取A[i]和A[j]中較小者放入tempA[k]
if(A[i]<=A[j]){
tempA[k++] = A[i++]; }
else{
tempA[k++] = A[j++]; } }
if(i<=m) while(i<=m)
tempA[k++]=A[i++];//處理前一個子序列
else while(j<=t)
tempA[k++]=A[j++];//處理後一個子序列
return tempA;
}
⑼ java編程合並排序演算法
packagep1;
importjava.util.Arrays;
publicclassGuy
{
/**
*歸並排序
*/
privatestaticvoidmergeSort(int[]array,intstart,intend,int[]tempArray)
{
if(end<=start)
{
return;
}
intmiddle=(start+end)/2;
mergeSort(array,start,middle,tempArray);
mergeSort(array,middle+1,end,tempArray);
intk=0,leftIndex=0,rightIndex=end-start;
System.array(array,start,tempArray,0,middle-start+1);
for(inti=0;i<end-middle;i++)
{
tempArray[end-start-i]=array[middle+i+1];
}
while(k<end-start+1)
{
if(tempArray[rightIndex]>tempArray[leftIndex])//從小到大
{
array[k+start]=tempArray[leftIndex++];
}
else
{
array[k+start]=tempArray[rightIndex--];
}
k++;
}
}
publicstaticvoidmain(String[]args)
{
int[]array=newint[]{11,213,134,65,77,78,23,43};
mergeSort(array,0,array.length-1,newint[array.length]);
System.out.println(Arrays.toString(array));
}
}
⑽ java實現合並排序，且輸出每次合並的兩個數組段，及合並結果
package test; import java.util.Arrays;import java.util.Comparator; public class JButtonTest{ public static void main ( String[] args ) { int[] arr1 = { 3, 1, 23 }; int[] arr2 = { 27, 7, 2 }; String temp = Arrays.toString (arr1) + Arrays.toString (arr2); temp = temp.replaceAll ("\\]\\[", ",").replaceAll ("\\s", "").replaceAll ("[\\[\\]]", ""); String[] result = temp.split ("\\,"); System.out.println (Arrays.toString (result)); Arrays.sort (result, new Comparator<String> () { @Override public int compare ( String o1, String o2 ) { int a = Integer.parseInt (o1), b = Integer.parseInt (o2); if (a > b) { return 1; } else if (a < b) { return -1; } else { return 0; } } }); System.out.println (Arrays.toString (result)); }}