java線性
A. 怎麼用java代碼寫一個線性布局;布局裡面有兩個按鈕是水平的
android 使兩個按鈕水平排列的方法是使用lineLayout線性布局，如下代碼：
<?xmlversion="1.0"encoding="utf-8"?>
<LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="match_parent"
android:background="@color/background"
android:orientation="vertical">
<View
android:layout_width="wrap_content"
android:layout_height="1.2px"
android:layout_marginBottom="7dp"
android:background="@color/white"/>
<LinearLayout
android:layout_width="fill_parent"
android:layout_height="79dp"
android:layout_weight="2"
android:orientation="horizontal"
android:layout_margin="10dp">
<Button
android:id="@+id/bt1"
android:layout_width="fill_parent"
android:layout_height="26dp"
android:background="@drawable/shape"
android:layout_weight="1"
android:text="確認對沖"
android:textColor="@color/white"
android:textSize="15dp"/>
<Button
android:layout_width="fill_parent"
android:layout_height="26dp"
android:background="@drawable/shapeyuanjiao"
android:layout_weight="1"
android:text="取消"
android:textColor="@color/white"
android:textSize="15dp"/>
</LinearLayout>
</LinearLayout>
運行結果如下：
B. java程序怎麼線性執行
使用Runtime.getRuntime().exec()方法可以在java程序里運行外部程序。
1. exec(String command)
2. exec(String command, String envp[], File dir)
3. exec(String cmd, String envp[])
4. exec(String cmdarray[])
5. exec(String cmdarray[], String envp[])
6. exec(String cmdarray[], String envp[], File dir)
一般的應用程序可以直接使用第一版本，當有環境變數傳遞的時候使用後面的版本。其中2和6版本可以傳遞一個目錄，標識當前目錄，因為有些程序是使用相對目錄的，所以就要使用這個版本。
實例：
Process process = Runtime.getRuntime().exec(".\\p.exe");
process.waitfor();
在上面的程序中，第一行的「.\\p.exe」是要執行的程序名，Runtime.getRuntime()返回當前應用程序的Runtime對象，該對象的exec()方法指示Java虛擬機創建一個子進程執行指定的可執行程序，並返回與該子進程對應的Process對象實例。通過Process可以控制該子進程的執行或獲取該子進程的信息。第二條語句的目的等待子進程完成再往下執行。
C. Java中的map是線性結構嗎
map不是線性結構，常用的線性結構有：線性表，棧，隊列，雙隊列，數組，串。
數據結構中線性結構指的是數據元素之間存在著「一對一」的線性關系的數據結構。如（a1,a2,a3,.....,an）,a1為第一個元素，an為最後一個元素，此集合即為一個線性結構的集合。
而Map 集合是用存儲元素對（鍵值對）來存儲元素，每個鍵映射到一個值，不存在最後一個元素的說法，也沒前驅和後繼元素，所以是非線性的。
D. java關於線性表的編程
packageTest;
importjava.io.BufferedReader;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileNotFoundException;
importjava.io.FileReader;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.InputStreamReader;
importjava.io.Reader;
importjava.io.StringBufferInputStream;
importjava.io.StringReader;
importjava.util.Scanner;
classTest{
privatestaticNodefirstList,secondList,resultList;
privatestaticvoidinput(Nodehead)throwsException{
inta;
intb;
inti;
Nodep=head;
BufferedReaderreader=newBufferedReader(newInputStreamReader(
System.in));
//讀取一行信息
Stringinput=reader.readLine();
//以空格為分隔符，轉換成數組
String[]numbers=input.split("");
for(i=0;i<numbers.length;){
a=Integer.parseInt(numbers[i]);
b=Integer.parseInt(numbers[i+1]);
p.next=newNode(a,b);
p=p.next;
i+=2;
}
}
publicstaticvoidmain(String[]args)throwsException{
firstList=newNode();
secondList=newNode();
resultList=newNode();
Nodep=resultList;
System.out.println("輸入第一個多項式");
input(firstList);
System.out.println("輸入第二個不等式");
input(secondList);
while(firstList.next!=null&&secondList.next!=null){
if(firstList.next.zs>secondList.next.zs){
p.next=newNode(firstList.next.xs,firstList.next.zs);
p=p.next;
firstList=firstList.next;
}elseif(firstList.next.zs<secondList.next.zs){
p.next=newNode(secondList.next.xs,secondList.next.zs);
p=p.next;
secondList=secondList.next;
}else{
p.next=newNode(firstList.next.xs+secondList.next.xs,firstList.next.zs);
p=p.next;
firstList=firstList.next;
secondList=secondList.next;
}
}
if(firstList!=null){
p.next=firstList.next;
}
if(secondList!=null){
p.next=secondList.next;
}
p=resultList;
while(p.next!=null){
System.out.print(p.next.xs+"x^"+p.next.zs+"+");
p=p.next;
}
System.out.println();
}
}
publicclassNode{
publicintxs;//系數
publicintzs;//指數
publicNodenext=null;//指向下一個
publicNode(inta,intb){
xs=a;
zs=b;
}
publicNode(){
}
}答案
輸入第一個多項式
5 4 3 2 1 1
輸入第二個不等式
4 4 3 2 1 1
9x^4+6x^2+2x^1
E. java 線性表
import java.util.*;
public class MainList{
public static void main(String[] args) throws Exception {
int len,inpos,delpos;
Object yinsert;
List li=new List(20);
Scanner reader=new Scanner(System.in);
System.out.print("請輸入順序表的長度：");
len=reader.nextInt();
System.out.println("請輸入順序表的元素：");
for(int i=0;i<len;i++)
{
yinsert=reader.nextInt();
li.in(yinsert);
}
li.outprint();
System.out.print("請輸入插入的元素位置：");
inpos=reader.nextInt();
System.out.println();
System.out.print("請輸入需要插入的元素：");
yinsert=reader.nextInt();
System.out.println();
li.insert(inpos,yinsert);
li.outprint();
}
}
class List {
private Object[] listelem;
private int curlen;
List(int maxlen) {
curlen=0;
listelem=new Object[maxlen];
}
public int length(){
return curlen;
}
public void in(Object x) {
listelem[curlen]=x;
curlen++;
}
public void insert(int a,Object x)throws Exception{
if(a<0||a>listelem.length)
{throw new Exception("插入的位置不正確"); }
for(int i=curlen;i>a;i--)
{
listelem[i]=listelem[i-1];
}
listelem[a]=x;
curlen++;
}
public void outprint() {
System.out.print("當前順序表中的元素為：");
for(int z=0;z<curlen;z++) {
System.out.print(listelem[z]+" ");
}
System.out.println("當前順序表的長度為："+length());
}
}
我做了一點點修改，在輸入元素時，用空格將每個元素隔開即可！
回答你的問題：
你在用reader.nextInt()進行鍵盤讀入時，實際是返回的字元串類型的，因此你輸入長度為5，但只能輸入4個元素。實際上有五個元素，只不過第一個元素是空格而已！第二個問題也是出在reader.nextInt()上，道理一樣！
F. Java設計線性表排序演算法
import java.util.Scanner;
import java.util.Arrays;
public class P
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
float[] A=new float[1],B=new float[1];
int alen=0,blen=0,i,j,k;
String line;
System.out.println("請輸入線性表A的各元素,每行一個（輸入#結束）：");
while(true)
{
line=sc.nextLine();
if(line.equals("#"))
break;
A=Arrays.Of(A,++alen);
A[alen-1]=Float.parseFloat(line);
}
System.out.println("請輸入線性表B的各元素,每行一個（輸入#結束）：");
while(true)
{
line=sc.nextLine();
if(line.equals("#"))
break;
B=Arrays.Of(B,++blen);
B[blen-1]=Float.parseFloat(line);
}
Arrays.sort(A);
Arrays.sort(B);
System.out.println("升序排序後，線性表A的各元素是：");
for(i=0;i<alen;i++)
{
System.out.print(A[i]+" ");
}
System.out.println();
System.out.println();
System.out.println("升序排序後，線性表B的各元素是：");
for(i=0;i<blen;i++)
{
System.out.print(B[i]+" ");
}
System.out.println();
System.out.println();
A=Arrays.Of(A,alen+blen);
for(i=0;i<blen;i++)
{
if(B[i]>=A[alen-1])
A[alen++]=B[i];
else
{
for(j=0;j<alen-1;j++)
{
if(B[i]<=A[j])
break;
}
for(k=alen-1;k>=j;k--)
{
A[k+1]=A[k];
}
A[j]=B[i];
alen++;
}
}
System.out.println("線性表B按順序插入線性表A中後，線性表A的各元素是：");
for(i=0;i<alen;i++)
{
System.out.print(A[i]+" ");
}
sc.close();
}
}
G. java線性表編程（一定要用java語言）
借用樓上的代碼
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class Test {
public static void main(String[] args) {
List<Integer> l1 = new ArrayList<Integer>(Arrays.asList(3,5,8,11));
List<Integer> l2 = new ArrayList<Integer>(Arrays.asList(2,6,8,9,11,15,20));
List<Integer> tmp = new ArrayList<Integer>(l2);
tmp.removeAll(l1);
List<Integer> result = new ArrayList<Integer>(l1);
result.addAll(tmp);
System.out.println(result);
l1.addAll(l2);
Collections.sort(l1);
System.out.println(l1);
}
}
H. java 線性查找和二分查找的區別
一 線性查找
定義：在一列給定的值中進行搜索，從一端開始逐一檢查每個元素，直到找到所需元素的過程。
線性查找又稱為順序查找。如果查找池是某種類型的一個表，比如一個數組，簡單的查找方法是從表頭開始，一次將每一個值與目標元素進行比較。最後，或者查找到目標，或者達到表尾，而目標不存在於組中，這個方法稱為線性查找。
二 折半查找
定義：二分查找又稱折半查找，它是一種效率較高的查找方法。
【二分查找要求】：1.必須採用順序存儲結構 2.必須按關鍵字大小有序排列。
【優缺點】折半查找法的優點是比較次數少，查找速度快，平均性能好;其缺點是要求待查表為有序表，且插入刪除困難。因此，折半查找方法適用於不經常變動而查找頻繁的有序列表。
【演算法思想】首先，將表中間位置記錄的關鍵字與查找關鍵字比較，如果兩者相等，則查找成功；否則利用中間位置記錄將表分成前、後兩個子表，如果中間位置記錄的關鍵字大於查找關鍵字，則進一步查找前一子表，否則進一步查找後一子表。
重復以上過程，直到找到滿足條件的記錄，使查找成功，或直到子表不存在為止，此時查找不成功。
【演算法復雜度】假設其數組長度為n，其演算法復雜度為o（log（n））
折半查找法也稱為二分查找法，它充分利用了元素間的次序關系，採用分治策略，可在最壞的情況下用O(log n)完成搜索任務。它的基本思想是，將n個元素分成個數大致相同的兩半，取a[n/2]與欲查找的x作比較，如果x=a[n/2]則找到x，演算法終止。如 果x<a[n/2]，則我們只要在數組a的左半部繼續搜索x（這里假設數組元素呈升序排列）。如果x>a[n/2]，則我們只要在數組a的右 半部繼續搜索x。
I. java建立一個線性表
import java.util.ArrayList;
import java.util.List;
public class ListDemo {
public static void main(String[] args) {
int numLength = 10;
int deleteNum = 5;
List<Integer> list = new ArrayList<Integer>();
init(numLength,list);
delete(deleteNum,list);
print(list);
}
private static void print(List<Integer> list) {
for(int i=0;i<list.size();i++){
System.out.print(list.get(i) +"\t");
}
}
private static void delete(int deleteNum,List<Integer> list) {
for (int i=0;i<list.size();i++){
if((int)list.get(i)==deleteNum){
list.remove(i);
}
}
}
private static void init(int numLength,List<Integer> list) {
for(int i=1;i<=numLength;i++){
list.add(i);
}
}
}
//當然你要是把你的代碼貼上來就更好了，可以幫忙找出問題，另外也可以知道你對java了解到哪個程度了呵，給出的幫助可能更實際一些