「java线性查找」什么是线性查找

本篇文章给大家谈谈java线性查找，以及什么是线性查找对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、麻烦帮下忙，看下这个哪里错了~~多谢啦·~~~
• 2、java 基础 array arraylist..越详细越好。
• 3、java中ArrayList和LinkedList的区别
• 4、java线性查找算法的平均次数为什么是n/2
• 5、Java的线性查找，二分查找，冒泡排序，插入排序，快速排序的源代码

麻烦帮下忙，看下这个哪里错了~~多谢啦·~~~

import java.util.Scanner;

public class SearchAndSort {

public static void main(String[] args) {

System.out.print("输入序列的长度  ");

Scanner keyboard = new Scanner(System.in);

int n = keyboard.nextInt();

System.out.println("未排序的序列：");

int[] list = new int[n];

for (int i = 0; i  n; i++) {

list[i] = (int) (Math.random() * (n - 1) + 1);

System.out.print(list[i] + " ");

}

System.out.println(" ");

System.out.print("输入要查找的数  ");

Scanner board = new Scanner(System.in);

int data = board.nextInt();

for (int j = 0; j  n; j++) {

if (data == list[j]) {

System.out.println("线性查找用了" + (j + 1) + "次比较");

System.out.println("数" + data + "在原序列中的位置是" + (j + 1));

break;

} else if (j == (n - 1))

System.out.println("没有找到该数！");

}

for (int a = 0; a  n; a++) {

for (int b = a + 1; b  n; b++) {

if (list[a]  list[b]) {

int temp = list[b];

list[b] = list[a];

list[a] = temp;

}

}

}

System.out.println("排序之后的序列为:");

for (int c = 0; c  n; c++) {

System.out.print(list[c] + " ");

}

int low = 0;

int high = n - 1;

int mid = 0;

int ii = 0;

while (low = high) {

mid = (low + high) / 2;

int x = list[mid];

ii++;

if (x == data) {

System.out.println("");

System.out.println("折半查找用了" + ii + "次比较");

System.out.println("数" + data + "在排序好的序列中的位置是" + (mid + 1));

break;

} else if (x  data) {

low = mid + 1;

} else {

high = mid - 1;

}

if (low  high) {

System.out.println("里面没有这个数！");

break;

}

}

}

}

java 基础 array arraylist..越详细越好。

java.util

类 ArrayListE

java.lang.Object

java.util.AbstractCollectionE

java.util.AbstractListE

java.util.ArrayListE

所有已实现的接口：

Serializable, Cloneable, IterableE, CollectionE, ListE, RandomAccess

直接已知子类：

AttributeList, RoleList, RoleUnresolvedList

--------------------------------------------------------------------------------

public class ArrayListEextends AbstractListEimplements ListE, RandomAccess, Cloneable, SerializableList 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于 Vector 类，除了此类是不同步的。）

size、isEmpty、get、set、iterator 和 listIterator 操作都以固定时间运行。add 操作以分摊的固定时间 运行，也就是说，添加 n 个元素需要 O(n) 时间。其他所有操作都以线性时间运行（大体上讲）。与用于 LinkedList 实现的常数因子相比，此实现的常数因子较低。

每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素，其容量也自动增长。并未指定增长策略的细节，因为这不只是添加元素会带来分摊固定时间开销那样简单。

在添加大量元素前，应用程序可以使用 ensureCapacity 操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。

注意，此实现不是同步的。如果多个线程同时访问一个 ArrayList 实例，而其中至少一个线程从结构上修改了列表，那么它必须 保持外部同步。（结构上的修改是指任何添加或删除一个或多个元素的操作，或者显式调整底层数组的大小；仅仅设置元素的值不是结构上的修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方法将该列表“包装”起来。这最好在创建时完成，以防止意外对列表进行不同步的访问：

List list = Collections.synchronizedList(new ArrayList(...)); 此类的 iterator 和 listIterator 方法返回的迭代器是快速失败的：在创建迭代器之后，除非通过迭代器自身的 remove 或 add 方法从结构上对列表进行修改，否则在任何时间以任何方式对列表进行修改，迭代器都会抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，而不是冒着在将来某个不确定时间发生任意不确定行为的风险。

注意，迭代器的快速失败行为无法得到保证，因为一般来说，不可能对是否出现不同步并发修改做出任何硬性保证。快速失败迭代器会尽最大努力抛出 ConcurrentModificationException。因此，为提高这类迭代器的正确性而编写一个依赖于此异常的程序是错误的做法：迭代器的快速失败行为应该仅用于检测 bug。

此类是 Java Collections Framework 的成员。

构造方法详细信息

ArrayList

public ArrayList(int initialCapacity)构造一个具有指定初始容量的空列表。

参数：

initialCapacity - 列表的初始容量

抛出：

IllegalArgumentException - 如果指定的初始容量为负

--------------------------------------------------------------------------------

ArrayList

public ArrayList()构造一个初始容量为 10 的空列表。

--------------------------------------------------------------------------------

ArrayList

public ArrayList(Collection? extends E c)构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。

参数：

c - 其元素将放置在此列表中的 collection

抛出：

NullPointerException - 如果指定的 collection 为 null

方法详细信息

trimToSize

public void trimToSize()将此 ArrayList 实例的容量调整为列表的当前大小。应用程序可以使用此操作来最小化 ArrayList 实例的存储量。

--------------------------------------------------------------------------------

ensureCapacity

public void ensureCapacity(int minCapacity)如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。

参数：

minCapacity - 所需的最小容量

--------------------------------------------------------------------------------

size

public int size()返回此列表中的元素数。

指定者：

接口 CollectionE 中的 size

指定者：

接口 ListE 中的 size

指定者：

类 AbstractCollectionE 中的 size

返回：

此列表中的元素数

--------------------------------------------------------------------------------

isEmpty

public boolean isEmpty()如果此列表中没有元素，则返回 true

指定者：

接口 CollectionE 中的 isEmpty

指定者：

接口 ListE 中的 isEmpty

覆盖：

类 AbstractCollectionE 中的 isEmpty

返回：

如果此列表中没有元素，则返回 true

--------------------------------------------------------------------------------

contains

public boolean contains(Object o)如果此列表中包含指定的元素，则返回 true。更确切地讲，当且仅当此列表包含至少一个满足 (o==null ? e==null : o.equals(e)) 的元素 e 时，则返回 true。

指定者：

接口 CollectionE 中的 contains

指定者：

接口 ListE 中的 contains

覆盖：

类 AbstractCollectionE 中的 contains

参数：

o - 测试此列表中是否存在的元素

返回：

如果此列表包含特定的元素，则返回 true

--------------------------------------------------------------------------------

indexOf

public int indexOf(Object o)返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。更确切地讲，返回满足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引 i ，如果不存在此类索引，则返回 -1。

指定者：

接口 ListE 中的 indexOf

覆盖：

类 AbstractListE 中的 indexOf

参数：

o - 要搜索的元素

返回：

此列表中第一次出现的指定元素的索引，如果列表不包含该元素，则返回 -1

--------------------------------------------------------------------------------

lastIndexOf

public int lastIndexOf(Object o)返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。更确切地讲，返回满足 (o==null ? get(i)==null : o.equals(get(i))) 的最高索引 i，如果不存在此类索引，则返回 -1。

指定者：

接口 ListE 中的 lastIndexOf

覆盖：

类 AbstractListE 中的 lastIndexOf

参数：

o - 要搜索的元素

返回：

列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1

--------------------------------------------------------------------------------

clone

public Object clone()返回此 ArrayList 实例的浅表副本。（不复制这些元素本身。）

覆盖：

类 Object 中的 clone

返回：

此 ArrayList 实例的一个副本

另请参见：

Cloneable

--------------------------------------------------------------------------------

toArray

public Object[] toArray()按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。

由于此列表不维护对返回数组的任何引用，，因而它将是“安全的”。（换句话说，此方法必须分配一个新的数组）。因此，调用者可以自由地修改返回的数组。

此方法担当基于数组的 API 和基于 collection 的 API 之间的桥梁。

指定者：

接口 CollectionE 中的 toArray

指定者：

接口 ListE 中的 toArray

覆盖：

类 AbstractCollectionE 中的 toArray

返回：

包含此列表中所有元素的数组（按适当顺序）

另请参见：

Arrays.asList(Object[])

--------------------------------------------------------------------------------

toArray

public T T[] toArray(T[] a)按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。如果指定的数组能容纳列表，则将该列表返回此处。否则，将分配一个具有指定数组的运行时类型和此列表大小的新数组。

如果指定的数组能容纳队列，并有剩余的空间（即数组的元素比队列多），那么会将数组中紧接 collection 尾部的元素设置为 null。（仅 在调用者知道列表中不包含任何 null 元素时才能用此方法确定列表长度）。

指定者：

接口 CollectionE 中的 toArray

指定者：

接口 ListE 中的 toArray

覆盖：

类 AbstractCollectionE 中的 toArray

参数：

a - 要在其中存储列表元素的数组（如果它足够大）；否则，为此分配一个具有相同运行时类型的新数组。

返回：

包含列表元素的数组

抛出：

ArrayStoreException - 如果指定数组的运行时类型不是此列表每个元素的运行时类型的超类型

NullPointerException - 如果指定数组为 null

--------------------------------------------------------------------------------

get

public E get(int index)返回此列表中指定位置上的元素。

指定者：

接口 ListE 中的 get

指定者：

类 AbstractListE 中的 get

参数：

index - 要返回元素的索引

返回：

此列表中指定位置上的元素

抛出：

IndexOutOfBoundsException - 如果索引超出范围 (index 0 || index = size())

--------------------------------------------------------------------------------

set

public E set(int index,

E element)用指定的元素替代此列表中指定位置上的元素。

指定者：

接口 ListE 中的 set

覆盖：

类 AbstractListE 中的 set

参数：

index - 要替代的元素的索引

element - 存储在指定位置上的元素

返回：

以前位于该指定位置上的元素

抛出：

IndexOutOfBoundsException - 如果索引超出范围 (index 0 || index = size())

--------------------------------------------------------------------------------

add

public boolean add(E e)将指定的元素添加到此列表的尾部。

指定者：

接口 CollectionE 中的 add

指定者：

接口 ListE 中的 add

覆盖：

类 AbstractListE 中的 add

参数：

e - 要添加到此列表中的元素

返回：

true（按照 Collection.add(E) 的指定）

--------------------------------------------------------------------------------

add

public void add(int index,

E element)将指定的元素插入此列表中的指定位置。向右移动当前位于该位置的元素（如果有）以及所有后续元素（将其索引加 1）。

指定者：

接口 ListE 中的 add

覆盖：

类 AbstractListE 中的 add

参数：

index - 指定元素所插入位置的索引

element - 要插入的元素

抛出：

IndexOutOfBoundsException - 如果索引超出范围 (index 0 || index size())

--------------------------------------------------------------------------------

remove

public E remove(int index)移除此列表中指定位置上的元素。向左移动所有后续元素（将其索引减 1）。

指定者：

接口 ListE 中的 remove

覆盖：

类 AbstractListE 中的 remove

参数：

index - 要移除的元素的索引

返回：

从列表中移除的元素

抛出：

IndexOutOfBoundsException - 如果索引超出范围 (index 0 || index = size())

--------------------------------------------------------------------------------

remove

public boolean remove(Object o)移除此列表中首次出现的指定元素（如果存在）。如果列表不包含此元素，则列表不做改动。更确切地讲，移除满足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引的元素（如果存在此类元素）。如果列表中包含指定的元素，则返回 true（或者等同于这种情况：如果列表由于调用而发生更改，则返回 true）。

指定者：

接口 CollectionE 中的 remove

指定者：

接口 ListE 中的 remove

覆盖：

类 AbstractCollectionE 中的 remove

参数：

o - 要从此列表中移除的元素（如果存在）

返回：

如果此列表包含指定的元素，则返回 true

--------------------------------------------------------------------------------

clear

public void clear()移除此列表中的所有元素。此调用返回后，列表将为空。

指定者：

接口 CollectionE 中的 clear

指定者：

接口 ListE 中的 clear

覆盖：

类 AbstractListE 中的 clear

--------------------------------------------------------------------------------

addAll

public boolean addAll(Collection? extends E c)按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。如果正在进行此操作时修改指定的 collection ，那么此操作的行为是不确定的。（这意味着如果指定的 collection 是此列表且此列表是非空的，那么此调用的行为是不确定的）。

指定者：

接口 CollectionE 中的 addAll

指定者：

接口 ListE 中的 addAll

覆盖：

类 AbstractCollectionE 中的 addAll

参数：

c - 包含要添加到此列表中的元素的 collection

返回：

如果此列表由于调用而发生更改，则返回 true

抛出：

NullPointerException - 如果指定的 collection 为 null

另请参见：

AbstractCollection.add(Object)

--------------------------------------------------------------------------------

addAll

public boolean addAll(int index,

Collection? extends E c)从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。向右移动当前位于该位置的元素（如果有）以及所有后续元素（增加其索引）。新元素将按照指定 collection 的迭代器所返回的元素顺序出现在列表中。

指定者：

接口 ListE 中的 addAll

覆盖：

类 AbstractListE 中的 addAll

参数：

index - 插入指定 collection 中的首个元素的位置索引

c - 包含要添加到此列表中元素的 collection

返回：

如果此列表由于调用而发生更改，则返回 true

抛出：

IndexOutOfBoundsException - 如果索引超出范围 (index 0 || index size())

NullPointerException - 如果指定的 collection 为 null

--------------------------------------------------------------------------------

removeRange

protected void removeRange(int fromIndex,

int toIndex)移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。向左移动所有后续元素（减小其索引）。此调用将列表缩短了 (toIndex - fromIndex) 个元素。（如果 toIndex==fromIndex，则此操作无效。）

覆盖：

类 AbstractListE 中的 removeRange

参数：

fromIndex - 要移除的首个元素的索引

toIndex - 最后一个要移除的元素后面那个元素的索引

抛出：

IndexOutOfBoundsException - 如果 fromIndex 或 toIndex 超出范围 (fromIndex 0 || fromIndex = size() || toIndex size() || toIndex fromIndex)

---------------------------------------------------------------------

from java API

java中ArrayList和LinkedList的区别

java中的arraylist和linkedlist的区别如下:

1．对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的。对ArrayList而言，主要是在内部数组中增加一项，指向所添加的元素，偶尔可能会导致对数组重新进行分配；而对LinkedList而言，这个开销是统一的，分配一个内部Entry对象。

2．在ArrayList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在LinkedList的中间插入或删除一个元素的开销是固定的。

3．LinkedList不支持高效的随机元素访问。

4．ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间

可以这样说：当操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能；当你的操作是在一列数据的前面或中间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。

java线性查找算法的平均次数为什么是n/2

平均次数是(n+1)/2，不是n/2。

被查找的数是第1个数，则需用第1个数和被查找的数比较，要比较1次。

被查找的数是第2个数，则需用第1个数、第2个数和被查找的数比较，要比较2次。

...

被查找的数是第n个数，则需用第1个数、第2个数、...、第n个数和被查找的数比较，要比较n次。

平均次数为(1+2+...+n)/n=(n+1)/2。

Java的线性查找，二分查找，冒泡排序，插入排序，快速排序的源代码

C++的，只要把，函数名改下，输出语句改下，就可以了。希望对你有帮助

void Sort :: SelectionSort(int a[],int n)

{

bool sorted=false;

cout"中间过程为："endl;

for(int size=n;!sorted size1;size--){

int pos = 0;

sorted = true;

for(int i=1;isize;i++)

if(a[pos]=a[i])pos=i;

else sorted=false;

Swap(a[pos],a[size-1]);

for(int j=0;j!=n;j++){//显示中间过程

couta[j]" ";

}

coutendl;

}

cout"选择排序结果为："endl;

for(int i=0;i!=n;i++){

couta[i]" ";

}

coutendl;

}

/*

冒泡排序

*/

bool Sort :: Bubble(int a[],int m,int n)

{

bool swapped=false;

for(int i=0;im-1;i++){

if(a[i]a[i+1]){

Swap(a[i],a[i+1]);

swapped=true;

for(int j=0;j!=n;j++){//显示中间过程

couta[j]" ";

}

coutendl;

}

}

return swapped;

}

void Sort :: BubbleSort(int a[],int n)

{

cout"中间过程为："endl;

for(int i=n;i1 Bubble(a,i,n);i--);

coutendl;

cout"冒泡排序结果为："endl;

for(i=0;i!=n;i++){

couta[i]" ";

}

coutendl;

}

/*

插入排序

*/

void Sort :: InsertionSort(int a[],int n)

{

cout"中间过程为："endl;

for (int i=1;in;i++){

int t=a[i];

int j;

for (j=i-1;j=0 ta[j];j--){

a[j+1]=a[j];

}

a[j+1]=t;

for(int k=0;k!=n;k++){//显示中间过程

couta[k]" ";

}

coutendl;

}

cout"插入排序结果为："endl;

for(i=0;i!=n;i++){

couta[i]" ";

}

coutendl;

}

/*

基数排序

*/

void Sort :: RadixSort(int a[],int n)

{

int d=1;

int m=10;

for (int i=0;in;i++){

while(a[i]=m){

m*=10;

++d;

}

}

int *t=new int[n];

int *count=new int [10];

int radix=1,k;

for(i=1;i=d;i++){

for(int j=0;j10;j++){

count[j]=0;//每次分配前清空计数器

}

for(j=0;jn;j++){

k=(a[j]/radix)%10;//统计每个桶中的记录数

count[k]++;

}

cout"分桶显示："endl;

for(j=0;j10;j++){//显示中间xiangxi过程

if(count[j]!=0){

coutj": ";

for(int l=0;ln;l++){

if ((a[l]/radix)%10==j)

couta[l]" ";

}

coutendl;

}

}

coutendl;

for(j=1;j10;j++){

count[j]=count[j-1]+count[j];

}

for(j=n-1;j=0;j--){

k=(a[j]/radix)%10;

count[k]--;

t[count[k]]=a[j];

}

for(j = 0;j n;j++) {

a[j]=t[j];

}

radix=radix*10;

cout"按桶依次排序排序："endl;

for(j=0;j!=n;j++){//显示中间过程

couta[j]" ";

}

coutendl;

}

delete[] t;

delete[] count;

cout"基数排序结果为："endl;

for(i=0;i!=n;i++){

couta[i]" ";

}

coutendl;

}

java线性查找的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于什么是线性查找、java线性查找的信息别忘了在本站进行查找喔。