初识数据结构与算法

数据结构：

1.概念：

数据结构：数据之间的关系，提高程序效率。

逻辑关系：（人为认为）

（1）、集合：在一个范围内有多个数据，数据之间没有关系。

（2）、线性：1对1的关系

（3）、树型：1对多的关系

（4）、图：多对多的关系

物理关系：内存存储

1、顺序存储：数组（array）

2、链式存储：链表（node相连）

数据结构难不难：容易但是很难。

数据结构有没有用：有用且没有用，锻炼自己的思维能力。

ArrayList:

数组与集合的区别：动态大小。

ArrayList底层也是由array实现，动态大小的实现是如果放不下就新增一个更大的array来代替原数组实现的。

在ArrayList中删除数据的时候，先是删除该index中的数据，之后所有数据向前移动，后面每个数据的索引都会发生改变。

注意：在对ArrayList循环删除的时候，从后往前遍历效率高。

ArrayList删除数据：删除前面的数据效率低，删除后面的效率高。

LinkedList删除数据：删除前面和后面的数据效率高，越中间效率越低。

栈：数组和链表都可以实现，数组实现固定栈（栈的容量数量是固定的），链表可以实现动态栈。

队列：链表实现更加简单，效率更高。

递归算法：自己调用自己。典型的使用递归的地方：树的遍历。（不断寻找子节点的过程）文件夹（典型的树型结构）

重点：定义方法的参数。

代码实现八皇后：

package test;
public class test {

static int[][] map = new int[8][8];  //表示棋盘，0表示没有皇后，1表示有皇后
public static void main(String[] args){
play(0);
}
static int count = 1;

//显示棋盘
static void show(){
System.out.println("第"+count+"种摆法");
count++;
for(int i=0;i<8;i++){
for(int j=0;j<8;j++){
System.out.print(map[i][j]+" ");
}
System.out.println();
}
}
//验证此位置是否可以放皇后
static boolean check(int row,int col){
if(row==0){
return true;
}
else{

//验证上面
for(int i=row-1;i>=0;i++){
if(map[i][col]==1){
return false;
}
}
//验证左上方
for(int i=row-1,j=col-1;i>=0&&j>=0;i--,j--){
if(map[i][j]==1){
return false;
}
}
//验证右上方
for(int i=row-1,j=col+1;i>=0&&j<8;i--,j++){
if(map[i][j]==1){
return false;
}
}
return true;
}


}
static void play(int row){
//遍历当前行的所有单元格
for(int i=0;i<8;i++){
if(check(row,i)){
map[row][i]=1;
}
if(row==7){
show();
//当最后一个皇后摆好后，去掉这个皇后，推翻原来的摆放，进入到下一种排列
}
else{
play(row+1);

//当调用自己结束后，说明这次摆放是不成立的，去掉这个皇后，推翻这次摆放

}
map[row][i]=0;//去掉皇后
}

}

}

二叉树：

关于二叉树的遍历：

前序遍历：打左右。（对于每个节点来说，打印当前节点，再进行左边节点，再进行右边节点）

中序遍历：左打右。（对于每个节点来说，先打印左边节点，再打印父节点，再进行右边节点）

后序遍历：左右打。（对于每个节点来说，先打印左边节点，再进行右边节点，再进行父节点）

打：打印父节点的意思

（1）使用数组表示二叉树：堆排序

（2）使用链表表示二叉树：中序排序（1.必须为顺序二叉树，2.必须为中序遍历）

顺序二叉树：和父节点比较，小的为左子树，大的为右子树。

实现中序排序的代码：

1、Node.java

package doubleTree;
public class Node {
int value;
Node left;
Node right;
public Node(int value){
this.value = value;
}
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
public Node getLeft() {
return left;
}
public void setLeft(Node left) {
this.left = left;
}
public Node getRight() {
return right;
}
public void setRight(Node right) {
this.right = right;
}

}

2、DoubleTree.java

package doubleTree;


public class DoubleTree {

Node root;
public void add(int value){


Node node = new Node(value);
if(root==null){
root = node;
}
else{
Node temp = root;
while(true){
if(value<temp.getValue()) //小的放左边
{
if(temp.getLeft()==null){
temp.setLeft(node);
break;
}
else{
temp = temp.getLeft();
}
}
else{
if(temp.getRight()==null){
temp.setRight(node);
break;
}
else{
temp = temp.getRight();
}
}
}
}

}


public void show(){
showNode(root);
}

private void showNode(Node pNode){
//System.out.println(pNode.getValue());    前序遍历
if(pNode.getLeft()!=null){
showNode(pNode.getLeft());
}
System.out.println(pNode.getValue());   //中序遍历
if(pNode.getRight()!=null){
showNode(pNode.getRight());
}
//System.out.println(pNode.getValue());    后序遍历

}

}

3、test.java

package doubleTree;


public class test {

public static void main(String[] args){
DoubleTree dt = new DoubleTree();
dt.add(5);
dt.add(2);
dt.add(7);
dt.add(4);
dt.add(6);
dt.add(9);
dt.add(3);
dt.add(6);
dt.add(8);
dt.show();
}
}