数据结构代码教学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();
}
新闻标题：数据结构代码教学java 数据结构代码实现
URL标题：http://scyanting.com/article/hpdshi.html
