您的位置:

单链表快速排序的java实现(单链表快速排序的java实现语句)

本文目录一览:

用JAVA实现快速排序算法?

本人特地给你编的代码

亲测

public class QuickSort {

public static int Partition(int a[],int p,int r){

int x=a[r-1];

int i=p-1;

int temp;

for(int j=p;j=r-1;j++){

if(a[j-1]=x){

// swap(a[j-1],a[i-1]);

i++;

temp=a[j-1];

a[j-1]=a[i-1];

a[i-1]=temp;

}

}

//swap(a[r-1,a[i+1-1]);

temp=a[r-1];

a[r-1]=a[i+1-1];

a[i+1-1]=temp;

return i+1;

}

public static void QuickSort(int a[],int p,int r){

if(pr){

int q=Partition(a,p,r);

QuickSort(a,p,q-1);

QuickSort(a,q+1,r);

}

}

public static void main(String[] stra){

int a[]={23,53,77,36,84,76,93,13,45,23};

QuickSort(a,1,10);

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

System.out.println(a[i-1]);

}

}

那位大大能详细的讲解一下JAVA中的快速排序

快速排序是对冒泡排序的一种改进。它的基本思想是:通过一躺排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按次方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。最坏情况的时间复杂度为O(n2),最好情况时间复杂度为O(nlog2n)。

另外 java没指针概念 可以认为是句柄

假设要排序的数组是A[1]……A[N],首先任意选取一个数据(通常选用第一个数据)作为关键数据,然后将所有比它的数都放到它前面,所有比它大的数都放到它后面,这个过程称为一躺快速排序。一趟快速排序的算法是:

1)、设置两个变量I、J,排序开始的时候I:=1,J:=N;

2)以第一个数组元素作为关键数据,赋值给X,即X:=A[1];

3)、从J开始向前搜索,即由后开始向前搜索(J:=J-1),找到第一个小于X的值,两者交换;

4)、从I开始向后搜索,即由前开始向后搜索(I:=I+1),找到第一个大于X的值,两者交换;

5)、重复第3、4步,直到I=J;

例如:待排序的数组A的值分别是:(初始关键数据X:=49)

A[1] A[2] A[3] A[4] A[5] A[6] A[7]:

49 38 65 97 76 13 27

进行第一次交换后: 27 38 65 97 76 13 49

( 按照算法的第三步从后面开始找)

进行第二次交换后: 27 38 49 97 76 13 65

( 按照算法的第四步从前面开始找X的值,6549,两者交换,此时I:=3 )

进行第三次交换后: 27 38 13 97 76 49 65

( 按照算法的第五步将又一次执行算法的第三步从后开始找)

进行第四次交换后: 27 38 13 49 76 97 65

( 按照算法的第四步从前面开始找大于X的值,9749,两者交换,此时J:=4 )

此时再执行第三步的时候就发现I=J,从而结束一躺快速排序,那么经过一躺快速排序之后的结果是:27 38 13 49 76 97 65,即所以大于49的数全部在49的后面,所以小于49的数全部在49的前面。

快速排序就是递归调用此过程——在以49为中点分割这个数据序列,分别对前面一部分和后面一部分进行类似的快速排序,从而完成全部数据序列的快速排序,最后把此数据序列变成一个有序的序列,根据这种思想对于上述数组A的快速排序的全过程如图6所示:

初始状态 {49 38 65 97 76 13 27}

进行一次快速排序之后划分为 {27 38 13} 49 {76 97 65}

分别对前后两部分进行快速排序 {13} 27 {38}

结束 结束 {49 65} 76 {97}

49 {65} 结束

结束//下面是一个示例,哪位给说说快速排序法的原理,下面的示例中指针和上下标移动我看不太懂,

public class QuickSort {

/**主方法*/

public static void main(String[] args) {

//声明数组

int[] nums = {27, 8, 57, 9, 23, 41, 65, 19, 0, 1, 2, 4, 5};

//应用快速排序方法

quickSort(nums, 0, nums.length-1);

//显示排序后的数组

for(int i = 0; i nums.length; ++i) {

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

}

System.out.println("");

}

/**快速排序方法*/

public static void quickSort(int[] a, int lo0, int hi0) {

int lo = lo0;

int hi = hi0;

if (lo = hi)

return;

//确定指针方向的逻辑变量

boolean transfer=true;

while (lo != hi) {

if (a[lo] a[hi]) {

//交换数字

int temp = a[lo];

a[lo] = a[hi];

a[hi] = temp;

//决定下标移动,还是上标移动

transfer = (transfer == true) ? false : true;

}

//将指针向前或者向后移动

if(transfer)

hi--;

else

lo++;

//显示每一次指针移动的数组数字的变化

/*for(int i = 0; i a.length; ++i) {

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

}

System.out.print(" (lo,hi) = " + "(" + lo + "," + hi + ")");

System.out.println("");*/

}

//将数组分开两半,确定每个数字的正确位置

lo--;

hi++;

quickSort(a, lo0, lo);

quickSort(a, hi, hi0);

}

}

java如何实现链表

链表是一种重要的数据结构,在程序设计中占有很重要的地位。C语言和C++语言中是用指针来实现链表结构的,由于Java语言不提供指针,所以有人认为在Java语言中不能实现链表,其实不然,Java语言比C和C++更容易实现链表结构。Java语言中的对象引用实际上是一个指针(本文中的指针均为概念上的意义,而非语言提供的数据类型),所以我们可以编写这样的类来实现链表中的结点。

class Node

{

Object data;

Node next;//指向下一个结点

}

将数据域定义成Object类是因为Object类是广义超类,任何类对象都可以给其赋值,增加了代码的通用性。为了使链表可以被访问还需要定义一个表头,表头必须包含指向第一个结点的指针和指向当前结点的指针。为了便于在链表尾部增加结点,还可以增加一指向链表尾部的指针,另外还可以用一个域来表示链表的大小,当调用者想得到链表的大小时,不必遍历整个链表。下图是这种链表的示意图:

链表的数据结构

我们可以用类List来实现链表结构,用变量Head、Tail、Length、Pointer来实现表头。存储当前结点的指针时有一定的技巧,Pointer并非存储指向当前结点的指针,而是存储指向它的前趋结点的指针,当其值为null时表示当前结点是第一个结点。那么为什么要这样做呢?这是因为当删除当前结点后仍需保证剩下的结点构成链表,如果Pointer指向当前结点,则会给操作带来很大困难。那么如何得到当前结点呢,我们定义了一个方法cursor(),返回值是指向当前结点的指针。类List还定义了一些方法来实现对链表的基本操作,通过运用这些基本操作我们可以对链表进行各种操作。例如reset()方法使第一个结点成为当前结点。insert(Object d)方法在当前结点前插入一个结点,并使其成为当前结点。remove()方法删除当前结点同时返回其内容,并使其后继结点成为当前结点,如果删除的是最后一个结点,则第一个结点变为当前结点。

链表类List的源代码如下:

import java.io.*;

public class List

{

/*用变量来实现表头*/

private Node Head=null;

private Node Tail=null;

private Node Pointer=null;

private int Length=0;

public void deleteAll()

/*清空整个链表*/

{

Head=null;

Tail=null;

Pointer=null;

Length=0;

}

public void reset()

/*链表复位,使第一个结点成为当前结点*/

{

Pointer=null;

}

public boolean isEmpty()

/*判断链表是否为空*/

{

return(Length==0);

}

public boolean isEnd()

/*判断当前结点是否为最后一个结点*/

{

if(Length==0)

 throw new java.lang.NullPointerException();

else if(Length==1)

 return true;

else

 return(cursor()==Tail);

}

public Object nextNode()

/*返回当前结点的下一个结点的值,并使其成为当前结点*/

{

if(Length==1)

 throw new java.util.NoSuchElementException();

else if(Length==0)

 throw new java.lang.NullPointerException();

else

{

 Node temp=cursor();

 Pointer=temp;

 if(temp!=Tail)

return(temp.next.data);

 else

throw new java.util.NoSuchElementException();

}

}

public Object currentNode()

/*返回当前结点的值*/

{

Node temp=cursor();

return temp.data;

}

public void insert(Object d)

/*在当前结点前插入一个结点,并使其成为当前结点*/

{

Node e=new Node(d);

if(Length==0)

{

 Tail=e;

 Head=e;

}

else

{

 Node temp=cursor();

 e.next=temp;

 if(Pointer==null)

Head=e;

 else

Pointer.next=e;

}

Length++;

}

public int size()

/*返回链表的大小*/

{

return (Length);

}

public Object remove()

/*将当前结点移出链表,下一个结点成为当前结点,如果移出的结点是最后一个结点,则第一个结点成为当前结点*/

{

Object temp;

if(Length==0)

 throw new java.util.NoSuchElementException();

else if(Length==1)

{

 temp=Head.data;

 deleteAll();

}

else

{

 Node cur=cursor();

 temp=cur.data;

 if(cur==Head)

Head=cur.next;

 else if(cur==Tail)

 {

Pointer.next=null;

Tail=Pointer;

reset();

 }

 else

Pointer.next=cur.next;

Length--;

}

return temp;

}

private Node cursor()

/*返回当前结点的指针*/

{

if(Head==null)

 throw new java.lang.NullPointerException();

else if(Pointer==null)

 return Head;

else

 return Pointer.next;

}

public static void main(String[] args)

/*链表的简单应用举例*/

{

List a=new List ();

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

 a.insert(new Integer(i));

 System.out.println(a.currentNode());

 while(!a.isEnd())

System.out.println(a.nextNode());

a.reset();

while(!a.isEnd())

{

 a.remove();

}

a.remove();

a.reset();

if(a.isEmpty())

 System.out.println("There is no Node in List \n");

 System.in.println("You can press return to quit\n");

try

{

 System.in.read();

 //确保用户看清程序运行结果

}

catch(IOException e)

{}

 }

}

class Node

/*构成链表的结点定义*/

{

 Object data;

 Node next;

 Node(Object d)

 {

data=d;

next=null;

 }

}

读者还可以根据实际需要定义新的方法来对链表进行操作。双向链表可以用类似的方法实现只是结点的类增加了一个指向前趋结点的指针。

可以用这样的代码来实现:

class Node

{

Object data;

Node next;

Node previous;

Node(Object d)

{

data=d;

next=null;

previous=null;

}

}

当然,双向链表基本操作的实现略有不同。链表和双向链表的实现方法,也可以用在堆栈和队列的实现中,这里就不再多写了,有兴趣的读者可以将List类的代码稍加改动即可。

希望对你有帮助。

java 单链表排序问题

你的这个类,按照你的意思,应该有处理链表的方法。

比如有class A{

//there are many methods which you use them to do different jobs.

LinkList sort(LinkList p)

{

//处理链表排序

//返回链表

}

}

在你的主函数中,new 一个A,用A的对象调用A中那个排序的方法。作为一个方法写在一个类中,提高了代码的复用性。如果写在主函数中,首先,看起来,很不爽,其次,如果你的程序中需要多次调用,你就没啥子办法。JAVA中不能使用GOTO语句。