本文介绍了Java中的数据结构，包括数组、栈、队列、链表、树、图、堆和散列表，以及算法的基本特征和设计原则。讨论了数据结构和算法的关系，并通过约瑟夫问题举例说明算法的应用。
目录
数据结构
数据结构是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的数据元素的集合。
数据结构往往同高效的检索算法和索引技术有关。
数据结构的基本功能
①如何插入一条新的数据项
②如何寻找某一特定的数据项
③如何删除某一特定的数据项
④如何迭代的访问各个数据项，以便进行显示或其他操作
种类
数组(Array)
数组是一种聚合数据类型，它是将具有相同类型的若干变量有序地组织在一起的集合。数组可以说是最基本的数据结构，在各种编程语言中都有对应。一个数组可以分解为多个数组元素，按照数据元素的类型，数组可以分为整型数组、字符型数组、浮点型数组、指针数组和结构数组等。数组还可以有一维、二维以及多维等表现形式。
栈(Stack)
栈是一种特殊的线性表，它只能在一个表的一个固定端进行数据结点的插入和删除操作。栈按照后进先出的原则来存储数据，也就是说，先插入的数据将被压入栈底，最后插入的数据在栈顶，读出数据时，从栈顶开始逐个读出。栈在汇编语言程序中，经常用于重要数据的现场保护。栈中没有数据时，称为空栈。
队列(Queue)
队列和栈类似，也是一种特殊的线性表。和栈不同的是，队列只允许在表的一端进行插入操作，而在另一端进行删除操作。一般来说，进行插入操作的一端称为队尾，进行删除操作的一端称为队头。队列中没有元素时，称为空队列。
链表(Linked List)
链表是一种数据元素按照链式存储结构进行存储的数据结构，这种存储结构具有在物理上存在非连续的特点。链表由一系列数据结点构成，每个数据结点包括数据域和指针域两部分。其中，指针域保存了数据结构中下一个元素存放的地址。链表结构中数据元素的逻辑顺序是通过链表中的指针链接次序来实现的。
树(Tree)
树是典型的非线性结构，它是包括，2个结点的有穷集合K。在树结构中，有且仅有一个根结点，该结点没有前驱结点。在树结构中的其他结点都有且仅有一个前驱结点，而且可以有两个后继结点，m≥0。
图(Graph)
图是另一种非线性数据结构。在图结构中，数据结点一般称为顶点，而边是顶点的有序偶对。如果两个顶点之间存在一条边，那么就表示这两个顶点具有相邻关系。
堆(Heap)
堆是一种特殊的树形数据结构，一般讨论的堆都是二叉堆。堆的特点是根结点的值是所有结点中最小的或者最大的，并且根结点的两个子树也是一个堆结构。
散列表(Hash)
散列表源自于散列函数，其思想是如果在结构中存在关键字和T相等的记录，那么必定在F(T)的存储位置可以找到该记录，这样就可以不用进行比较操作而直接取得所查记录。
算法
特征
①有穷性
算法的有穷性是指算法必须能在执行有限个步骤之后终止；
②确定性
算法的每一步骤必须有确切的定义；
③可行性
算法中执行的任何计算步骤都是可以被分解为基本的可执行的操作步骤，即每个计算步骤都可以在有限时间内完成（也称之为有效性);
④有输入
一个算法有0个或多个输入，以刻画运算对象的初始情况，所谓0个输入是指算法本身定出了初始条件；
⑤有输出
一个算法有一个或多个输出，以反映对输入数据加工后的结果。没有输出的算法是毫无意义的。
设计原则
①正确性
一、程序语法错误。
二、程序对于几组输入数据能够得出满足需要的结果。
三、程序对于精心选择的、典型、苛刻切带有刁难性的几组输入数据能够得出满足要求的结果。
四、程序对于一切合法的输入数据都能得到满足要求的结果。
②可读性
③健壮性
当输入的数据非法时，算法应当恰当的做出反应或进行相应处理，而不是产生莫名其妙的输出结果。并且，处理出错的方法不应是中断程序执行，而是应当返回一个表示错误或错误性质的值，以便在更高的抽象层次上进行处理。
④高效率与低存储量需求
通常算法效率值得是算法执行时间；存储量是指算法执行过程中所需要的最大存储空间，两者都与问题的规模有关。
经典的算法面试题
暴力匹配【简单，但效率低】
KMP算法《部分匹配表》
汉诺塔游戏：分治算法
class Hannuo{
public static void main(String[] args){
//盘子的个数 出发 中间 目的
hanno(3,"X","Y","Z");
}
public static void hanno(int n,String begin,String mid,String end){
if(n==1){
System.out.println(begin+" -> "+end);
}else{
hanno(n-1,begin,end,mid);
System.out.println(begin+" -> "+end);
hanno(n-1,mid,begin,end);
}
}
}
八皇后问题：回溯算法
package eightQuen;
/**
* 八皇后问题
*
* @author 83771
*
*/
public class eight {
// 定义一个数组 表示棋盘
public static Integer[][] checkerBoard = new Integer[8][8];
// 棋盘副本
public static Integer[][] checkerBoardCopy = new Integer[8][8];
// 计数器 用于计数有多少种方法
public static Integer jishu = 1;
// 定义横竖斜方向上是否有棋子
public static boolean flag1 = true;
public static boolean flag2 = true;
public static boolean flag3 = true;
public static boolean flag4 = true;
// 初始化一个棋盘 8x8
public static void init() {
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
System.out.print(0 + " ");
checkerBoard[i][j] = 0;
}
System.out.println();
}
checkerBoardCopy = checkerBoard;
}
// 递归测试方法
public static void startTest(int row) {
for (int col = 0; col < 8; col++) {
if (checkCheet(row, col, checkerBoardCopy) == 1) {
if (row < 7) {
startTest(++row);
--row;
}
}
// 该行重新赋值为0 进行下一次判断
checkerBoardCopy[row][col] = 0;
}
}
// 检查是否危险
// row行
// col列
public static int checkCheet(int row, int col, Integer[][] checkerBoardCopy) {
flag1 = true;
flag2 = true;
flag3 = true;
flag4 = true;
// 行方向上是否满足条件
for (int i = 0; i < 8; i++) {
if (checkerBoardCopy[row][i] == 1) {
flag1 = false;
break;
}
}
// 列方向上是否满足条件
for (int j = 0; j < 8; j++) {
if (checkerBoardCopy[j][col] == 1) {
flag2 = false;
break;
}
}
// 右下方向
for (int i = row, j = col; i < 8 & j < 8; i++, j++) {
if (checkerBoardCopy[i][j] == 1) {
flag3 = false;
break;
}
}
// 左上方向
for (int i = row, j = col; i >= 0 & j >= 0; i--, j--) {
if (checkerBoardCopy[i][j] == 1) {
flag3 = false;
break;
}
}
// 左下方向
for (int i = row, j = col; i < 8 & j >= 0; i++, j--) {
if (checkerBoardCopy[i][j] == 1) {
flag4 = false;
break;
}
}
// 右上方向
for (int i = row, j = col; i >= 0 & j < 8; i--, j++) {
if (checkerBoardCopy[i][j] == 1) {
flag4 = false;
break;
}
}
if (flag1 & flag2 & flag3 & flag4) {
// 若为真 增此点的值赋为1
checkerBoardCopy[row][col] = 1;
// 如果已经判断到最后一行 并且最后一行也符合情况 打印整个棋盘
if (row == 7) {
printCheets(checkerBoardCopy);
}
return 1;
}
return 0;
}
// 打印棋盘方法
public static void printCheets(Integer[][] checkerBoardCopy) {
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
System.out.print(checkerBoardCopy[i][j] + " ");
}
System.out.println();
}
System.out.println("=================" + jishu++);
}
public static void main(String[] args) {
init();
startTest(0);
}
}
任意两个皇后都不能处于同一行、同一列或同一斜线上，一共有92种摆法。
马踏棋盘算法：图的深度优化遍历算法(DFS)+贪心算法优化
package com.zzl;
import java.util.Scanner;
/**
* 1.问题描述 在国际象棋中，马只能走日，但是马位于不同的方位可以走的方向有所区别
* 当马位于棋盘中间位置的时候
*
*
*/
public class 马踏棋盘问题求解 {
//马能走的8个方向
static int weizhi[][] = {{-2,1},{-2,-1},{-1,2},{-1,-2},{1,2},{1,-2},{2,1},{2,-1}};
static int step = 1;//先走哪一步，步数
static int qipan[][] = new int[5][4];
static int count = 0;
public static void main(String[] args) {
//初始化棋盘
for(int i=0;i<qipan.length;i++){
for(int j=0;j<qipan[i].length;j++){
qipan[i][j] = 0;
}
}
//输入起始位置，起始位置从1,1开始算 ，计算机数组从0,0开始算，所以x--，y--；
Scanner scn = new Scanner(System.in);
System.out.println("请输入棋盘马起始位置:");
int x = scn.nextInt();
int y = scn.nextInt();
qipan[x][y] = step;
step++;
move(x,y);
System.out.println("共有" + count + "种方案");
}
public static void move(int x, int y) {
int next_x = 0;
int next_y = 0;
if(step>20){
for(int i=0;i<5;i++){
for(int j=0;j<4;j++){
System.out.printf("%5d",qipan[i][j]);
}
System.out.println();
}
System.out.println("==========================");
count ++;
return;
}else{
for(int i=0;i<8;i++){
next_x = x + weizhi[i][0];
next_y = y + weizhi[i][1];
//下一步棋满足条件
if(next_x>=0 && next_x<=4 && next_y>=0 && next_y<=3 && qipan[next_x][next_y] ==0){
qipan[next_x][next_y] = step;
step++;
move(next_x,next_y);
step--;
qipan[next_x][next_y] = 0;
}
}
}
}
}数据结构和算法的关系
数据结构是一门研究组织数据方式的学科，有了编程语言也就有了数据结构。学好数据结构可以编写出更加漂亮，更加有效率的代码。
要学习好数据结构就要多多考虑如何将生活中遇到的问题，用程序去实现解决。
程序=数据结构+算法
数据结构是算法的基础，换言之，想要学好算法，需要把数据结构学到位。
约瑟夫问题（丢手帕问题）
private static void lastPeople(int total, int k) {
//初始化人数，人数排号从1开始；
List<Integer> list = new ArrayList<Integer>();
for (int i = 1; i <= total; i++) {
list.add(i);
}
//从第target（数组下标）个开始重新数数；
int target = 0;
while (!list.isEmpty()) {
target = (target + k)%list.size();
//当target=0时，target-1就是-1了，数组越界，其意思就是返回倒数第一个元素，即list.size()-1；
if (target != 0) {
System.out.print(list.get(target-1)+" ");
list.remove(target-1);
target--;
}else {
System.out.print(list.get(list.size()-1)+" ");
list.remove(list.size()-1);
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
