数据结构代码教学java 数据结构代码实现

用java实现一个数据结构！

import java.io.IOException;

成都创新互联公司专注于企业成都全网营销、网站重做改版、阿拉尔网站定制设计、自适应品牌网站建设、HTML5、电子商务商城网站建设、集团公司官网建设、外贸网站制作、高端网站制作、响应式网页设计等建站业务，价格优惠性价比高，为阿拉尔等各大城市提供网站开发制作服务。

import java.util.Scanner;

public class LinkList {

private static Scanner san = new Scanner(System.in);

public static void main(String[] args) throws IOException {

List list = new List();

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

System.out.print("请输入第" + i + "个数: ");

list.add(san.nextInt());

list.print();

}

System.out.println("输入的数据如下: ");

list.print();

}

}

class node {

int data;

node next = this; // 指向自己

}

class List {

private node header = new node();

// 循环链表的尾部添加数据

public node add(int data) {

node current = new node();

node temp = header;

while (temp.next != header)

temp = temp.next;

current.data = data;

current.next = temp.next;

temp.next = current;

return current;

}

// 查询某个数字的位置 如果不在 返回-1；

public int search(int data) {

node temp = header;

int n = 0;

while (temp.next != header) {

temp = temp.next;

n++;

if (temp.data == data)

break;

}

if (temp.data == data)

return n;

else

return -1;

}

// 打印出整个链表

public void print() {

node temp = header;

while (temp.next != header) {

temp = temp.next;

System.out.print(temp.data + " ");

}

System.out.println();

}

// 插入数据

public node Insert(int pos, int data) {

node temp = header;

node current = new node();

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

if (temp.next != header) {

temp = temp.next;

} else

return null;

}

current.data = data;

if (temp.next != header) {

current.next = temp.next;

}

temp.next = current;

return current;

}

// 删除某个数据

public node del(int data) {

node temp = header;

node oldtemp = null;

node current = null;

while (temp.next != header) {

oldtemp = temp;

temp = temp.next;

if (temp.data == data) {

current = temp;

break;

}

}

if (current == header)

return null;

oldtemp.next = current.next;

return current;

}

}

数据结构JAVA编程求教

#includestdio.h /* EOF(=^Z或F6),NULL */

#define FALSE 0

#define OK 1

#define ERROR 0

typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */

#define N 9 /* 数据元素个数 */

typedef char KeyType; /* 设关键字域为字符型 */

typedef struct /* 数据元素类型 */

{

KeyType key;

int weight;

}ElemType;

ElemType r[N]={{'A',1},{'B',1},{'C',2},{'D',5},{'E',3},

         {'F',4},{'G',4},{'H',3},{'I',5}}; /* 数据元素(以教科书例9-1为例),全局变量 */

int sw[N+1]; /* 累计权值，全局变量 */

#define EQ(a,b) ((a)==(b))

#define LT(a,b) ((a)(b))

typedef struct

{

ElemType *elem; /* 数据元素存储空间基址，建表时按实际长度分配，0号单元留空 */

int length; /* 表长度 */

}SSTable;

Status Creat_Seq(SSTable *ST,int n)

{ /* 操作结果: 构造一个含n个数据元素的静态顺序查找表ST(数据来自全局数组r) */

int i;

(*ST).elem=(ElemType *)calloc(n+1,sizeof(ElemType)); /* 动态生成n个数据元素空间(0号单元不用) */

if(!(*ST).elem)

return ERROR;

for(i=1;i=n;i++)

*((*ST).elem+i)=r[i-1]; /* 将全局数组r的值依次赋给ST */

(*ST).length=n;

return OK;

}

void Ascend(SSTable *ST)

{ /* 重建静态查找表为按关键字非降序排序 */

int i,j,k;

for(i=1;i(*ST).length;i++)

{

k=i;

(*ST).elem[0]=(*ST).elem[i]; /* 待比较值存[0]单元 */

for(j=i+1;j=(*ST).length;j++)

if LT((*ST).elem[j].key,(*ST).elem[0].key)

{

  k=j;

  (*ST).elem[0]=(*ST).elem[j];

}

if(k!=i) /* 有更小的值则交换 */

{

(*ST).elem[k]=(*ST).elem[i];

(*ST).elem[i]=(*ST).elem[0];

}

}

}

Status Creat_Ord(SSTable *ST,int n)

{ /* 操作结果: 构造一个含n个数据元素的静态按关键字非降序查找表ST */

/* 数据来自全局数组r */

Status f;

f=Creat_Seq(ST,n);

if(f)

Ascend(ST);

return f;

}

Status Traverse(SSTable ST,void(*Visit)(ElemType))

{ /* 初始条件: 静态查找表ST存在，Visit()是对元素操作的应用函数 */

/* 操作结果: 按顺序对ST的每个元素调用函数Visit()一次且仅一次。 */

/* 一旦Visit()失败，则操作失败 */

ElemType *p;

int i;

p=++ST.elem; /* p指向第一个元素 */

for(i=1;i=ST.length;i++)

Visit(*p++);

return OK;

}

typedef ElemType TElemType;

typedef struct BiTNode

{

TElemType data;

struct BiTNode *lchild,*rchild; /* 左右孩子指针 */

}BiTNode,*BiTree;

Status SecondOptimal(BiTree *T, ElemType R[],int sw[],int low,int high)

{ /* 由有序表R[low..high]及其累计权值表sw(其中sw[0]==0)递归构造 */

/* 次优查找树T。*/

int i,j;

double min,dw;

i=low;

min=fabs(sw[high]-sw[low]);

dw=sw[high]+sw[low-1];

for(j=low+1;j=high;++j) /* 选择最小的△Pi值 */

if(fabs(dw-sw[j]-sw[j-1])min)

{

i=j;

min=fabs(dw-sw[j]-sw[j-1]);

}

*T=(BiTree)malloc(sizeof(BiTNode));

if(!*T)

return ERROR;

(*T)-data=R[i]; /* 生成结点 */

if(i==low)

(*T)-lchild=NULL; /* 左子树空 */

else

SecondOptimal((*T)-lchild,R,sw,low,i-1); /* 构造左子树 */

if(i==high)

(*T)-rchild=NULL; /* 右子树空 */

else

SecondOptimal((*T)-rchild,R,sw,i+1,high); /* 构造右子树 */

return OK;

}

void FindSW(int sw[],SSTable ST)

{ /* 按照有序表ST中各数据元素的Weight域求累计权值表sw */

int i;

sw[0]=0;

for(i=1;i=ST.length;i++)

sw[i]=sw[i-1]+ST.elem[i].weight;

}

typedef BiTree SOSTree; /* 次优查找树采用二叉链表的存储结构 */

Status CreateSOSTree(SOSTree *T,SSTable ST)

{ /* 由有序表ST构造一棵次优查找树T。ST的数据元素含有权域weight。*/

if(ST.length==0)

*T=NULL;

else

{

FindSW(sw,ST); /* 按照有序表ST中各数据元素的Weight域求累计权值表sw */

SecondOptimal(T,ST.elem,sw,1,ST.length);

}

return OK;

}

Status Search_SOSTree(SOSTree *T,KeyType key)

{ /* 在次优查找树T中查找关键字等于key的元素。找到则返回OK，否则返回FALSE */

while(*T) /* T非空 */

if((*T)-data.key==key)

return OK;

else if((*T)-data.keykey)

*T=(*T)-lchild;

else

*T=(*T)-rchild;

return FALSE; /* 顺序表中不存在待查元素 */

}

void print(ElemType c) /* Traverse()调用的函数 */

{

printf("(%c %d) ",c.key,c.weight);

}

void main()

{

SSTable st;

SOSTree t;

Status i;

KeyType s;

Creat_Ord(st,N); /* 由全局数组产生非降序静态查找表st */

Traverse(st,print);

CreateSOSTree(t,st); /* 由有序表构造一棵次优查找树 */

printf("\n请输入待查找的字符: ");

scanf("%c",s);

i=Search_SOSTree(t,s);

if(i)

printf("%c的权值是%d\n",s,t-data.weight);

else

printf("表中不存在此字符\n");

}

运行结果：

这个是数据结构上的一个源码，你用这个自己改一改试试吧

关于数据结构（java）的一个代码

描述栈抽象数据类型的SStack接口的声明

public interfaceSStackE //栈接口

{

boolean isEmpty(); //判断是否空栈，若空栈返回true

boolean push(E element); //元素element入栈，若操作成功返回true

E pop(); //出栈，返回当前栈顶元素，若栈空返回null

E get(); //取栈顶元素值，未出栈，若栈空返回null

}

顺序栈类具体操作方法的声明：

importdataStructure.linearList.SStack;

public classSeqStackE implements SStackE

//顺序栈类

{

private Object value[]; //存储栈的数据元素

private int top; //top为栈顶元素下标

public SeqStack(int capacity) //构造指定容量的空栈

{

this.value = newObject[Math.abs(capacity)];

this.top=-1;

}

public SeqStack() //构造默认容量的空栈

{

this(10);

}

public boolean isEmpty() //判断是否空栈，若空栈返回true

{

return this.top==-1;

}

public boolean push(E element) //元素element入栈，若操作成功返回true

{

if (element==null)

return false; //空对象（null）不能入栈

if (this.top==value.length-1) //若栈满，则扩充容量

{

Object[] temp = this.value;

this.value = newObject[temp.length*2];

for (int i=0; itemp.length;i++)

this.value[i] = temp[i];

}

this.top++;

this.value[this.top] = element;

return true;

}

public E pop() //出栈，返回当前栈顶元素，若栈空返回null

{

if (!isEmpty())

return (E)this.value[this.top--];

else

return null;

}

public E get() //取栈顶元素值，未出栈，栈顶元素未改变

{

if (!isEmpty())

return (E)this.value[this.top];

else

return null;

}

public String toString() //返回栈中各元素的字符串描述

{

String str="{";

if (this.top!=-1)

str +=this.value[this.top].toString();

for (int i=this.top-1; i=0; i--)

str += ","+this.value[i].toString();

return str+"} ";

}

实例引用public static void main(String args[])

{

SeqStackString stack = newSeqStackString(20);

System.out.print("Push: ");

char ch='a';

for(int i=0;i5;i++)

{

String str =(char)(ch+i)+"";

stack.push(str);

System.out.print(str+" ");

}

System.out.println("\n"+stack.toString());

System.out.print("Pop : ");

while(!stack.isEmpty()) //全部出栈

System.out.print(stack.pop().toString()+" ");

System.out.println();

}